@superatomai/sdk-node 0.0.2-mds → 0.0.3-mds

package/dist/index.mjs

@@ -1407,6 +1407,7 @@ var ThreadManager = class _ThreadManager {
 var QueryCache = class {
   constructor() {
     this.cache = /* @__PURE__ */ new Map();
+    this.queryIdCache = /* @__PURE__ */ new Map();
     this.ttlMs = 5 * 60 * 1e3;
     // Default: 5 minutes
     this.cleanupInterval = null;
@@ -1501,11 +1502,64 @@ var QueryCache = class {
           expiredCount++;
         }
       }
+      for (const [key, entry] of this.queryIdCache.entries()) {
+        if (now - entry.timestamp > this.ttlMs) {
+          this.queryIdCache.delete(key);
+          expiredCount++;
+        }
+      }
       if (expiredCount > 0) {
         logger.debug(`[QueryCache] Cleaned up ${expiredCount} expired entries`);
       }
     }, 2 * 60 * 1e3);
   }
+  // ============================================
+  // Query ID Store — maps queryId → query (no SQL sent to frontend)
+  // ============================================
+  /**
+   * Generate a unique query ID
+   */
+  generateQueryId() {
+    return `qry_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 8)}`;
+  }
+  /**
+   * Store a query by ID. Returns the generated queryId.
+   * The query is stored server-side; only the queryId is sent to the frontend.
+   */
+  storeQuery(query, data) {
+    const queryId = this.generateQueryId();
+    this.queryIdCache.set(queryId, {
+      queryId,
+      query,
+      data: data || null,
+      timestamp: Date.now()
+    });
+    const queryPreview = typeof query === "string" ? query.substring(0, 50) : JSON.stringify(query).substring(0, 50);
+    logger.debug(`[QueryCache] Stored query as ${queryId} (${queryPreview}...)`);
+    return queryId;
+  }
+  /**
+   * Get a stored query by its ID (not expired)
+   */
+  getQuery(queryId) {
+    const entry = this.queryIdCache.get(queryId);
+    if (!entry) return null;
+    if (Date.now() - entry.timestamp > this.ttlMs) {
+      this.queryIdCache.delete(queryId);
+      return null;
+    }
+    return { query: entry.query, data: entry.data };
+  }
+  /**
+   * Update cached data for a queryId
+   */
+  setQueryData(queryId, data) {
+    const entry = this.queryIdCache.get(queryId);
+    if (entry) {
+      entry.data = data;
+      entry.timestamp = Date.now();
+    }
+  }
   /**
    * Stop cleanup interval (for graceful shutdown)
    */
@@ -1515,6 +1569,7 @@ var QueryCache = class {
       this.cleanupInterval = null;
     }
     this.cache.clear();
+    this.queryIdCache.clear();
   }
 };
 var queryCache = new QueryCache();
@@ -1877,6 +1932,24 @@ function getQueryCacheKey(query) {
   }
   return "";
 }
+function getCacheKey(collection, op, params) {
+  if (collection === "database" && op === "execute" && params?.sql) {
+    return getQueryCacheKey(params.sql);
+  }
+  if (collection === "external-tools" && op === "execute" && params?.sql) {
+    const toolId = params.toolId || "";
+    const sqlKey = getQueryCacheKey(params.sql);
+    const paramsKey = params.params ? JSON.stringify(params.params) : "";
+    return sqlKey ? `et:${toolId}:${sqlKey}:${paramsKey}` : "";
+  }
+  if (collection === "external-tools" && op === "executeByQueryId" && params?.queryId) {
+    const toolId = params.toolId || "";
+    const filterKey = params.filterParams ? JSON.stringify(params.filterParams) : "";
+    const paramsKey = params.params ? JSON.stringify(params.params) : "";
+    return `etq:${toolId}:${params.queryId}:${paramsKey}:${filterKey}`;
+  }
+  return "";
+}
 async function handleDataRequest(data, collections, sendMessage) {
   let requestId;
   let collection;
@@ -1903,31 +1976,26 @@ async function handleDataRequest(data, collections, sendMessage) {
     const startTime = performance.now();
     let result;
     let fromCache = false;
-    if (collection === "database" && op === "execute" && params?.sql) {
-      const cacheKey = getQueryCacheKey(params.sql);
-      if (cacheKey) {
-        const cachedResult = queryCache.get(cacheKey);
-        if (cachedResult !== null) {
-          result = cachedResult;
-          fromCache = true;
-          logger.info(`[QueryCache] Returning cached result for database.execute`);
-        }
+    const cacheKey = getCacheKey(collection, op, params);
+    if (cacheKey) {
+      const cachedResult = queryCache.get(cacheKey);
+      if (cachedResult !== null) {
+        result = cachedResult;
+        fromCache = true;
+        logger.info(`[QueryCache] Returning cached result for ${collection}.${op}`);
       }
     }
     if (!fromCache) {
       const handler = collections[collection][op];
       let handlerParams = params || {};
       if (collection === "database" && op === "execute" && params?.sql && typeof params.sql !== "string") {
-        const cacheKey = getQueryCacheKey(params.sql);
-        handlerParams = { ...params, sql: cacheKey };
+        const queryKey = getQueryCacheKey(params.sql);
+        handlerParams = { ...params, sql: queryKey };
         logger.debug(`[data-request] Converted object query to JSON string for database handler`);
       }
       result = await handler(handlerParams);
-      if (collection === "database" && op === "execute" && params?.sql && result) {
-        const cacheKey = getQueryCacheKey(params.sql);
-        if (cacheKey) {
-          queryCache.set(cacheKey, result);
-        }
+      if (cacheKey && result) {
+        queryCache.set(cacheKey, result);
       }
     }
     const executionMs = Math.round(performance.now() - startTime);
@@ -2472,9 +2540,6 @@ function sendDataResponse3(id, res, sendMessage, clientId) {
   sendMessage(response);
 }
 
-// src/userResponse/groq.ts
-import dotenv from "dotenv";
-
 // src/userResponse/prompt-loader.ts
 import fs3 from "fs";
 import path2 from "path";
@@ -3576,6 +3641,71 @@ You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 `,
     user: `{{USER_PROMPT}}`
   },
+  "agent-main": {
+    system: `You are a data analysis agent with access to multiple data sources.
+Answer the user's question by querying the appropriate data source(s) using the tools provided.
+
+## Available Data Sources
+{{SOURCE_SUMMARIES}}
+
+## How to Use Source Tools
+Each tool represents a data source. Call a tool with:
+- **intent**: Describe what data you need in natural language. Be specific about fields, filters, grouping, sorting, and limits. You can request both raw rows AND aggregated values in a single intent.
+- **aggregation** (optional): Default is "raw". Use "pre-aggregate" for totals/counts/averages, "summary" for high-level metrics.
+
+## Writing Good Intents
+Describe ALL your data needs in one intent per source. The source agent handles it in a single query.
+- You can combine raw rows and aggregated totals in one request
+- Be specific about which fields, filters, sorting, and grouping you need
+- Prefer a SINGLE call per source \u2014 only call again if the result was insufficient or incorrect
+
+## Rules
+- Call the appropriate source tool(s) to get data before answering
+- You can call multiple source tools if the question requires data from different sources
+- If a query returns insufficient or incorrect data, call the tool again with a modified intent
+- If the data is marked as LIMITED, mention it in your analysis (the full dataset may be larger)
+- After getting all needed data, provide a clear, concise analysis answering the question
+- For general questions (greetings, help, chitchat), respond directly without calling any tools
+- Be precise with numbers \u2014 use the exact values from the data
+- Maximum {{MAX_ROWS}} rows per source query
+
+## Current Date/Time
+{{CURRENT_DATETIME}}
+
+---
+
+## CONTEXT (for this specific request)
+
+### Conversation History
+{{CONVERSATION_HISTORY}}`,
+    user: `{{USER_PROMPT}}`
+  },
+  "agent-source-query": {
+    system: `You are a data source agent for "{{SOURCE_NAME}}" ({{SOURCE_TYPE}}).
+Your job is to fetch the requested data using the available tool.
+
+## Data Source Schema
+{{FULL_SCHEMA}}
+
+## Rules
+- Generate the most efficient query for the given intent
+- Always include a LIMIT of {{MAX_ROWS}} rows maximum
+- Aggregation mode is "{{AGGREGATION_MODE}}":
+  - "pre-aggregate": Use GROUP BY, COUNT, SUM, AVG etc. to return aggregated results instead of raw rows
+  - "summary": Return a high-level overview with key metrics
+  - "raw": Return individual records as-is
+- **Combined requests**: The intent may ask for both raw rows and aggregated values together. Handle this in a single query using the capabilities of the data source (e.g., UNION, window functions, subqueries for SQL sources)
+- Return ONLY the fields needed for the intent \u2014 avoid SELECT *
+- Use the tool provided to execute your query
+- If the query fails with an ERROR, analyze the error and try a corrected query
+- **IMPORTANT: If the tool returns data successfully, STOP. Do NOT call the tool again to get more rows or paginate. The returned data is sufficient.**
+- Call the tool exactly ONCE unless it returns an error that needs a corrected query
+
+## Current Date/Time
+{{CURRENT_DATETIME}}`,
+    user: `## Task
+{{INTENT}}`
+  },
   "dash-filter-picker": {
     system: `You are a dashboard filter expert that creates filter components and updates existing dashboard components to work with the filter.
 
@@ -4150,587 +4280,868 @@ function validateAndFixSqlQuery(query, dbType) {
   };
 }
 
-// src/userResponse/schema.ts
-import path3 from "path";
+// src/utils/user-prompt-error-logger.ts
 import fs4 from "fs";
-var Schema = class {
-  constructor(schemaFilePath) {
-    this.cachedSchema = null;
-    this.schemaFilePath = schemaFilePath || path3.join(process.cwd(), "../analysis/data/schema.json");
+import path3 from "path";
+var UserPromptErrorLogger = class {
+  constructor() {
+    this.logStream = null;
+    this.hasErrors = false;
+    this.logPath = process.env.USER_PROMPT_ERROR_LOG_PATH || path3.join(process.cwd(), "user-prompt-req-errors");
+    this.enabled = process.env.USER_PROMPT_ERROR_LOGGING !== "false";
   }
   /**
-   * Gets the database schema from the schema file
-   * @returns Parsed schema object or null if error occurs
+   * Reset the error log file for a new request
    */
-  getDatabaseSchema() {
+  resetLogFile(requestContext) {
+    if (!this.enabled) return;
     try {
-      const dir = path3.dirname(this.schemaFilePath);
-      if (!fs4.existsSync(dir)) {
-        logger.info(`Creating directory structure: ${dir}`);
-        fs4.mkdirSync(dir, { recursive: true });
+      if (this.logStream) {
+        this.logStream.end();
+        this.logStream = null;
       }
-      if (!fs4.existsSync(this.schemaFilePath)) {
-        logger.info(`Schema file does not exist at ${this.schemaFilePath}, creating with empty schema`);
-        const initialSchema = {
-          database: "",
-          schema: "",
-          description: "",
-          tables: [],
-          relationships: []
-        };
-        fs4.writeFileSync(this.schemaFilePath, JSON.stringify(initialSchema, null, 4));
-        this.cachedSchema = initialSchema;
-        return initialSchema;
+      const dir = path3.dirname(this.logPath);
+      if (dir !== "." && !fs4.existsSync(dir)) {
+        fs4.mkdirSync(dir, { recursive: true });
       }
-      const fileContent = fs4.readFileSync(this.schemaFilePath, "utf-8");
-      const schema2 = JSON.parse(fileContent);
-      this.cachedSchema = schema2;
-      return schema2;
+      this.logStream = fs4.createWriteStream(this.logPath, { flags: "w" });
+      this.hasErrors = false;
+      const header = `================================================================================
+USER PROMPT REQUEST ERROR LOG
+Request Started: ${(/* @__PURE__ */ new Date()).toISOString()}
+${requestContext ? `Context: ${requestContext}` : ""}
+================================================================================
+
+`;
+      this.logStream.write(header);
     } catch (error) {
-      logger.error("Error parsing schema file:", error);
-      return null;
+      console.error("[UserPromptErrorLogger] Failed to reset log file:", error);
     }
   }
   /**
-   * Gets the cached schema or loads it if not cached
-   * @returns Cached schema or freshly loaded schema
+   * Log a JSON parse error with the raw string that failed
    */
-  getSchema() {
-    if (this.cachedSchema) {
-      return this.cachedSchema;
-    }
-    return this.getDatabaseSchema();
+  logJsonParseError(context, rawString, error) {
+    if (!this.enabled) return;
+    this.hasErrors = true;
+    const entry = `
+--------------------------------------------------------------------------------
+[${(/* @__PURE__ */ new Date()).toISOString()}] JSON PARSE ERROR
+--------------------------------------------------------------------------------
+Context: ${context}
+Error: ${error.message}
+
+Raw String (${rawString.length} chars):
+--------------------------------------------------------------------------------
+${rawString}
+--------------------------------------------------------------------------------
+
+Stack Trace:
+${error.stack || "No stack trace available"}
+
+`;
+    this.write(entry);
+    console.error(`[UserPromptError] JSON Parse Error in ${context}: ${error.message}`);
   }
   /**
-   * Generates database schema documentation for LLM from Snowflake JSON schema
-   * @returns Formatted schema documentation string
+   * Log a general error with full details
    */
-  generateSchemaDocumentation() {
-    const schema2 = this.getSchema();
-    if (!schema2) {
-      logger.warn("No database schema found.");
-      return "No database schema available.";
-    }
-    const tables = [];
-    tables.push(`Database: ${schema2.database}`);
-    tables.push(`Schema: ${schema2.schema}`);
-    tables.push(`Description: ${schema2.description}`);
-    tables.push("");
-    tables.push("=".repeat(80));
-    tables.push("");
-    for (const table of schema2.tables) {
-      const tableInfo = [];
-      tableInfo.push(`TABLE: ${table.fullName}`);
-      tableInfo.push(`Description: ${table.description}`);
-      tableInfo.push(`Row Count: ~${table.rowCount.toLocaleString()}`);
-      tableInfo.push("");
-      tableInfo.push("Columns:");
-      for (const column of table.columns) {
-        let columnLine = `  - ${column.name}: ${column.type}`;
-        if (column.isPrimaryKey) {
-          columnLine += " (PRIMARY KEY)";
-        }
-        if (column.isForeignKey && column.references) {
-          columnLine += ` (FK -> ${column.references.table}.${column.references.column})`;
-        }
-        if (!column.nullable) {
-          columnLine += " NOT NULL";
-        }
-        if (column.description) {
-          columnLine += ` - ${column.description}`;
-        }
-        tableInfo.push(columnLine);
-        if (column.sampleValues && column.sampleValues.length > 0) {
-          tableInfo.push(`    Sample values: [${column.sampleValues.join(", ")}]`);
-        }
-        if (column.statistics) {
-          const stats = column.statistics;
-          if (stats.min !== void 0 && stats.max !== void 0) {
-            tableInfo.push(`    Range: ${stats.min} to ${stats.max}`);
-          }
-          if (stats.distinct !== void 0) {
-            tableInfo.push(`    Distinct values: ${stats.distinct.toLocaleString()}`);
-          }
-        }
-      }
-      tableInfo.push("");
-      tables.push(tableInfo.join("\n"));
+  logError(context, error, additionalData) {
+    if (!this.enabled) return;
+    this.hasErrors = true;
+    const errorMessage = error instanceof Error ? error.message : error;
+    const errorStack = error instanceof Error ? error.stack : void 0;
+    let entry = `
+--------------------------------------------------------------------------------
+[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR
+--------------------------------------------------------------------------------
+Context: ${context}
+Error: ${errorMessage}
+`;
+    if (additionalData) {
+      entry += `
+Additional Data:
+${JSON.stringify(additionalData, null, 2)}
+`;
     }
-    tables.push("=".repeat(80));
-    tables.push("");
-    tables.push("TABLE RELATIONSHIPS:");
-    tables.push("");
-    for (const rel of schema2.relationships) {
-      tables.push(`${rel.from} -> ${rel.to} (${rel.type}): ${rel.keys.join(" = ")}`);
+    if (errorStack) {
+      entry += `
+Stack Trace:
+${errorStack}
+`;
     }
-    return tables.join("\n");
+    entry += `--------------------------------------------------------------------------------
+
+`;
+    this.write(entry);
+    console.error(`[UserPromptError] ${context}: ${errorMessage}`);
   }
   /**
-   * Clears the cached schema, forcing a reload on next access
+   * Log a SQL query error with the full query
    */
-  clearCache() {
-    this.cachedSchema = null;
+  logSqlError(query, error, params) {
+    if (!this.enabled) return;
+    this.hasErrors = true;
+    const errorMessage = error instanceof Error ? error.message : error;
+    const entry = `
+--------------------------------------------------------------------------------
+[${(/* @__PURE__ */ new Date()).toISOString()}] SQL QUERY ERROR
+--------------------------------------------------------------------------------
+Error: ${errorMessage}
+
+Query (${query.length} chars):
+--------------------------------------------------------------------------------
+${query}
+--------------------------------------------------------------------------------
+${params ? `
+Parameters: ${JSON.stringify(params)}` : ""}
+
+`;
+    this.write(entry);
+    console.error(`[UserPromptError] SQL Error: ${errorMessage}`);
   }
   /**
-   * Sets a custom schema file path
-   * @param filePath - Path to the schema file
+   * Log an LLM API error
    */
-  setSchemaPath(filePath) {
-    this.schemaFilePath = filePath;
-    this.clearCache();
-  }
-};
-var schema = new Schema();
-
-// src/llm.ts
-import Anthropic from "@anthropic-ai/sdk";
-import Groq from "groq-sdk";
-import { GoogleGenerativeAI, SchemaType } from "@google/generative-ai";
-import OpenAI from "openai";
-import { jsonrepair } from "jsonrepair";
-
-// src/utils/llm-usage-logger.ts
-import fs5 from "fs";
-import path4 from "path";
-var PRICING = {
-  // Anthropic (December 2025)
-  "claude-opus-4-5": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-  "claude-opus-4-5-20251101": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-  "claude-sonnet-4-5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-  "claude-sonnet-4-5-20250929": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
-  "claude-haiku-4-5-20251001": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
-  "claude-3-5-sonnet-20241022": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-  "claude-3-5-haiku-20241022": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
-  "claude-3-opus-20240229": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
-  "claude-3-sonnet-20240229": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-  "claude-3-haiku-20240307": { input: 0.25, output: 1.25, cacheRead: 0.03, cacheWrite: 0.3 },
-  // OpenAI (December 2025)
-  "gpt-5": { input: 1.25, output: 10 },
-  "gpt-5-mini": { input: 0.25, output: 2 },
-  "gpt-4o": { input: 5, output: 15 },
-  // Updated pricing as of late 2025
-  "gpt-4o-mini": { input: 0.15, output: 0.6 },
-  "gpt-4-turbo": { input: 10, output: 30 },
-  "gpt-4": { input: 30, output: 60 },
-  "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
-  // Google Gemini (January 2026)
-  "gemini-3-pro-preview": { input: 2, output: 12 },
-  // New Gemini 3
-  "gemini-3-flash-preview": { input: 0.5, output: 3 },
-  // For prompts ≤200K tokens, 2x for >200K
-  "gemini-2.5-flash": { input: 0.3, output: 2.5 },
-  // Paid tier: $0.30 input (text/image/video), $2.50 output (includes thinking)
-  "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
-  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
-  "gemini-2.0-flash-lite": { input: 0.075, output: 0.3 },
-  "gemini-1.5-pro": { input: 1.25, output: 5 },
-  "gemini-1.5-flash": { input: 0.075, output: 0.3 },
-  // Groq (December 2025)
-  "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 },
-  "llama-3.1-70b-versatile": { input: 0.59, output: 0.79 },
-  "llama-3.1-8b-instant": { input: 0.05, output: 0.08 },
-  "llama-4-scout-17b-16e": { input: 0.11, output: 0.34 },
-  "llama-4-maverick-17b-128e": { input: 0.2, output: 0.6 },
-  "mixtral-8x7b-32768": { input: 0.27, output: 0.27 },
-  "qwen3-32b": { input: 0.29, output: 0.59 }
-};
-var DEFAULT_PRICING = { input: 3, output: 15 };
-var LLMUsageLogger = class {
-  constructor() {
-    this.logStream = null;
-    this.sessionStats = {
-      totalCalls: 0,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalCacheReadTokens: 0,
-      totalCacheWriteTokens: 0,
-      totalCostUSD: 0,
-      totalDurationMs: 0
-    };
-    this.logPath = process.env.LLM_USAGE_LOG_PATH || path4.join(process.cwd(), "llm-usage-logs");
-    this.enabled = process.env.LLM_USAGE_LOGGING !== "false";
-    if (this.enabled) {
-      this.initLogStream();
+  logLlmError(provider, model, method, error, requestData) {
+    if (!this.enabled) return;
+    this.hasErrors = true;
+    const errorMessage = error instanceof Error ? error.message : error;
+    const errorStack = error instanceof Error ? error.stack : void 0;
+    let entry = `
+--------------------------------------------------------------------------------
+[${(/* @__PURE__ */ new Date()).toISOString()}] LLM API ERROR
+--------------------------------------------------------------------------------
+Provider: ${provider}
+Model: ${model}
+Method: ${method}
+Error: ${errorMessage}
+`;
+    if (requestData) {
+      const dataStr = JSON.stringify(requestData, null, 2);
+      const truncated = dataStr.length > 5e3 ? dataStr.substring(0, 5e3) + "\n... [truncated]" : dataStr;
+      entry += `
+Request Data:
+${truncated}
+`;
     }
-  }
-  initLogStream() {
-    try {
-      const dir = path4.dirname(this.logPath);
-      if (!fs5.existsSync(dir)) {
-        fs5.mkdirSync(dir, { recursive: true });
-      }
-      this.logStream = fs5.createWriteStream(this.logPath, { flags: "a" });
-      if (!fs5.existsSync(this.logPath) || fs5.statSync(this.logPath).size === 0) {
-        this.writeHeader();
-      }
-    } catch (error) {
-      console.error("[LLM-Usage-Logger] Failed to initialize log stream:", error);
-      this.enabled = false;
+    if (errorStack) {
+      entry += `
+Stack Trace:
+${errorStack}
+`;
     }
-  }
-  writeHeader() {
-    const header = `
-================================================================================
-LLM USAGE LOG - Session Started: ${(/* @__PURE__ */ new Date()).toISOString()}
-================================================================================
-Format: [TIMESTAMP] [REQUEST_ID] [PROVIDER/MODEL] [METHOD]
-        Tokens: IN=input OUT=output CACHE_R=cache_read CACHE_W=cache_write TOTAL=total
-        Cost: $X.XXXXXX | Time: Xms
-================================================================================
+    entry += `--------------------------------------------------------------------------------
 
 `;
-    this.logStream?.write(header);
-  }
-  /**
-   * Calculate cost based on token usage and model
-   */
-  calculateCost(model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0) {
-    let pricing = PRICING[model];
-    if (!pricing) {
-      const modelLower = model.toLowerCase();
-      for (const [key, value] of Object.entries(PRICING)) {
-        if (modelLower.includes(key.toLowerCase()) || key.toLowerCase().includes(modelLower)) {
-          pricing = value;
-          break;
-        }
-      }
-    }
-    pricing = pricing || DEFAULT_PRICING;
-    const inputCost = inputTokens / 1e6 * pricing.input;
-    const outputCost = outputTokens / 1e6 * pricing.output;
-    const cacheReadCost = cacheReadTokens / 1e6 * (pricing.cacheRead || pricing.input * 0.1);
-    const cacheWriteCost = cacheWriteTokens / 1e6 * (pricing.cacheWrite || pricing.input * 1.25);
-    return inputCost + outputCost + cacheReadCost + cacheWriteCost;
+    this.write(entry);
+    console.error(`[UserPromptError] LLM Error (${provider}/${model}): ${errorMessage}`);
   }
   /**
-   * Log an LLM API call
+   * Log tool execution error
    */
-  log(entry) {
+  logToolError(toolName, toolInput, error) {
     if (!this.enabled) return;
-    this.sessionStats.totalCalls++;
-    this.sessionStats.totalInputTokens += entry.inputTokens;
-    this.sessionStats.totalOutputTokens += entry.outputTokens;
-    this.sessionStats.totalCacheReadTokens += entry.cacheReadTokens || 0;
-    this.sessionStats.totalCacheWriteTokens += entry.cacheWriteTokens || 0;
-    this.sessionStats.totalCostUSD += entry.costUSD;
-    this.sessionStats.totalDurationMs += entry.durationMs;
-    const cacheInfo = entry.cacheReadTokens || entry.cacheWriteTokens ? ` CACHE_R=${entry.cacheReadTokens || 0} CACHE_W=${entry.cacheWriteTokens || 0}` : "";
-    const toolInfo = entry.toolCalls ? ` | Tools: ${entry.toolCalls}` : "";
-    const errorInfo = entry.error ? ` | ERROR: ${entry.error}` : "";
-    const status = entry.success ? "\u2713" : "\u2717";
-    let cacheStatus = "";
-    if (entry.cacheReadTokens && entry.cacheReadTokens > 0) {
-      const savedCost = entry.cacheReadTokens / 1e6 * 2.7;
-      cacheStatus = ` \u26A1 CACHE HIT! Saved ~$${savedCost.toFixed(4)}`;
-    } else if (entry.cacheWriteTokens && entry.cacheWriteTokens > 0) {
-      cacheStatus = " \u{1F4DD} Cache created (next request will be cheaper)";
-    }
-    const logLine = `[${entry.timestamp}] [${entry.requestId}] ${status} ${entry.provider}/${entry.model} [${entry.method}]
-    Tokens: IN=${entry.inputTokens} OUT=${entry.outputTokens}${cacheInfo} TOTAL=${entry.totalTokens}
-    Cost: $${entry.costUSD.toFixed(6)} | Time: ${entry.durationMs}ms${toolInfo}${errorInfo}${cacheStatus}
-`;
-    this.logStream?.write(logLine);
-  }
-  /**
-   * Log session summary (call at end of request)
-   */
-  logSessionSummary(requestContext) {
-    if (!this.enabled || this.sessionStats.totalCalls === 0) return;
-    const cacheReadSavings = this.sessionStats.totalCacheReadTokens / 1e6 * 2.7;
-    const hasCaching = this.sessionStats.totalCacheReadTokens > 0 || this.sessionStats.totalCacheWriteTokens > 0;
-    let cacheSection = "";
-    if (hasCaching) {
-      cacheSection = `
-Cache Statistics:
-  Cache Read Tokens: ${this.sessionStats.totalCacheReadTokens.toLocaleString()}${this.sessionStats.totalCacheReadTokens > 0 ? " \u26A1" : ""}
-  Cache Write Tokens: ${this.sessionStats.totalCacheWriteTokens.toLocaleString()}${this.sessionStats.totalCacheWriteTokens > 0 ? " \u{1F4DD}" : ""}
-  Estimated Savings: $${cacheReadSavings.toFixed(4)}`;
-    }
-    const summary = `
+    this.hasErrors = true;
+    const errorMessage = error instanceof Error ? error.message : error;
+    const errorStack = error instanceof Error ? error.stack : void 0;
+    const entry = `
 --------------------------------------------------------------------------------
-SESSION SUMMARY${requestContext ? ` (${requestContext})` : ""}
+[${(/* @__PURE__ */ new Date()).toISOString()}] TOOL EXECUTION ERROR
 --------------------------------------------------------------------------------
-Total LLM Calls: ${this.sessionStats.totalCalls}
-Total Input Tokens: ${this.sessionStats.totalInputTokens.toLocaleString()}
-Total Output Tokens: ${this.sessionStats.totalOutputTokens.toLocaleString()}
-Total Tokens: ${(this.sessionStats.totalInputTokens + this.sessionStats.totalOutputTokens).toLocaleString()}
-Total Cost: $${this.sessionStats.totalCostUSD.toFixed(6)}
-Total Time: ${this.sessionStats.totalDurationMs}ms (${(this.sessionStats.totalDurationMs / 1e3).toFixed(2)}s)
-Avg Cost/Call: $${(this.sessionStats.totalCostUSD / this.sessionStats.totalCalls).toFixed(6)}
-Avg Time/Call: ${Math.round(this.sessionStats.totalDurationMs / this.sessionStats.totalCalls)}ms${cacheSection}
+Tool: ${toolName}
+Error: ${errorMessage}
+
+Tool Input:
+${JSON.stringify(toolInput, null, 2)}
+${errorStack ? `
+Stack Trace:
+${errorStack}` : ""}
 --------------------------------------------------------------------------------
 
 `;
-    this.logStream?.write(summary);
-  }
-  /**
-   * Reset session stats (call at start of new user request)
-   */
-  resetSession() {
-    this.sessionStats = {
-      totalCalls: 0,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalCacheReadTokens: 0,
-      totalCacheWriteTokens: 0,
-      totalCostUSD: 0,
-      totalDurationMs: 0
-    };
+    this.write(entry);
+    console.error(`[UserPromptError] Tool Error (${toolName}): ${errorMessage}`);
   }
   /**
-   * Reset the log file for a new request (clears previous logs)
-   * Call this at the start of each USER_PROMPT_REQ
+   * Write final summary if there were errors
    */
-  resetLogFile(requestContext) {
-    if (!this.enabled) return;
-    try {
-      if (this.logStream) {
-        this.logStream.end();
-        this.logStream = null;
-      }
-      this.logStream = fs5.createWriteStream(this.logPath, { flags: "w" });
-      const header = `
-================================================================================
-LLM USAGE LOG - Request Started: ${(/* @__PURE__ */ new Date()).toISOString()}
-${requestContext ? `Context: ${requestContext}` : ""}
+  writeSummary() {
+    if (!this.enabled || !this.hasErrors) return;
+    const summary = `
 ================================================================================
-Format: [TIMESTAMP] [REQUEST_ID] [PROVIDER/MODEL] [METHOD]
-        Tokens: IN=input OUT=output CACHE_R=cache_read CACHE_W=cache_write TOTAL=total
-        Cost: $X.XXXXXX | Time: Xms
+REQUEST COMPLETED WITH ERRORS
+Time: ${(/* @__PURE__ */ new Date()).toISOString()}
 ================================================================================
-
 `;
-      this.logStream.write(header);
-      this.resetSession();
-    } catch (error) {
-      console.error("[LLM-Usage-Logger] Failed to reset log file:", error);
-    }
-  }
-  /**
-   * Get current session stats
-   */
-  getSessionStats() {
-    return { ...this.sessionStats };
+    this.write(summary);
   }
   /**
-   * Generate a unique request ID
+   * Check if any errors were logged
    */
-  generateRequestId() {
-    return `req-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+  hadErrors() {
+    return this.hasErrors;
   }
-};
-var llmUsageLogger = new LLMUsageLogger();
+  write(content) {
+    if (this.logStream) {
+      this.logStream.write(content);
+    }
+  }
+};
+var userPromptErrorLogger = new UserPromptErrorLogger();
+
+// src/utils/bm25l-reranker.ts
+var BM25L = class {
+  /**
+   * @param documents - Array of raw documents (strings)
+   * @param opts - Optional BM25L parameters
+   */
+  constructor(documents = [], opts = {}) {
+    if (!Array.isArray(documents)) {
+      throw new Error("BM25L: documents must be an array of strings.");
+    }
+    this.k1 = typeof opts.k1 === "number" ? opts.k1 : 1.5;
+    this.b = typeof opts.b === "number" ? opts.b : 0.75;
+    this.delta = typeof opts.delta === "number" ? opts.delta : 0.5;
+    this.documents = documents.map((d) => typeof d === "string" ? this.tokenize(d) : []);
+    this.docLengths = this.documents.map((doc) => doc.length);
+    this.avgDocLength = this.docLengths.reduce((a, b) => a + b, 0) / (this.docLengths.length || 1);
+    this.termDocFreq = {};
+    this.documents.forEach((doc) => {
+      const seen = /* @__PURE__ */ new Set();
+      doc.forEach((term) => {
+        if (!seen.has(term)) {
+          seen.add(term);
+          this.termDocFreq[term] = (this.termDocFreq[term] || 0) + 1;
+        }
+      });
+    });
+  }
+  /**
+   * Tokenize text into lowercase alphanumeric tokens
+   */
+  tokenize(text) {
+    if (typeof text !== "string") return [];
+    return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean);
+  }
+  /**
+   * Compute IDF (Inverse Document Frequency) with smoothing
+   */
+  idf(term) {
+    const df = this.termDocFreq[term] || 0;
+    const N = this.documents.length || 1;
+    return Math.log(1 + (N - df + 0.5) / (df + 0.5));
+  }
+  /**
+   * Compute BM25L score for a single document
+   */
+  score(query, docIndex) {
+    if (typeof query !== "string") return 0;
+    if (docIndex < 0 || docIndex >= this.documents.length) return 0;
+    const tokens = this.tokenize(query);
+    if (tokens.length === 0) return 0;
+    const doc = this.documents[docIndex];
+    const docLength = this.docLengths[docIndex] || 1;
+    const freq = {};
+    for (const t of doc) {
+      freq[t] = (freq[t] || 0) + 1;
+    }
+    let sum = 0;
+    for (const term of tokens) {
+      const tf = freq[term] || 0;
+      if (tf === 0) continue;
+      const idfVal = this.idf(term);
+      let tfL = tf - this.b * (docLength / this.avgDocLength) + this.delta;
+      if (tfL < 0) tfL = 0;
+      sum += idfVal * (tfL / (this.k1 + tfL));
+    }
+    return sum;
+  }
+  /**
+   * Search and rank all documents
+   */
+  search(query) {
+    return this.documents.map((_, i) => ({
+      index: i,
+      score: this.score(query, i)
+    })).sort((a, b) => b.score - a.score);
+  }
+};
+function normalizeScores(scores) {
+  if (scores.length === 0) return [];
+  const min = Math.min(...scores);
+  const max = Math.max(...scores);
+  if (max === min) {
+    return scores.map(() => max === 0 ? 0 : 1);
+  }
+  return scores.map((score) => (score - min) / (max - min));
+}
+function hybridRerank(query, items, getDocument, getSemanticScore, options = {}) {
+  const {
+    semanticWeight = 0.7,
+    bm25Weight = 0.3,
+    minScore = 0,
+    k1 = 1.5,
+    b = 0.75,
+    delta = 0.5
+  } = options;
+  if (items.length === 0) return [];
+  const documents = items.map(getDocument);
+  const semanticScores = items.map(getSemanticScore);
+  const bm25 = new BM25L(documents, { k1, b, delta });
+  const bm25Scores = items.map((_, i) => bm25.score(query, i));
+  const normalizedSemantic = normalizeScores(semanticScores);
+  const normalizedBM25 = normalizeScores(bm25Scores);
+  const results = items.map((item, i) => {
+    const hybridScore = semanticWeight * normalizedSemantic[i] + bm25Weight * normalizedBM25[i];
+    return {
+      item,
+      originalIndex: i,
+      semanticScore: semanticScores[i],
+      bm25Score: bm25Scores[i],
+      hybridScore
+    };
+  });
+  return results.filter((r) => r.hybridScore >= minScore).sort((a, b2) => b2.hybridScore - a.hybridScore);
+}
+function rerankChromaResults(query, chromaResults, options = {}) {
+  const ids = chromaResults.ids[0] || [];
+  const documents = chromaResults.documents[0] || [];
+  const metadatas = chromaResults.metadatas[0] || [];
+  const distances = chromaResults.distances[0] || [];
+  if (ids.length === 0) return [];
+  const items = ids.map((id, i) => ({
+    id,
+    document: documents[i],
+    metadata: metadatas[i],
+    distance: distances[i]
+  }));
+  const reranked = hybridRerank(
+    query,
+    items,
+    (item) => item.document || "",
+    // Convert L2 distance to similarity score
+    (item) => 1 / (1 + item.distance),
+    options
+  );
+  return reranked.map((r) => ({
+    id: r.item.id,
+    document: r.item.document,
+    metadata: r.item.metadata,
+    distance: r.item.distance,
+    semanticScore: r.semanticScore,
+    bm25Score: r.bm25Score,
+    hybridScore: r.hybridScore
+  }));
+}
+function rerankConversationResults(query, results, options = {}) {
+  if (results.length === 0) return [];
+  const reranked = hybridRerank(
+    query,
+    results,
+    (item) => item.userPrompt || "",
+    (item) => item.similarity || 0,
+    options
+  );
+  return reranked.map((r) => ({
+    ...r.item,
+    hybridScore: r.hybridScore,
+    bm25Score: r.bm25Score
+  }));
+}
+
+// src/userResponse/conversation-search.ts
+var searchConversations = async ({
+  userPrompt,
+  collections,
+  userId,
+  similarityThreshold = 0.6
+}) => {
+  try {
+    if (!collections || !collections["conversation-history"] || !collections["conversation-history"]["search"]) {
+      logger.info("[ConversationSearch] conversation-history.search collection not registered, skipping");
+      return null;
+    }
+    logger.info(`[ConversationSearch] Searching conversations for: "${userPrompt.substring(0, 50)}..."`);
+    logger.info(`[ConversationSearch] Using similarity threshold: ${(similarityThreshold * 100).toFixed(0)}%`);
+    const result = await collections["conversation-history"]["search"]({
+      userPrompt,
+      userId,
+      threshold: similarityThreshold
+    });
+    if (!result) {
+      logger.info("[ConversationSearch] No matching conversations found");
+      return null;
+    }
+    if (!result.uiBlock) {
+      logger.error("[ConversationSearch] No UI block in conversation search result");
+      return null;
+    }
+    const similarity = result.similarity || 0;
+    logger.info(`[ConversationSearch] Best match similarity: ${(similarity * 100).toFixed(2)}%`);
+    if (similarity < similarityThreshold) {
+      logger.info(
+        `[ConversationSearch] Best match has similarity ${(similarity * 100).toFixed(2)}% but below threshold ${(similarityThreshold * 100).toFixed(2)}%`
+      );
+      return null;
+    }
+    logger.info(
+      `[ConversationSearch] Found matching conversation with similarity ${(similarity * 100).toFixed(2)}%`
+    );
+    logger.debug(`[ConversationSearch] Matched prompt: "${result.metadata?.userPrompt?.substring(0, 50)}..."`);
+    return result;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.warn(`[ConversationSearch] Error searching conversations: ${errorMsg}`);
+    return null;
+  }
+};
+var searchConversationsWithReranking = async (options) => {
+  const {
+    userPrompt,
+    collections,
+    userId,
+    similarityThreshold = 0.6,
+    rerankCandidates = 50,
+    // Fetch more candidates for better reranking
+    hybridOptions = {
+      semanticWeight: 0.7,
+      bm25Weight: 0.3
+    }
+  } = options;
+  try {
+    if (!collections || !collections["conversation-history"]) {
+      logger.warn("[ConversationSearch] conversation-history collection not registered, skipping");
+      return null;
+    }
+    if (!collections["conversation-history"]["searchMultiple"]) {
+      logger.warn("[ConversationSearch] searchMultiple not available, falling back to standard search");
+      return searchConversations({
+        userPrompt,
+        collections,
+        userId,
+        similarityThreshold
+      });
+    }
+    const results = await collections["conversation-history"]["searchMultiple"]({
+      userPrompt,
+      userId,
+      limit: rerankCandidates,
+      threshold: 0
+      // No threshold - get all candidates for reranking
+    });
+    if (!results || results.length === 0) {
+      logger.info("[ConversationSearch] No conversations found in database");
+      return null;
+    }
+    logger.info(`[ConversationSearch] Retrieved ${results.length} candidates for reranking`);
+    const candidatesForReranking = results.map((r) => ({
+      ...r,
+      userPrompt: r.metadata?.userPrompt || ""
+    }));
+    const reranked = rerankConversationResults(userPrompt, candidatesForReranking, hybridOptions);
+    if (reranked.length === 0) {
+      logger.info("[ConversationSearch] No results after reranking");
+      return null;
+    }
+    const best = reranked[0];
+    const hybridScore = best.hybridScore;
+    const semanticScore = best.similarity || 0;
+    const matchedUserPrompt = best.userPrompt || best.metadata?.userPrompt || "";
+    logger.info(`[ConversationSearch] Best match after reranking:`);
+    logger.info(`  - Hybrid score: ${(hybridScore * 100).toFixed(2)}%`);
+    logger.info(`  - Semantic score: ${(semanticScore * 100).toFixed(2)}%`);
+    logger.info(`  - BM25L score: ${best.bm25Score.toFixed(4)}`);
+    logger.info(`  - Matched prompt: "${matchedUserPrompt}"`);
+    logger.info(`  - Query prompt: "${userPrompt}"`);
+    if (semanticScore < similarityThreshold) {
+      logger.info(
+        `[ConversationSearch] Semantic score ${(semanticScore * 100).toFixed(2)}% below threshold ${(similarityThreshold * 100).toFixed(2)}% - rejecting match`
+      );
+      return null;
+    }
+    logger.info(
+      `[ConversationSearch] \u2713 Found match with semantic score ${(semanticScore * 100).toFixed(2)}%`
+    );
+    return {
+      uiBlock: best.uiBlock,
+      similarity: semanticScore,
+      hybridScore,
+      bm25Score: best.bm25Score,
+      metadata: best.metadata
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.warn(`[ConversationSearch] Error in hybrid search: ${errorMsg}`);
+    return null;
+  }
+};
+var ConversationSearch = {
+  searchConversations,
+  searchConversationsWithReranking
+};
+var conversation_search_default = ConversationSearch;
 
-// src/utils/user-prompt-error-logger.ts
-import fs6 from "fs";
-import path5 from "path";
-var UserPromptErrorLogger = class {
-  constructor() {
-    this.logStream = null;
-    this.hasErrors = false;
-    this.logPath = process.env.USER_PROMPT_ERROR_LOG_PATH || path5.join(process.cwd(), "user-prompt-req-errors");
-    this.enabled = process.env.USER_PROMPT_ERROR_LOGGING !== "false";
+// src/userResponse/constants.ts
+var MAX_QUERY_VALIDATION_RETRIES = 3;
+var MAX_QUERY_ATTEMPTS = 6;
+var MAX_TOOL_ATTEMPTS = 3;
+var STREAM_FLUSH_INTERVAL_MS = 50;
+var PROGRESS_HEARTBEAT_INTERVAL_MS = 800;
+var STREAM_DELAY_MS = 50;
+var STREAM_IMMEDIATE_FLUSH_THRESHOLD = 100;
+var MAX_TOKENS_QUERY_FIX = 2048;
+var MAX_TOKENS_COMPONENT_MATCHING = 8192;
+var MAX_TOKENS_CLASSIFICATION = 1500;
+var MAX_TOKENS_ADAPTATION = 8192;
+var MAX_TOKENS_TEXT_RESPONSE = 4e3;
+var MAX_TOKENS_NEXT_QUESTIONS = 1200;
+var DEFAULT_MAX_ROWS_FOR_LLM = 10;
+var DEFAULT_MAX_CHARS_PER_FIELD2 = 500;
+var STREAM_PREVIEW_MAX_ROWS = 10;
+var STREAM_PREVIEW_MAX_CHARS = 200;
+var TOOL_TRACKING_MAX_ROWS = 5;
+var TOOL_TRACKING_MAX_CHARS = 200;
+var TOOL_TRACKING_SAMPLE_ROWS = 3;
+var DEFAULT_QUERY_LIMIT = 10;
+var MAX_COMPONENT_QUERY_LIMIT = 10;
+var EXACT_MATCH_SIMILARITY_THRESHOLD = 0.99;
+var DEFAULT_CONVERSATION_SIMILARITY_THRESHOLD = 0.8;
+var MAX_TOOL_CALLING_ITERATIONS = 20;
+var KNOWLEDGE_BASE_TOP_K = 3;
+
+// src/userResponse/stream-buffer.ts
+var StreamBuffer = class {
+  constructor(callback) {
+    this.buffer = "";
+    this.flushTimer = null;
+    this.fullText = "";
+    this.callback = callback;
   }
   /**
-   * Reset the error log file for a new request
+   * Check if the buffer has a callback configured
    */
-  resetLogFile(requestContext) {
-    if (!this.enabled) return;
-    try {
-      if (this.logStream) {
-        this.logStream.end();
-        this.logStream = null;
-      }
-      const dir = path5.dirname(this.logPath);
-      if (dir !== "." && !fs6.existsSync(dir)) {
-        fs6.mkdirSync(dir, { recursive: true });
-      }
-      this.logStream = fs6.createWriteStream(this.logPath, { flags: "w" });
-      this.hasErrors = false;
-      const header = `================================================================================
-USER PROMPT REQUEST ERROR LOG
-Request Started: ${(/* @__PURE__ */ new Date()).toISOString()}
-${requestContext ? `Context: ${requestContext}` : ""}
-================================================================================
-
-`;
-      this.logStream.write(header);
-    } catch (error) {
-      console.error("[UserPromptErrorLogger] Failed to reset log file:", error);
+  hasCallback() {
+    return !!this.callback;
+  }
+  /**
+   * Get all text that has been written (including already flushed)
+   */
+  getFullText() {
+    return this.fullText;
+  }
+  /**
+   * Write a chunk to the buffer
+   * Large chunks or chunks with newlines are flushed immediately
+   * Small chunks are batched and flushed after a short interval
+   *
+   * @param chunk - Text chunk to write
+   */
+  write(chunk) {
+    this.fullText += chunk;
+    if (!this.callback) {
+      return;
+    }
+    this.buffer += chunk;
+    if (chunk.includes("\n") || chunk.length > STREAM_IMMEDIATE_FLUSH_THRESHOLD) {
+      this.flushNow();
+    } else if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => this.flushNow(), STREAM_FLUSH_INTERVAL_MS);
     }
   }
   /**
-   * Log a JSON parse error with the raw string that failed
+   * Flush the buffer immediately
+   * Call this before tool execution or other operations that need clean output
    */
-  logJsonParseError(context, rawString, error) {
-    if (!this.enabled) return;
-    this.hasErrors = true;
-    const entry = `
---------------------------------------------------------------------------------
-[${(/* @__PURE__ */ new Date()).toISOString()}] JSON PARSE ERROR
---------------------------------------------------------------------------------
-Context: ${context}
-Error: ${error.message}
-
-Raw String (${rawString.length} chars):
---------------------------------------------------------------------------------
-${rawString}
---------------------------------------------------------------------------------
-
-Stack Trace:
-${error.stack || "No stack trace available"}
-
-`;
-    this.write(entry);
-    console.error(`[UserPromptError] JSON Parse Error in ${context}: ${error.message}`);
+  flush() {
+    this.flushNow();
   }
   /**
-   * Log a general error with full details
+   * Internal flush implementation
    */
-  logError(context, error, additionalData) {
-    if (!this.enabled) return;
-    this.hasErrors = true;
-    const errorMessage = error instanceof Error ? error.message : error;
-    const errorStack = error instanceof Error ? error.stack : void 0;
-    let entry = `
---------------------------------------------------------------------------------
-[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR
---------------------------------------------------------------------------------
-Context: ${context}
-Error: ${errorMessage}
-`;
-    if (additionalData) {
-      entry += `
-Additional Data:
-${JSON.stringify(additionalData, null, 2)}
-`;
+  flushNow() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.buffer && this.callback) {
+      this.callback(this.buffer);
+      this.buffer = "";
+    }
+  }
+  /**
+   * Clean up resources
+   * Call this when done with the buffer
+   */
+  dispose() {
+    this.flush();
+    this.callback = void 0;
+  }
+};
+function streamDelay(ms = STREAM_DELAY_MS) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withProgressHeartbeat(operation, progressMessage, streamBuffer, intervalMs = PROGRESS_HEARTBEAT_INTERVAL_MS) {
+  if (!streamBuffer.hasCallback()) {
+    return operation();
+  }
+  const startTime = Date.now();
+  await streamDelay(30);
+  streamBuffer.write(`\u23F3 ${progressMessage}`);
+  const heartbeatInterval = setInterval(() => {
+    const elapsedSeconds = Math.floor((Date.now() - startTime) / 1e3);
+    if (elapsedSeconds >= 1) {
+      streamBuffer.write(` (${elapsedSeconds}s)`);
+    }
+  }, intervalMs);
+  try {
+    const result = await operation();
+    return result;
+  } finally {
+    clearInterval(heartbeatInterval);
+    streamBuffer.write("\n\n");
+  }
+}
+
+// src/llm.ts
+import Anthropic from "@anthropic-ai/sdk";
+import Groq from "groq-sdk";
+import { GoogleGenerativeAI, SchemaType } from "@google/generative-ai";
+import OpenAI from "openai";
+import { jsonrepair } from "jsonrepair";
+
+// src/utils/llm-usage-logger.ts
+import fs5 from "fs";
+import path4 from "path";
+var PRICING = {
+  // Anthropic (December 2025)
+  "claude-opus-4-5": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-5-20251101": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-sonnet-4-5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-4-5-20250929": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-haiku-4-5-20251001": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-3-5-haiku-20241022": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-3-opus-20240229": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-3-sonnet-20240229": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-3-haiku-20240307": { input: 0.25, output: 1.25, cacheRead: 0.03, cacheWrite: 0.3 },
+  // OpenAI (December 2025)
+  "gpt-5": { input: 1.25, output: 10 },
+  "gpt-5-mini": { input: 0.25, output: 2 },
+  "gpt-4o": { input: 5, output: 15 },
+  // Updated pricing as of late 2025
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-4": { input: 30, output: 60 },
+  "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+  // Google Gemini (January 2026)
+  "gemini-3-pro-preview": { input: 2, output: 12 },
+  // New Gemini 3
+  "gemini-3-flash-preview": { input: 0.5, output: 3 },
+  // For prompts ≤200K tokens, 2x for >200K
+  "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+  // Paid tier: $0.30 input (text/image/video), $2.50 output (includes thinking)
+  "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
+  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+  "gemini-2.0-flash-lite": { input: 0.075, output: 0.3 },
+  "gemini-1.5-pro": { input: 1.25, output: 5 },
+  "gemini-1.5-flash": { input: 0.075, output: 0.3 },
+  // Groq (December 2025)
+  "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 },
+  "llama-3.1-70b-versatile": { input: 0.59, output: 0.79 },
+  "llama-3.1-8b-instant": { input: 0.05, output: 0.08 },
+  "llama-4-scout-17b-16e": { input: 0.11, output: 0.34 },
+  "llama-4-maverick-17b-128e": { input: 0.2, output: 0.6 },
+  "mixtral-8x7b-32768": { input: 0.27, output: 0.27 },
+  "qwen3-32b": { input: 0.29, output: 0.59 }
+};
+var DEFAULT_PRICING = { input: 3, output: 15 };
+var LLMUsageLogger = class {
+  constructor() {
+    this.logStream = null;
+    this.sessionStats = {
+      totalCalls: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCacheReadTokens: 0,
+      totalCacheWriteTokens: 0,
+      totalCostUSD: 0,
+      totalDurationMs: 0
+    };
+    this.logPath = process.env.LLM_USAGE_LOG_PATH || path4.join(process.cwd(), "llm-usage-logs");
+    this.enabled = process.env.LLM_USAGE_LOGGING !== "false";
+    if (this.enabled) {
+      this.initLogStream();
     }
-    if (errorStack) {
-      entry += `
-Stack Trace:
-${errorStack}
-`;
+  }
+  initLogStream() {
+    try {
+      const dir = path4.dirname(this.logPath);
+      if (!fs5.existsSync(dir)) {
+        fs5.mkdirSync(dir, { recursive: true });
+      }
+      this.logStream = fs5.createWriteStream(this.logPath, { flags: "a" });
+      if (!fs5.existsSync(this.logPath) || fs5.statSync(this.logPath).size === 0) {
+        this.writeHeader();
+      }
+    } catch (error) {
+      console.error("[LLM-Usage-Logger] Failed to initialize log stream:", error);
+      this.enabled = false;
     }
-    entry += `--------------------------------------------------------------------------------
+  }
+  writeHeader() {
+    const header = `
+================================================================================
+LLM USAGE LOG - Session Started: ${(/* @__PURE__ */ new Date()).toISOString()}
+================================================================================
+Format: [TIMESTAMP] [REQUEST_ID] [PROVIDER/MODEL] [METHOD]
+        Tokens: IN=input OUT=output CACHE_R=cache_read CACHE_W=cache_write TOTAL=total
+        Cost: $X.XXXXXX | Time: Xms
+================================================================================
 
 `;
-    this.write(entry);
-    console.error(`[UserPromptError] ${context}: ${errorMessage}`);
+    this.logStream?.write(header);
   }
   /**
-   * Log a SQL query error with the full query
+   * Calculate cost based on token usage and model
    */
-  logSqlError(query, error, params) {
-    if (!this.enabled) return;
-    this.hasErrors = true;
-    const errorMessage = error instanceof Error ? error.message : error;
-    const entry = `
---------------------------------------------------------------------------------
-[${(/* @__PURE__ */ new Date()).toISOString()}] SQL QUERY ERROR
---------------------------------------------------------------------------------
-Error: ${errorMessage}
-
-Query (${query.length} chars):
---------------------------------------------------------------------------------
-${query}
---------------------------------------------------------------------------------
-${params ? `
-Parameters: ${JSON.stringify(params)}` : ""}
-
-`;
-    this.write(entry);
-    console.error(`[UserPromptError] SQL Error: ${errorMessage}`);
+  calculateCost(model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0) {
+    let pricing = PRICING[model];
+    if (!pricing) {
+      const modelLower = model.toLowerCase();
+      for (const [key, value] of Object.entries(PRICING)) {
+        if (modelLower.includes(key.toLowerCase()) || key.toLowerCase().includes(modelLower)) {
+          pricing = value;
+          break;
+        }
+      }
+    }
+    pricing = pricing || DEFAULT_PRICING;
+    const inputCost = inputTokens / 1e6 * pricing.input;
+    const outputCost = outputTokens / 1e6 * pricing.output;
+    const cacheReadCost = cacheReadTokens / 1e6 * (pricing.cacheRead || pricing.input * 0.1);
+    const cacheWriteCost = cacheWriteTokens / 1e6 * (pricing.cacheWrite || pricing.input * 1.25);
+    return inputCost + outputCost + cacheReadCost + cacheWriteCost;
   }
   /**
-   * Log an LLM API error
+   * Log an LLM API call
    */
-  logLlmError(provider, model, method, error, requestData) {
+  log(entry) {
     if (!this.enabled) return;
-    this.hasErrors = true;
-    const errorMessage = error instanceof Error ? error.message : error;
-    const errorStack = error instanceof Error ? error.stack : void 0;
-    let entry = `
---------------------------------------------------------------------------------
-[${(/* @__PURE__ */ new Date()).toISOString()}] LLM API ERROR
---------------------------------------------------------------------------------
-Provider: ${provider}
-Model: ${model}
-Method: ${method}
-Error: ${errorMessage}
-`;
-    if (requestData) {
-      const dataStr = JSON.stringify(requestData, null, 2);
-      const truncated = dataStr.length > 5e3 ? dataStr.substring(0, 5e3) + "\n... [truncated]" : dataStr;
-      entry += `
-Request Data:
-${truncated}
-`;
-    }
-    if (errorStack) {
-      entry += `
-Stack Trace:
-${errorStack}
-`;
+    this.sessionStats.totalCalls++;
+    this.sessionStats.totalInputTokens += entry.inputTokens;
+    this.sessionStats.totalOutputTokens += entry.outputTokens;
+    this.sessionStats.totalCacheReadTokens += entry.cacheReadTokens || 0;
+    this.sessionStats.totalCacheWriteTokens += entry.cacheWriteTokens || 0;
+    this.sessionStats.totalCostUSD += entry.costUSD;
+    this.sessionStats.totalDurationMs += entry.durationMs;
+    const cacheInfo = entry.cacheReadTokens || entry.cacheWriteTokens ? ` CACHE_R=${entry.cacheReadTokens || 0} CACHE_W=${entry.cacheWriteTokens || 0}` : "";
+    const toolInfo = entry.toolCalls ? ` | Tools: ${entry.toolCalls}` : "";
+    const errorInfo = entry.error ? ` | ERROR: ${entry.error}` : "";
+    const status = entry.success ? "\u2713" : "\u2717";
+    let cacheStatus = "";
+    if (entry.cacheReadTokens && entry.cacheReadTokens > 0) {
+      const savedCost = entry.cacheReadTokens / 1e6 * 2.7;
+      cacheStatus = ` \u26A1 CACHE HIT! Saved ~$${savedCost.toFixed(4)}`;
+    } else if (entry.cacheWriteTokens && entry.cacheWriteTokens > 0) {
+      cacheStatus = " \u{1F4DD} Cache created (next request will be cheaper)";
     }
-    entry += `--------------------------------------------------------------------------------
-
+    const logLine = `[${entry.timestamp}] [${entry.requestId}] ${status} ${entry.provider}/${entry.model} [${entry.method}]
+    Tokens: IN=${entry.inputTokens} OUT=${entry.outputTokens}${cacheInfo} TOTAL=${entry.totalTokens}
+    Cost: $${entry.costUSD.toFixed(6)} | Time: ${entry.durationMs}ms${toolInfo}${errorInfo}${cacheStatus}
 `;
-    this.write(entry);
-    console.error(`[UserPromptError] LLM Error (${provider}/${model}): ${errorMessage}`);
+    this.logStream?.write(logLine);
   }
   /**
-   * Log tool execution error
+   * Log session summary (call at end of request)
    */
-  logToolError(toolName, toolInput, error) {
-    if (!this.enabled) return;
-    this.hasErrors = true;
-    const errorMessage = error instanceof Error ? error.message : error;
-    const errorStack = error instanceof Error ? error.stack : void 0;
-    const entry = `
+  logSessionSummary(requestContext) {
+    if (!this.enabled || this.sessionStats.totalCalls === 0) return;
+    const cacheReadSavings = this.sessionStats.totalCacheReadTokens / 1e6 * 2.7;
+    const hasCaching = this.sessionStats.totalCacheReadTokens > 0 || this.sessionStats.totalCacheWriteTokens > 0;
+    let cacheSection = "";
+    if (hasCaching) {
+      cacheSection = `
+Cache Statistics:
+  Cache Read Tokens: ${this.sessionStats.totalCacheReadTokens.toLocaleString()}${this.sessionStats.totalCacheReadTokens > 0 ? " \u26A1" : ""}
+  Cache Write Tokens: ${this.sessionStats.totalCacheWriteTokens.toLocaleString()}${this.sessionStats.totalCacheWriteTokens > 0 ? " \u{1F4DD}" : ""}
+  Estimated Savings: $${cacheReadSavings.toFixed(4)}`;
+    }
+    const summary = `
 --------------------------------------------------------------------------------
-[${(/* @__PURE__ */ new Date()).toISOString()}] TOOL EXECUTION ERROR
+SESSION SUMMARY${requestContext ? ` (${requestContext})` : ""}
 --------------------------------------------------------------------------------
-Tool: ${toolName}
-Error: ${errorMessage}
-
-Tool Input:
-${JSON.stringify(toolInput, null, 2)}
-${errorStack ? `
-Stack Trace:
-${errorStack}` : ""}
+Total LLM Calls: ${this.sessionStats.totalCalls}
+Total Input Tokens: ${this.sessionStats.totalInputTokens.toLocaleString()}
+Total Output Tokens: ${this.sessionStats.totalOutputTokens.toLocaleString()}
+Total Tokens: ${(this.sessionStats.totalInputTokens + this.sessionStats.totalOutputTokens).toLocaleString()}
+Total Cost: $${this.sessionStats.totalCostUSD.toFixed(6)}
+Total Time: ${this.sessionStats.totalDurationMs}ms (${(this.sessionStats.totalDurationMs / 1e3).toFixed(2)}s)
+Avg Cost/Call: $${(this.sessionStats.totalCostUSD / this.sessionStats.totalCalls).toFixed(6)}
+Avg Time/Call: ${Math.round(this.sessionStats.totalDurationMs / this.sessionStats.totalCalls)}ms${cacheSection}
 --------------------------------------------------------------------------------
 
 `;
-    this.write(entry);
-    console.error(`[UserPromptError] Tool Error (${toolName}): ${errorMessage}`);
+    this.logStream?.write(summary);
   }
   /**
-   * Write final summary if there were errors
+   * Reset session stats (call at start of new user request)
    */
-  writeSummary() {
-    if (!this.enabled || !this.hasErrors) return;
-    const summary = `
+  resetSession() {
+    this.sessionStats = {
+      totalCalls: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCacheReadTokens: 0,
+      totalCacheWriteTokens: 0,
+      totalCostUSD: 0,
+      totalDurationMs: 0
+    };
+  }
+  /**
+   * Reset the log file for a new request (clears previous logs)
+   * Call this at the start of each USER_PROMPT_REQ
+   */
+  resetLogFile(requestContext) {
+    if (!this.enabled) return;
+    try {
+      if (this.logStream) {
+        this.logStream.end();
+        this.logStream = null;
+      }
+      this.logStream = fs5.createWriteStream(this.logPath, { flags: "w" });
+      const header = `
 ================================================================================
-REQUEST COMPLETED WITH ERRORS
-Time: ${(/* @__PURE__ */ new Date()).toISOString()}
+LLM USAGE LOG - Request Started: ${(/* @__PURE__ */ new Date()).toISOString()}
+${requestContext ? `Context: ${requestContext}` : ""}
+================================================================================
+Format: [TIMESTAMP] [REQUEST_ID] [PROVIDER/MODEL] [METHOD]
+        Tokens: IN=input OUT=output CACHE_R=cache_read CACHE_W=cache_write TOTAL=total
+        Cost: $X.XXXXXX | Time: Xms
 ================================================================================
+
 `;
-    this.write(summary);
+      this.logStream.write(header);
+      this.resetSession();
+    } catch (error) {
+      console.error("[LLM-Usage-Logger] Failed to reset log file:", error);
+    }
   }
   /**
-   * Check if any errors were logged
+   * Get current session stats
    */
-  hadErrors() {
-    return this.hasErrors;
+  getSessionStats() {
+    return { ...this.sessionStats };
   }
-  write(content) {
-    if (this.logStream) {
-      this.logStream.write(content);
-    }
+  /**
+   * Generate a unique request ID
+   */
+  generateRequestId() {
+    return `req-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
   }
 };
-var userPromptErrorLogger = new UserPromptErrorLogger();
+var llmUsageLogger = new LLMUsageLogger();
 
 // src/llm.ts
 var LLM = class {
@@ -5165,7 +5576,7 @@ var LLM = class {
           role: "user",
           content: []
         };
-        for (const toolUse of toolUses) {
+        const toolResultEntries = await Promise.all(toolUses.map(async (toolUse) => {
           try {
             const result = await toolHandler(toolUse.name, toolUse.input);
             let resultContent = typeof result === "string" ? result : JSON.stringify(result);
@@ -5173,20 +5584,21 @@ var LLM = class {
             if (resultContent.length > MAX_RESULT_LENGTH) {
               resultContent = resultContent.substring(0, MAX_RESULT_LENGTH) + "\n\n... [Result truncated - showing first 50000 characters of " + resultContent.length + " total]";
             }
-            toolResults.content.push({
+            return {
               type: "tool_result",
               tool_use_id: toolUse.id,
               content: resultContent
-            });
+            };
           } catch (error) {
-            toolResults.content.push({
+            return {
               type: "tool_result",
               tool_use_id: toolUse.id,
               content: error instanceof Error ? error.message : String(error),
               is_error: true
-            });
+            };
           }
-        }
+        }));
+        toolResultEntries.forEach((entry) => toolResults.content.push(entry));
         conversationMessages.push(toolResults);
       } else {
         break;
@@ -5684,7 +6096,7 @@ var LLM = class {
         break;
       }
       const functionResponses = [];
-      for (const fc of functionCalls) {
+      const responses = await Promise.all(functionCalls.map(async (fc) => {
         try {
           const result2 = await toolHandler(fc.name, fc.args);
           let resultContent = typeof result2 === "string" ? result2 : JSON.stringify(result2);
@@ -5692,17 +6104,18 @@ var LLM = class {
           if (resultContent.length > MAX_RESULT_LENGTH) {
             resultContent = resultContent.substring(0, MAX_RESULT_LENGTH) + "\n\n... [Result truncated - showing first 50000 characters of " + resultContent.length + " total]";
           }
-          functionResponses.push({
+          return {
             name: fc.name,
             response: { result: resultContent }
-          });
+          };
         } catch (error) {
-          functionResponses.push({
+          return {
             name: fc.name,
             response: { error: error instanceof Error ? error.message : String(error) }
-          });
+          };
         }
-      }
+      }));
+      functionResponses.push(...responses);
       const functionResponseParts = functionResponses.map((fr) => ({
         functionResponse: {
           name: fr.name,
@@ -5958,7 +6371,7 @@ var LLM = class {
           }
         }))
       });
-      for (const tc of toolCalls) {
+      const toolCallResults = await Promise.all(toolCalls.map(async (tc) => {
         let result;
         try {
           const args = JSON.parse(tc.arguments);
@@ -5970,13 +6383,10 @@ var LLM = class {
           }
         } catch (error) {
           result = JSON.stringify({ error: error instanceof Error ? error.message : String(error) });
-        }
-        conversationMessages.push({
-          role: "tool",
-          tool_call_id: tc.id,
-          content: result
-        });
-      }
+        }
+        return { role: "tool", tool_call_id: tc.id, content: result };
+      }));
+      toolCallResults.forEach((r) => conversationMessages.push(r));
     }
     if (iterations >= maxIterations) {
       throw new Error(`Max iterations (${maxIterations}) reached in tool calling loop`);
@@ -6071,583 +6481,851 @@ function getCurrentDateTimeForPrompt() {
   });
 }
 
-// src/userResponse/knowledge-base.ts
-var getKnowledgeBase = async ({
-  prompt,
-  collections,
-  topK = 1
-}) => {
-  try {
-    if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["query"]) {
-      logger.warn("[KnowledgeBase] knowledge-base.query collection not registered, skipping");
-      return "";
-    }
-    const result = await collections["knowledge-base"]["query"]({
-      prompt,
-      topK
+// src/userResponse/agents/agent-prompt-builder.ts
+function buildSourceSummaries(externalTools) {
+  return externalTools.map((tool) => {
+    const description = tool.description || "";
+    const type = extractSourceType(tool.id);
+    const entityDetails = extractEntityDetails(description);
+    const dataContext = extractDataContext(description, tool.name, type);
+    return {
+      id: extractSourceId(tool.id),
+      name: tool.name,
+      type,
+      description: dataContext,
+      entityDetails,
+      toolId: tool.id
+    };
+  });
+}
+function formatSummariesForPrompt(summaries) {
+  return summaries.map((s, idx) => {
+    const totalRows = s.entityDetails.reduce((sum, e) => sum + (e.rowCount || 0), 0);
+    const rowInfo = totalRows > 0 ? ` (~${totalRows.toLocaleString()} total rows)` : "";
+    let entitiesBlock = "";
+    if (s.entityDetails.length > 0) {
+      entitiesBlock = "\n" + s.entityDetails.map((e) => {
+        const rows = e.rowCount ? ` (${e.rowCount.toLocaleString()} rows)` : "";
+        const cols = e.columns.length > 0 ? `: ${e.columns.join(", ")}` : "";
+        return `  - ${e.name}${rows}${cols}`;
+      }).join("\n");
+    }
+    return `${idx + 1}. **${s.name}** (tool: ${s.toolId}, type: ${s.type})${rowInfo}
+  ${s.description}${entitiesBlock}`;
+  }).join("\n\n");
+}
+function extractEntityDetails(description) {
+  const details = [];
+  const bulletSections = description.split(/(?=•\s)/);
+  for (const section of bulletSections) {
+    if (!section.trim().startsWith("\u2022")) continue;
+    const headerMatch = section.match(/•\s+(?:\w+\.)?(.+?)\s*\[~?([\d,]+)\s*rows?\]/);
+    if (!headerMatch) continue;
+    const name = headerMatch[1].trim();
+    const rowCount = parseInt(headerMatch[2].replace(/,/g, ""), 10);
+    const columns = extractColumnNames(section);
+    details.push({
+      name,
+      rowCount: rowCount > 0 ? rowCount : void 0,
+      columns
     });
-    if (!result || !result.content) {
-      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.warn(`[KnowledgeBase] Sources: ${result.metadata.sources.map((s) => s.title).join(", ")}`);
-    }
-    return result.content;
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logger.warn(`[KnowledgeBase] Error querying knowledge base: ${errorMsg}`);
-    return "";
   }
-};
-var getGlobalKnowledgeBase = async ({
-  collections,
-  limit = 100
-}) => {
-  try {
-    if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["getGlobal"]) {
-      logger.warn("[KnowledgeBase] knowledge-base.getGlobal collection not registered, skipping");
-      return "";
-    }
-    const result = await collections["knowledge-base"]["getGlobal"]({ limit });
-    if (!result || !result.content) {
-      logger.warn("[KnowledgeBase] No global knowledge base nodes found");
-      return "";
+  if (details.length === 0) {
+    const endpointPattern = /Endpoint:\s*(\S+)/g;
+    let match;
+    while ((match = endpointPattern.exec(description)) !== null) {
+      const columns = extractColumnNames(description);
+      details.push({
+        name: match[1].trim(),
+        columns
+      });
     }
-    logger.info(`[KnowledgeBase] Retrieved ${result.count || 0} global knowledge base nodes`);
-    return result.content;
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logger.warn(`[KnowledgeBase] Error fetching global knowledge base: ${errorMsg}`);
-    return "";
   }
-};
-var getUserKnowledgeBase = async ({
-  collections,
-  userId,
-  limit = 100
-}) => {
-  try {
-    if (!userId) {
-      logger.warn("[KnowledgeBase] No userId provided, skipping user knowledge base");
-      return "";
+  return details;
+}
+function extractColumnNames(block) {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  const colPattern = /(?:^|,)\s*([^,()\[\]{}\n]+?)\s*\((?:NUMBER|TEXT|BOOLEAN|TIMESTAMP|INTEGER|FLOAT|DECIMAL|DATE|BIGINT|VARCHAR|CHAR|DOUBLE|REAL|ARRAY|OBJECT)\)/gi;
+  let match;
+  while ((match = colPattern.exec(block)) !== null) {
+    const col = match[1].trim();
+    if (col && col.length < 60 && !col.includes("\u2022") && !seen.has(col)) {
+      columns.push(col);
+      seen.add(col);
+    }
+  }
+  return columns;
+}
+function extractDataContext(description, name, type) {
+  const contextMatch = description.match(/Data Context:\s*(.+?)(?:\n|$)/);
+  if (contextMatch) return contextMatch[1].trim();
+  const excelMatch = description.match(/Excel file:\s*(.+?)\)/);
+  if (excelMatch) return `Excel file: ${excelMatch[1].trim()})`;
+  const csvMatch = description.match(/CSV file:\s*(.+?)\)/);
+  if (csvMatch) return `CSV file: ${csvMatch[1].trim()})`;
+  const useForMatch = description.match(/Use this source for[^:]*:\s*(.+?)(?:\n|$)/);
+  if (useForMatch) return useForMatch[1].trim();
+  const typeLabels = {
+    postgres: "PostgreSQL database",
+    mysql: "MySQL database",
+    mssql: "SQL Server database",
+    excel: "Excel spreadsheet",
+    csv: "CSV file",
+    rest_api: "REST API",
+    graphql: "GraphQL API"
+  };
+  return `${typeLabels[type] || type}: ${name}`;
+}
+function extractSourceType(toolId) {
+  const match = toolId.match(/^(\w+)-[a-f0-9]+_/);
+  if (match) return match[1];
+  const types = ["postgres", "mysql", "mssql", "excel", "csv", "rest_api", "graphql"];
+  for (const type of types) {
+    if (toolId.toLowerCase().includes(type)) return type;
+  }
+  return "unknown";
+}
+function extractSourceId(toolId) {
+  return toolId.replace(/_(query|read|call)$/, "");
+}
+
+// src/userResponse/agents/source-agent.ts
+var SourceAgent = class {
+  constructor(tool, config, streamBuffer) {
+    this.attempts = 0;
+    this.tool = tool;
+    this.config = config;
+    this.streamBuffer = streamBuffer;
+  }
+  /**
+   * Execute a query against this source based on the intent from the main agent.
+   *
+   * Flow:
+   * 1. Build prompt with full schema (from tool.description) + intent
+   * 2. Source agent's OWN LLM generates query via tool calling
+   * 3. Execute with retry — all handled internally
+   * 4. Return SourceAgentResult with data + isLimited metadata
+   */
+  async execute(input) {
+    const startTime = Date.now();
+    const { intent, aggregation = "raw" } = input;
+    logger.info(`[SourceAgent:${this.tool.name}] Starting | intent: "${intent}" | aggregation: ${aggregation}`);
+    if (this.streamBuffer.hasCallback()) {
+      this.streamBuffer.write(`
+
+\u{1F517} **Querying ${this.tool.name}...**
+
+`);
+      await streamDelay();
     }
-    if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["getByUser"]) {
-      logger.warn("[KnowledgeBase] knowledge-base.getByUser collection not registered, skipping");
-      return "";
+    try {
+      const prompts = await this.buildPrompt(intent, aggregation);
+      const llmTool = this.buildLLMToolDefinition();
+      let executedTool = null;
+      let resultData = [];
+      let queryExecuted;
+      let totalRowsMatched = 0;
+      const toolHandler = async (_toolName, toolInput) => {
+        this.attempts++;
+        if (this.attempts > this.config.maxRetries) {
+          throw new Error(`Max retry attempts (${this.config.maxRetries}) reached for ${this.tool.name}`);
+        }
+        if (this.attempts > 1 && this.streamBuffer.hasCallback()) {
+          this.streamBuffer.write(`
+
+\u{1F504} **Retrying ${this.tool.name} (attempt ${this.attempts}/${this.config.maxRetries})...**
+
+`);
+          await streamDelay();
+        }
+        const cappedInput = { ...toolInput };
+        if (cappedInput.limit === void 0 || cappedInput.limit > this.config.maxRowsPerSource) {
+          cappedInput.limit = this.config.maxRowsPerSource;
+        }
+        queryExecuted = cappedInput.sql || cappedInput.query || JSON.stringify(cappedInput);
+        try {
+          const result = await withProgressHeartbeat(
+            () => this.tool.fn(cappedInput),
+            `Running ${this.tool.name}`,
+            this.streamBuffer
+          );
+          if (result && result.error) {
+            const errorMsg = typeof result.error === "string" ? result.error : JSON.stringify(result.error);
+            logger.warn(`[SourceAgent:${this.tool.name}] Tool returned error (attempt ${this.attempts}/${this.config.maxRetries}): ${errorMsg}`);
+            return `\u274C ERROR: ${errorMsg}
+
+Analyze the error and try again with a corrected query.`;
+          }
+          resultData = result.data || [];
+          totalRowsMatched = result.metadata?.totalCount || result.count || resultData.length;
+          const formattedResult = formatToolResultForLLM(result, {
+            toolName: this.tool.name,
+            maxRows: 5,
+            maxCharsPerField: 200
+          });
+          executedTool = {
+            id: this.tool.id,
+            name: this.tool.name,
+            params: cappedInput,
+            result: {
+              _totalRecords: totalRowsMatched,
+              _recordsShown: resultData.length,
+              _metadata: result.metadata,
+              _sampleData: resultData.slice(0, 3)
+            },
+            outputSchema: this.tool.outputSchema
+          };
+          const formatted = typeof formattedResult === "string" ? formattedResult : JSON.stringify(formattedResult);
+          return `\u2705 Query executed successfully. ${resultData.length} rows returned (${totalRowsMatched} total matched). Data is ready \u2014 do NOT call the tool again.
+
+${formatted}`;
+        } catch (execError) {
+          const errorMsg = execError instanceof Error ? execError.message : typeof execError === "object" && execError !== null ? execError.message || execError.error || JSON.stringify(execError) : String(execError);
+          logger.warn(`[SourceAgent:${this.tool.name}] Tool execution failed (attempt ${this.attempts}/${this.config.maxRetries}): ${errorMsg}`);
+          return `\u274C ERROR: ${errorMsg}
+
+Analyze the error and try again with a corrected query.`;
+        }
+      };
+      await LLM.streamWithTools(
+        { sys: prompts.system, user: prompts.user },
+        [llmTool],
+        toolHandler,
+        {
+          model: this.config.sourceAgentModel || void 0,
+          maxTokens: 2048,
+          temperature: 0,
+          apiKey: this.config.apiKey
+        },
+        this.config.maxRetries
+      );
+      const executionTimeMs = Date.now() - startTime;
+      if (!executedTool) {
+        logger.warn(`[SourceAgent:${this.tool.name}] LLM did not call the tool`);
+        return {
+          sourceId: this.tool.id,
+          sourceName: this.tool.name,
+          success: false,
+          data: [],
+          metadata: {
+            totalRowsMatched: 0,
+            rowsReturned: 0,
+            isLimited: false,
+            executionTimeMs
+          },
+          executedTool: this.buildEmptyExecutedTool(),
+          error: "Source agent did not execute any query"
+        };
+      }
+      logger.info(`[SourceAgent:${this.tool.name}] Success | ${resultData.length} rows in ${executionTimeMs}ms`);
+      return {
+        sourceId: this.tool.id,
+        sourceName: this.tool.name,
+        success: true,
+        data: resultData,
+        metadata: {
+          totalRowsMatched,
+          rowsReturned: resultData.length,
+          isLimited: resultData.length < totalRowsMatched,
+          queryExecuted,
+          executionTimeMs
+        },
+        executedTool
+      };
+    } catch (error) {
+      const executionTimeMs = Date.now() - startTime;
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(`[SourceAgent:${this.tool.name}] Failed: ${errorMsg}`);
+      if (this.streamBuffer.hasCallback()) {
+        this.streamBuffer.write(`
+
+\u274C **${this.tool.name} failed:** ${errorMsg}
+
+`);
+      }
+      return {
+        sourceId: this.tool.id,
+        sourceName: this.tool.name,
+        success: false,
+        data: [],
+        metadata: {
+          totalRowsMatched: 0,
+          rowsReturned: 0,
+          isLimited: false,
+          queryExecuted: void 0,
+          executionTimeMs
+        },
+        executedTool: this.buildEmptyExecutedTool(),
+        error: errorMsg
+      };
     }
-    const result = await collections["knowledge-base"]["getByUser"]({
-      userId: Number(userId),
-      limit
+  }
+  // ============================================
+  // Private Helpers
+  // ============================================
+  /**
+   * Build prompt using the prompt loader (file system → hardcoded fallback in prompts.ts).
+   */
+  async buildPrompt(intent, aggregation) {
+    const sourceName = this.tool.name;
+    const sourceType = this.extractSourceType();
+    const fullSchema = this.tool.description || "No schema available";
+    const prompts = await promptLoader.loadPrompts("agent-source-query", {
+      SOURCE_NAME: sourceName,
+      SOURCE_TYPE: sourceType,
+      FULL_SCHEMA: fullSchema,
+      MAX_ROWS: String(this.config.maxRowsPerSource),
+      AGGREGATION_MODE: aggregation,
+      CURRENT_DATETIME: getCurrentDateTimeForPrompt(),
+      INTENT: intent
     });
-    if (!result || !result.content) {
-      logger.info(`[KnowledgeBase] No user knowledge base nodes found for userId: ${userId}`);
-      return "";
-    }
-    logger.info(`[KnowledgeBase] Retrieved ${result.count || 0} user knowledge base nodes for userId: ${userId}`);
-    return result.content;
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logger.warn(`[KnowledgeBase] Error fetching user knowledge base: ${errorMsg}`);
-    return "";
+    return { system: prompts.system, user: prompts.user };
+  }
+  /**
+   * Build the LLM tool definition from the external tool.
+   * Parses param descriptions like "string - Sheet name" or "array (optional) - Columns"
+   * to extract the correct JSON schema type and required/optional status.
+   */
+  buildLLMToolDefinition() {
+    const properties = {};
+    const required = [];
+    const toolParams = this.tool.params || {};
+    Object.entries(toolParams).forEach(([key, typeOrValue]) => {
+      const valueStr = String(typeOrValue).toLowerCase();
+      let schemaType = "string";
+      const typeMatch = valueStr.match(/^(string|number|integer|boolean|array|object)\b/);
+      if (typeMatch) {
+        schemaType = typeMatch[1];
+      } else if (typeof typeOrValue === "number") {
+        schemaType = Number.isInteger(typeOrValue) ? "integer" : "number";
+      } else if (typeof typeOrValue === "boolean") {
+        schemaType = "boolean";
+      }
+      const isOptional = valueStr.includes("(optional)") || valueStr.includes("optional");
+      const description = typeof typeOrValue === "string" ? typeOrValue : `Parameter: ${key}`;
+      if (schemaType === "array") {
+        properties[key] = { type: "array", items: { type: "string" }, description };
+      } else if (schemaType === "object") {
+        properties[key] = { type: "object", description };
+      } else {
+        properties[key] = { type: schemaType, description };
+      }
+      if (!isOptional) {
+        required.push(key);
+      }
+    });
+    return {
+      name: this.tool.id,
+      description: this.tool.description || `Query ${this.tool.name}`,
+      input_schema: {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0
+      }
+    };
+  }
+  /**
+   * Extract source type from tool ID.
+   */
+  extractSourceType() {
+    const match = this.tool.id.match(/^(\w+)-[a-f0-9]+_/);
+    return match ? match[1] : "unknown";
+  }
+  /**
+   * Build an empty ExecutedToolInfo for error cases.
+   */
+  buildEmptyExecutedTool() {
+    return {
+      id: this.tool.id,
+      name: this.tool.name,
+      params: {},
+      result: {
+        _totalRecords: 0,
+        _recordsShown: 0,
+        _sampleData: []
+      },
+      outputSchema: this.tool.outputSchema
+    };
   }
 };
-var getAllKnowledgeBase = async ({
-  prompt,
-  collections,
-  userId,
-  topK = 3
-}) => {
-  const [globalContext, userContext, queryContext] = await Promise.all([
-    getGlobalKnowledgeBase({ collections }),
-    getUserKnowledgeBase({ collections, userId }),
-    getKnowledgeBase({ prompt, collections, topK })
-  ]);
-  let combinedContext = "";
-  if (globalContext) {
-    combinedContext += "## Global Knowledge Base\n";
-    combinedContext += "The following information applies to all queries:\n\n";
-    combinedContext += globalContext + "\n\n";
+
+// src/userResponse/agents/main-agent.ts
+var MainAgent = class {
+  constructor(externalTools, config, streamBuffer) {
+    this.externalTools = externalTools;
+    this.config = config;
+    this.streamBuffer = streamBuffer;
   }
-  if (userContext) {
-    combinedContext += "## User-Specific Knowledge Base\n";
-    combinedContext += "The following information is specific to this user:\n\n";
-    combinedContext += userContext + "\n\n";
+  /**
+   * Handle a user question using the multi-agent system.
+   *
+   * This is ONE LLM.streamWithTools() call. The LLM:
+   * 1. Sees source summaries in system prompt (~100 tokens each)
+   * 2. Decides which source(s) to query (routing)
+   * 3. Calls source tools → SourceAgent runs independently → returns data
+   * 4. Sees data, decides if it needs more → calls tools again if needed
+   * 5. Generates final analysis text
+   */
+  async handleQuestion(userPrompt, apiKey, conversationHistory, streamCallback) {
+    const startTime = Date.now();
+    logger.info(`[MainAgent] Starting | prompt: "${userPrompt.substring(0, 50)}..."`);
+    const summaries = buildSourceSummaries(this.externalTools);
+    logger.info(`[MainAgent] ${summaries.length} source(s) available`);
+    const systemPrompt = await this.buildSystemPrompt(summaries, conversationHistory);
+    const tools = this.buildSourceToolDefinitions(summaries);
+    const sourceResults = [];
+    const executedTools = [];
+    const toolHandler = async (toolName, toolInput) => {
+      const externalTool = this.externalTools.find((t) => t.id === toolName);
+      if (!externalTool) {
+        logger.error(`[MainAgent] Unknown tool called: ${toolName}`);
+        return `Error: Unknown data source "${toolName}"`;
+      }
+      const sourceInput = {
+        intent: toolInput.intent || toolInput.query || JSON.stringify(toolInput),
+        aggregation: toolInput.aggregation || "raw"
+      };
+      logger.info(`[MainAgent] Dispatching SourceAgent for "${externalTool.name}" | intent: "${sourceInput.intent}"`);
+      const sourceAgent = new SourceAgent(externalTool, this.config, this.streamBuffer);
+      const result = await sourceAgent.execute(sourceInput);
+      sourceResults.push(result);
+      if (result.success) {
+        executedTools.push(result.executedTool);
+      }
+      return this.formatResultForMainAgent(result);
+    };
+    const text = await LLM.streamWithTools(
+      {
+        sys: systemPrompt,
+        user: userPrompt
+      },
+      tools,
+      toolHandler,
+      {
+        model: this.config.mainAgentModel || void 0,
+        maxTokens: 4e3,
+        temperature: 0,
+        apiKey: apiKey || this.config.apiKey,
+        partial: streamCallback
+      },
+      this.config.maxIterations
+    );
+    const totalTime = Date.now() - startTime;
+    logger.info(`[MainAgent] Complete | ${sourceResults.length} source queries, ${executedTools.length} successful | ${totalTime}ms`);
+    return {
+      text,
+      executedTools,
+      sourceResults
+    };
   }
-  if (queryContext) {
-    combinedContext += "## Relevant Knowledge Base (Query-Matched)\n";
-    combinedContext += "The following information is semantically relevant to the current query:\n\n";
-    combinedContext += queryContext + "\n\n";
+  // ============================================
+  // System Prompt
+  // ============================================
+  /**
+   * Build the main agent's system prompt with source summaries.
+   * Loads from prompt loader (file system → hardcoded fallback in prompts.ts).
+   */
+  async buildSystemPrompt(summaries, conversationHistory) {
+    const summariesText = formatSummariesForPrompt(summaries);
+    const prompts = await promptLoader.loadPrompts("agent-main", {
+      SOURCE_SUMMARIES: summariesText,
+      MAX_ROWS: String(this.config.maxRowsPerSource),
+      CURRENT_DATETIME: getCurrentDateTimeForPrompt(),
+      CONVERSATION_HISTORY: conversationHistory || "No previous conversation"
+    });
+    return prompts.system;
+  }
+  // ============================================
+  // Tool Definitions (summary-only, no full schema)
+  // ============================================
+  /**
+   * Build tool definitions for the main agent — one per source.
+   * Descriptions include entity names with column names for routing.
+   * The full schema is inside the SourceAgent which runs independently.
+   */
+  buildSourceToolDefinitions(summaries) {
+    return summaries.map((summary) => {
+      const totalRows = summary.entityDetails.reduce((sum, e) => sum + (e.rowCount || 0), 0);
+      const rowInfo = totalRows > 0 ? ` (~${totalRows.toLocaleString()} total rows)` : "";
+      const entitiesList = summary.entityDetails.length > 0 ? summary.entityDetails.map((e) => {
+        const cols = e.columns.length > 0 ? ` [${e.columns.join(", ")}]` : "";
+        return `${e.name}${cols}`;
+      }).join("; ") : "no entities listed";
+      return {
+        name: summary.toolId,
+        description: `Query "${summary.name}" (${summary.type})${rowInfo}. ${summary.description}. Contains: ${entitiesList}.`,
+        input_schema: {
+          type: "object",
+          properties: {
+            intent: {
+              type: "string",
+              description: "Describe what data you need from this source in natural language. Be specific about fields, filters, aggregations, and limits."
+            },
+            aggregation: {
+              type: "string",
+              enum: ["raw", "pre-aggregate", "summary"],
+              description: 'How to return data. "pre-aggregate": use GROUP BY/SUM/COUNT for totals. "summary": high-level metrics. "raw": individual records.'
+            }
+          },
+          required: ["intent"]
+        }
+      };
+    });
+  }
+  // ============================================
+  // Format Result for Main Agent
+  // ============================================
+  /**
+   * Format a source agent's result as a clean string for the main agent LLM.
+   * Passes through the data as-is — no server-side aggregation.
+   * If the main agent needs aggregates, it should request aggregation: "pre-aggregate"
+   * from the source agent, which handles it at the query level (SQL GROUP BY, etc.).
+   */
+  formatResultForMainAgent(result) {
+    if (!result.success) {
+      return `Data source "${result.sourceName}" could not fulfill the request: ${result.error}. Try rephrasing your intent or querying a different source.`;
+    }
+    const { data, metadata } = result;
+    let output = `## Data from "${result.sourceName}"
+`;
+    output += `Rows returned: ${metadata.rowsReturned}`;
+    if (metadata.isLimited) {
+      output += ` (LIMITED \u2014 ${metadata.totalRowsMatched} total matched, only ${metadata.rowsReturned} returned)`;
+    }
+    output += `
+Execution time: ${metadata.executionTimeMs}ms
+
+`;
+    if (data.length === 0) {
+      output += "No data returned.";
+      return output;
+    }
+    output += `### Results (${data.length} rows)
+`;
+    output += "```json\n";
+    output += JSON.stringify(data, null, 2);
+    output += "\n```\n";
+    return output;
+  }
+  /**
+   * Get source summaries (for external inspection/debugging).
+   */
+  getSourceSummaries() {
+    return buildSourceSummaries(this.externalTools);
   }
-  return {
-    globalContext,
-    userContext,
-    queryContext,
-    combinedContext: combinedContext.trim()
-  };
 };
-var KB = {
-  getKnowledgeBase,
-  getGlobalKnowledgeBase,
-  getUserKnowledgeBase,
-  getAllKnowledgeBase
+
+// src/userResponse/agents/types.ts
+var DEFAULT_AGENT_CONFIG = {
+  maxRowsPerSource: 10,
+  mainAgentModel: "",
+  // will use the provider's default model
+  sourceAgentModel: "",
+  // will use the provider's default model
+  maxRetries: 3,
+  maxIterations: 10
 };
-var knowledge_base_default = KB;
 
-// src/utils/bm25l-reranker.ts
-var BM25L = class {
+// src/userResponse/anthropic.ts
+import dotenv from "dotenv";
+
+// src/userResponse/schema.ts
+import path5 from "path";
+import fs6 from "fs";
+var Schema = class {
+  constructor(schemaFilePath) {
+    this.cachedSchema = null;
+    this.schemaFilePath = schemaFilePath || path5.join(process.cwd(), "../analysis/data/schema.json");
+  }
   /**
-   * @param documents - Array of raw documents (strings)
-   * @param opts - Optional BM25L parameters
+   * Gets the database schema from the schema file
+   * @returns Parsed schema object or null if error occurs
    */
-  constructor(documents = [], opts = {}) {
-    if (!Array.isArray(documents)) {
-      throw new Error("BM25L: documents must be an array of strings.");
+  getDatabaseSchema() {
+    try {
+      const dir = path5.dirname(this.schemaFilePath);
+      if (!fs6.existsSync(dir)) {
+        logger.info(`Creating directory structure: ${dir}`);
+        fs6.mkdirSync(dir, { recursive: true });
+      }
+      if (!fs6.existsSync(this.schemaFilePath)) {
+        logger.info(`Schema file does not exist at ${this.schemaFilePath}, creating with empty schema`);
+        const initialSchema = {
+          database: "",
+          schema: "",
+          description: "",
+          tables: [],
+          relationships: []
+        };
+        fs6.writeFileSync(this.schemaFilePath, JSON.stringify(initialSchema, null, 4));
+        this.cachedSchema = initialSchema;
+        return initialSchema;
+      }
+      const fileContent = fs6.readFileSync(this.schemaFilePath, "utf-8");
+      const schema2 = JSON.parse(fileContent);
+      this.cachedSchema = schema2;
+      return schema2;
+    } catch (error) {
+      logger.error("Error parsing schema file:", error);
+      return null;
     }
-    this.k1 = typeof opts.k1 === "number" ? opts.k1 : 1.5;
-    this.b = typeof opts.b === "number" ? opts.b : 0.75;
-    this.delta = typeof opts.delta === "number" ? opts.delta : 0.5;
-    this.documents = documents.map((d) => typeof d === "string" ? this.tokenize(d) : []);
-    this.docLengths = this.documents.map((doc) => doc.length);
-    this.avgDocLength = this.docLengths.reduce((a, b) => a + b, 0) / (this.docLengths.length || 1);
-    this.termDocFreq = {};
-    this.documents.forEach((doc) => {
-      const seen = /* @__PURE__ */ new Set();
-      doc.forEach((term) => {
-        if (!seen.has(term)) {
-          seen.add(term);
-          this.termDocFreq[term] = (this.termDocFreq[term] || 0) + 1;
-        }
-      });
-    });
   }
   /**
-   * Tokenize text into lowercase alphanumeric tokens
+   * Gets the cached schema or loads it if not cached
+   * @returns Cached schema or freshly loaded schema
    */
-  tokenize(text) {
-    if (typeof text !== "string") return [];
-    return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean);
+  getSchema() {
+    if (this.cachedSchema) {
+      return this.cachedSchema;
+    }
+    return this.getDatabaseSchema();
   }
   /**
-   * Compute IDF (Inverse Document Frequency) with smoothing
+   * Generates database schema documentation for LLM from Snowflake JSON schema
+   * @returns Formatted schema documentation string
    */
-  idf(term) {
-    const df = this.termDocFreq[term] || 0;
-    const N = this.documents.length || 1;
-    return Math.log(1 + (N - df + 0.5) / (df + 0.5));
+  generateSchemaDocumentation() {
+    const schema2 = this.getSchema();
+    if (!schema2) {
+      logger.warn("No database schema found.");
+      return "No database schema available.";
+    }
+    const tables = [];
+    tables.push(`Database: ${schema2.database}`);
+    tables.push(`Schema: ${schema2.schema}`);
+    tables.push(`Description: ${schema2.description}`);
+    tables.push("");
+    tables.push("=".repeat(80));
+    tables.push("");
+    for (const table of schema2.tables) {
+      const tableInfo = [];
+      tableInfo.push(`TABLE: ${table.fullName}`);
+      tableInfo.push(`Description: ${table.description}`);
+      tableInfo.push(`Row Count: ~${table.rowCount.toLocaleString()}`);
+      tableInfo.push("");
+      tableInfo.push("Columns:");
+      for (const column of table.columns) {
+        let columnLine = `  - ${column.name}: ${column.type}`;
+        if (column.isPrimaryKey) {
+          columnLine += " (PRIMARY KEY)";
+        }
+        if (column.isForeignKey && column.references) {
+          columnLine += ` (FK -> ${column.references.table}.${column.references.column})`;
+        }
+        if (!column.nullable) {
+          columnLine += " NOT NULL";
+        }
+        if (column.description) {
+          columnLine += ` - ${column.description}`;
+        }
+        tableInfo.push(columnLine);
+        if (column.sampleValues && column.sampleValues.length > 0) {
+          tableInfo.push(`    Sample values: [${column.sampleValues.join(", ")}]`);
+        }
+        if (column.statistics) {
+          const stats = column.statistics;
+          if (stats.min !== void 0 && stats.max !== void 0) {
+            tableInfo.push(`    Range: ${stats.min} to ${stats.max}`);
+          }
+          if (stats.distinct !== void 0) {
+            tableInfo.push(`    Distinct values: ${stats.distinct.toLocaleString()}`);
+          }
+        }
+      }
+      tableInfo.push("");
+      tables.push(tableInfo.join("\n"));
+    }
+    tables.push("=".repeat(80));
+    tables.push("");
+    tables.push("TABLE RELATIONSHIPS:");
+    tables.push("");
+    for (const rel of schema2.relationships) {
+      tables.push(`${rel.from} -> ${rel.to} (${rel.type}): ${rel.keys.join(" = ")}`);
+    }
+    return tables.join("\n");
   }
   /**
-   * Compute BM25L score for a single document
+   * Clears the cached schema, forcing a reload on next access
    */
-  score(query, docIndex) {
-    if (typeof query !== "string") return 0;
-    if (docIndex < 0 || docIndex >= this.documents.length) return 0;
-    const tokens = this.tokenize(query);
-    if (tokens.length === 0) return 0;
-    const doc = this.documents[docIndex];
-    const docLength = this.docLengths[docIndex] || 1;
-    const freq = {};
-    for (const t of doc) {
-      freq[t] = (freq[t] || 0) + 1;
-    }
-    let sum = 0;
-    for (const term of tokens) {
-      const tf = freq[term] || 0;
-      if (tf === 0) continue;
-      const idfVal = this.idf(term);
-      let tfL = tf - this.b * (docLength / this.avgDocLength) + this.delta;
-      if (tfL < 0) tfL = 0;
-      sum += idfVal * (tfL / (this.k1 + tfL));
-    }
-    return sum;
+  clearCache() {
+    this.cachedSchema = null;
   }
   /**
-   * Search and rank all documents
+   * Sets a custom schema file path
+   * @param filePath - Path to the schema file
    */
-  search(query) {
-    return this.documents.map((_, i) => ({
-      index: i,
-      score: this.score(query, i)
-    })).sort((a, b) => b.score - a.score);
+  setSchemaPath(filePath) {
+    this.schemaFilePath = filePath;
+    this.clearCache();
   }
 };
-function normalizeScores(scores) {
-  if (scores.length === 0) return [];
-  const min = Math.min(...scores);
-  const max = Math.max(...scores);
-  if (max === min) {
-    return scores.map(() => max === 0 ? 0 : 1);
-  }
-  return scores.map((score) => (score - min) / (max - min));
-}
-function hybridRerank(query, items, getDocument, getSemanticScore, options = {}) {
-  const {
-    semanticWeight = 0.7,
-    bm25Weight = 0.3,
-    minScore = 0,
-    k1 = 1.5,
-    b = 0.75,
-    delta = 0.5
-  } = options;
-  if (items.length === 0) return [];
-  const documents = items.map(getDocument);
-  const semanticScores = items.map(getSemanticScore);
-  const bm25 = new BM25L(documents, { k1, b, delta });
-  const bm25Scores = items.map((_, i) => bm25.score(query, i));
-  const normalizedSemantic = normalizeScores(semanticScores);
-  const normalizedBM25 = normalizeScores(bm25Scores);
-  const results = items.map((item, i) => {
-    const hybridScore = semanticWeight * normalizedSemantic[i] + bm25Weight * normalizedBM25[i];
-    return {
-      item,
-      originalIndex: i,
-      semanticScore: semanticScores[i],
-      bm25Score: bm25Scores[i],
-      hybridScore
-    };
-  });
-  return results.filter((r) => r.hybridScore >= minScore).sort((a, b2) => b2.hybridScore - a.hybridScore);
-}
-function rerankChromaResults(query, chromaResults, options = {}) {
-  const ids = chromaResults.ids[0] || [];
-  const documents = chromaResults.documents[0] || [];
-  const metadatas = chromaResults.metadatas[0] || [];
-  const distances = chromaResults.distances[0] || [];
-  if (ids.length === 0) return [];
-  const items = ids.map((id, i) => ({
-    id,
-    document: documents[i],
-    metadata: metadatas[i],
-    distance: distances[i]
-  }));
-  const reranked = hybridRerank(
-    query,
-    items,
-    (item) => item.document || "",
-    // Convert L2 distance to similarity score
-    (item) => 1 / (1 + item.distance),
-    options
-  );
-  return reranked.map((r) => ({
-    id: r.item.id,
-    document: r.item.document,
-    metadata: r.item.metadata,
-    distance: r.item.distance,
-    semanticScore: r.semanticScore,
-    bm25Score: r.bm25Score,
-    hybridScore: r.hybridScore
-  }));
-}
-function rerankConversationResults(query, results, options = {}) {
-  if (results.length === 0) return [];
-  const reranked = hybridRerank(
-    query,
-    results,
-    (item) => item.userPrompt || "",
-    (item) => item.similarity || 0,
-    options
-  );
-  return reranked.map((r) => ({
-    ...r.item,
-    hybridScore: r.hybridScore,
-    bm25Score: r.bm25Score
-  }));
-}
+var schema = new Schema();
 
-// src/userResponse/conversation-search.ts
-var searchConversations = async ({
-  userPrompt,
+// src/userResponse/knowledge-base.ts
+var getKnowledgeBase = async ({
+  prompt,
   collections,
-  userId,
-  similarityThreshold = 0.6
+  topK = 1
 }) => {
   try {
-    if (!collections || !collections["conversation-history"] || !collections["conversation-history"]["search"]) {
-      logger.info("[ConversationSearch] conversation-history.search collection not registered, skipping");
-      return null;
+    if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["query"]) {
+      logger.warn("[KnowledgeBase] knowledge-base.query collection not registered, skipping");
+      return "";
     }
-    logger.info(`[ConversationSearch] Searching conversations for: "${userPrompt.substring(0, 50)}..."`);
-    logger.info(`[ConversationSearch] Using similarity threshold: ${(similarityThreshold * 100).toFixed(0)}%`);
-    const result = await collections["conversation-history"]["search"]({
-      userPrompt,
-      userId,
-      threshold: similarityThreshold
+    const result = await collections["knowledge-base"]["query"]({
+      prompt,
+      topK
     });
-    if (!result) {
-      logger.info("[ConversationSearch] No matching conversations found");
-      return null;
-    }
-    if (!result.uiBlock) {
-      logger.error("[ConversationSearch] No UI block in conversation search result");
-      return null;
+    if (!result || !result.content) {
+      logger.warn("[KnowledgeBase] No knowledge base results returned");
+      return "";
     }
-    const similarity = result.similarity || 0;
-    logger.info(`[ConversationSearch] Best match similarity: ${(similarity * 100).toFixed(2)}%`);
-    if (similarity < similarityThreshold) {
-      logger.info(
-        `[ConversationSearch] Best match has similarity ${(similarity * 100).toFixed(2)}% but below threshold ${(similarityThreshold * 100).toFixed(2)}%`
-      );
-      return null;
+    logger.info(`[KnowledgeBase] Retrieved knowledge base context (${result.content.length} chars)`);
+    if (result.metadata?.sources && result.metadata.sources.length > 0) {
+      logger.warn(`[KnowledgeBase] Sources: ${result.metadata.sources.map((s) => s.title).join(", ")}`);
     }
-    logger.info(
-      `[ConversationSearch] Found matching conversation with similarity ${(similarity * 100).toFixed(2)}%`
-    );
-    logger.debug(`[ConversationSearch] Matched prompt: "${result.metadata?.userPrompt?.substring(0, 50)}..."`);
-    return result;
+    return result.content;
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
-    logger.warn(`[ConversationSearch] Error searching conversations: ${errorMsg}`);
-    return null;
+    logger.warn(`[KnowledgeBase] Error querying knowledge base: ${errorMsg}`);
+    return "";
   }
 };
-var searchConversationsWithReranking = async (options) => {
-  const {
-    userPrompt,
-    collections,
-    userId,
-    similarityThreshold = 0.6,
-    rerankCandidates = 50,
-    // Fetch more candidates for better reranking
-    hybridOptions = {
-      semanticWeight: 0.7,
-      bm25Weight: 0.3
-    }
-  } = options;
+var getGlobalKnowledgeBase = async ({
+  collections,
+  limit = 100
+}) => {
   try {
-    if (!collections || !collections["conversation-history"]) {
-      logger.warn("[ConversationSearch] conversation-history collection not registered, skipping");
-      return null;
+    if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["getGlobal"]) {
+      logger.warn("[KnowledgeBase] knowledge-base.getGlobal collection not registered, skipping");
+      return "";
     }
-    if (!collections["conversation-history"]["searchMultiple"]) {
-      logger.warn("[ConversationSearch] searchMultiple not available, falling back to standard search");
-      return searchConversations({
-        userPrompt,
-        collections,
-        userId,
-        similarityThreshold
-      });
+    const result = await collections["knowledge-base"]["getGlobal"]({ limit });
+    if (!result || !result.content) {
+      logger.warn("[KnowledgeBase] No global knowledge base nodes found");
+      return "";
     }
-    const results = await collections["conversation-history"]["searchMultiple"]({
-      userPrompt,
-      userId,
-      limit: rerankCandidates,
-      threshold: 0
-      // No threshold - get all candidates for reranking
-    });
-    if (!results || results.length === 0) {
-      logger.info("[ConversationSearch] No conversations found in database");
-      return null;
+    logger.info(`[KnowledgeBase] Retrieved ${result.count || 0} global knowledge base nodes`);
+    return result.content;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.warn(`[KnowledgeBase] Error fetching global knowledge base: ${errorMsg}`);
+    return "";
+  }
+};
+var getUserKnowledgeBase = async ({
+  collections,
+  userId,
+  limit = 100
+}) => {
+  try {
+    if (!userId) {
+      logger.warn("[KnowledgeBase] No userId provided, skipping user knowledge base");
+      return "";
     }
-    logger.info(`[ConversationSearch] Retrieved ${results.length} candidates for reranking`);
-    const candidatesForReranking = results.map((r) => ({
-      ...r,
-      userPrompt: r.metadata?.userPrompt || ""
-    }));
-    const reranked = rerankConversationResults(userPrompt, candidatesForReranking, hybridOptions);
-    if (reranked.length === 0) {
-      logger.info("[ConversationSearch] No results after reranking");
-      return null;
+    if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["getByUser"]) {
+      logger.warn("[KnowledgeBase] knowledge-base.getByUser collection not registered, skipping");
+      return "";
     }
-    const best = reranked[0];
-    const hybridScore = best.hybridScore;
-    const semanticScore = best.similarity || 0;
-    const matchedUserPrompt = best.userPrompt || best.metadata?.userPrompt || "";
-    logger.info(`[ConversationSearch] Best match after reranking:`);
-    logger.info(`  - Hybrid score: ${(hybridScore * 100).toFixed(2)}%`);
-    logger.info(`  - Semantic score: ${(semanticScore * 100).toFixed(2)}%`);
-    logger.info(`  - BM25L score: ${best.bm25Score.toFixed(4)}`);
-    logger.info(`  - Matched prompt: "${matchedUserPrompt}"`);
-    logger.info(`  - Query prompt: "${userPrompt}"`);
-    if (semanticScore < similarityThreshold) {
-      logger.info(
-        `[ConversationSearch] Semantic score ${(semanticScore * 100).toFixed(2)}% below threshold ${(similarityThreshold * 100).toFixed(2)}% - rejecting match`
-      );
-      return null;
+    const result = await collections["knowledge-base"]["getByUser"]({
+      userId: Number(userId),
+      limit
+    });
+    if (!result || !result.content) {
+      logger.info(`[KnowledgeBase] No user knowledge base nodes found for userId: ${userId}`);
+      return "";
     }
-    logger.info(
-      `[ConversationSearch] \u2713 Found match with semantic score ${(semanticScore * 100).toFixed(2)}%`
-    );
-    return {
-      uiBlock: best.uiBlock,
-      similarity: semanticScore,
-      hybridScore,
-      bm25Score: best.bm25Score,
-      metadata: best.metadata
-    };
+    logger.info(`[KnowledgeBase] Retrieved ${result.count || 0} user knowledge base nodes for userId: ${userId}`);
+    return result.content;
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
-    logger.warn(`[ConversationSearch] Error in hybrid search: ${errorMsg}`);
-    return null;
-  }
-};
-var ConversationSearch = {
-  searchConversations,
-  searchConversationsWithReranking
-};
-var conversation_search_default = ConversationSearch;
-
-// src/userResponse/prompt-extractor.ts
-function extractPromptText(content) {
-  if (content === null || content === void 0) {
+    logger.warn(`[KnowledgeBase] Error fetching user knowledge base: ${errorMsg}`);
     return "";
   }
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return content.map((item) => extractContentBlockText(item)).filter((text) => text.length > 0).join("\n\n---\n\n");
-  }
-  if (content && typeof content === "object") {
-    return extractObjectText(content);
-  }
-  return String(content);
-}
-function extractContentBlockText(item) {
-  if (typeof item === "string") {
-    return item;
-  }
-  if (item && typeof item === "object") {
-    const obj = item;
-    if (typeof obj.text === "string") {
-      return obj.text;
-    }
-    if (typeof obj.content === "string") {
-      return obj.content;
-    }
-    return JSON.stringify(item, null, 2);
+};
+var getAllKnowledgeBase = async ({
+  prompt,
+  collections,
+  userId,
+  topK = 3
+}) => {
+  const [globalContext, userContext, queryContext] = await Promise.all([
+    getGlobalKnowledgeBase({ collections }),
+    getUserKnowledgeBase({ collections, userId }),
+    getKnowledgeBase({ prompt, collections, topK })
+  ]);
+  let combinedContext = "";
+  if (globalContext) {
+    combinedContext += "## Global Knowledge Base\n";
+    combinedContext += "The following information applies to all queries:\n\n";
+    combinedContext += globalContext + "\n\n";
   }
-  return String(item);
-}
-function extractObjectText(obj) {
-  if (typeof obj.text === "string") {
-    return obj.text;
+  if (userContext) {
+    combinedContext += "## User-Specific Knowledge Base\n";
+    combinedContext += "The following information is specific to this user:\n\n";
+    combinedContext += userContext + "\n\n";
   }
-  if (typeof obj.content === "string") {
-    return obj.content;
+  if (queryContext) {
+    combinedContext += "## Relevant Knowledge Base (Query-Matched)\n";
+    combinedContext += "The following information is semantically relevant to the current query:\n\n";
+    combinedContext += queryContext + "\n\n";
   }
-  return JSON.stringify(obj, null, 2);
-}
-
-// src/userResponse/constants.ts
-var MAX_QUERY_VALIDATION_RETRIES = 3;
-var MAX_QUERY_ATTEMPTS = 6;
-var MAX_TOOL_ATTEMPTS = 3;
-var STREAM_FLUSH_INTERVAL_MS = 50;
-var PROGRESS_HEARTBEAT_INTERVAL_MS = 800;
-var STREAM_DELAY_MS = 50;
-var STREAM_IMMEDIATE_FLUSH_THRESHOLD = 100;
-var MAX_TOKENS_QUERY_FIX = 2048;
-var MAX_TOKENS_COMPONENT_MATCHING = 8192;
-var MAX_TOKENS_CLASSIFICATION = 1500;
-var MAX_TOKENS_ADAPTATION = 8192;
-var MAX_TOKENS_TEXT_RESPONSE = 4e3;
-var MAX_TOKENS_NEXT_QUESTIONS = 1200;
-var DEFAULT_MAX_ROWS_FOR_LLM = 10;
-var DEFAULT_MAX_CHARS_PER_FIELD2 = 500;
-var STREAM_PREVIEW_MAX_ROWS = 10;
-var STREAM_PREVIEW_MAX_CHARS = 200;
-var TOOL_TRACKING_MAX_ROWS = 5;
-var TOOL_TRACKING_MAX_CHARS = 200;
-var TOOL_TRACKING_SAMPLE_ROWS = 3;
-var DEFAULT_QUERY_LIMIT = 10;
-var MAX_COMPONENT_QUERY_LIMIT = 10;
-var EXACT_MATCH_SIMILARITY_THRESHOLD = 0.99;
-var DEFAULT_CONVERSATION_SIMILARITY_THRESHOLD = 0.8;
-var MAX_TOOL_CALLING_ITERATIONS = 20;
-var KNOWLEDGE_BASE_TOP_K = 3;
+  return {
+    globalContext,
+    userContext,
+    queryContext,
+    combinedContext: combinedContext.trim()
+  };
+};
+var KB = {
+  getKnowledgeBase,
+  getGlobalKnowledgeBase,
+  getUserKnowledgeBase,
+  getAllKnowledgeBase
+};
+var knowledge_base_default = KB;
 
-// src/userResponse/stream-buffer.ts
-var StreamBuffer = class {
-  constructor(callback) {
-    this.buffer = "";
-    this.flushTimer = null;
-    this.fullText = "";
-    this.callback = callback;
+// src/userResponse/prompt-extractor.ts
+function extractPromptText(content) {
+  if (content === null || content === void 0) {
+    return "";
   }
-  /**
-   * Check if the buffer has a callback configured
-   */
-  hasCallback() {
-    return !!this.callback;
+  if (typeof content === "string") {
+    return content;
   }
-  /**
-   * Get all text that has been written (including already flushed)
-   */
-  getFullText() {
-    return this.fullText;
+  if (Array.isArray(content)) {
+    return content.map((item) => extractContentBlockText(item)).filter((text) => text.length > 0).join("\n\n---\n\n");
   }
-  /**
-   * Write a chunk to the buffer
-   * Large chunks or chunks with newlines are flushed immediately
-   * Small chunks are batched and flushed after a short interval
-   *
-   * @param chunk - Text chunk to write
-   */
-  write(chunk) {
-    this.fullText += chunk;
-    if (!this.callback) {
-      return;
-    }
-    this.buffer += chunk;
-    if (chunk.includes("\n") || chunk.length > STREAM_IMMEDIATE_FLUSH_THRESHOLD) {
-      this.flushNow();
-    } else if (!this.flushTimer) {
-      this.flushTimer = setTimeout(() => this.flushNow(), STREAM_FLUSH_INTERVAL_MS);
-    }
+  if (content && typeof content === "object") {
+    return extractObjectText(content);
   }
-  /**
-   * Flush the buffer immediately
-   * Call this before tool execution or other operations that need clean output
-   */
-  flush() {
-    this.flushNow();
+  return String(content);
+}
+function extractContentBlockText(item) {
+  if (typeof item === "string") {
+    return item;
   }
-  /**
-   * Internal flush implementation
-   */
-  flushNow() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
+  if (item && typeof item === "object") {
+    const obj = item;
+    if (typeof obj.text === "string") {
+      return obj.text;
     }
-    if (this.buffer && this.callback) {
-      this.callback(this.buffer);
-      this.buffer = "";
+    if (typeof obj.content === "string") {
+      return obj.content;
     }
+    return JSON.stringify(item, null, 2);
   }
-  /**
-   * Clean up resources
-   * Call this when done with the buffer
-   */
-  dispose() {
-    this.flush();
-    this.callback = void 0;
-  }
-};
-function streamDelay(ms = STREAM_DELAY_MS) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return String(item);
 }
-async function withProgressHeartbeat(operation, progressMessage, streamBuffer, intervalMs = PROGRESS_HEARTBEAT_INTERVAL_MS) {
-  if (!streamBuffer.hasCallback()) {
-    return operation();
+function extractObjectText(obj) {
+  if (typeof obj.text === "string") {
+    return obj.text;
   }
-  const startTime = Date.now();
-  await streamDelay(30);
-  streamBuffer.write(`\u23F3 ${progressMessage}`);
-  const heartbeatInterval = setInterval(() => {
-    const elapsedSeconds = Math.floor((Date.now() - startTime) / 1e3);
-    if (elapsedSeconds >= 1) {
-      streamBuffer.write(` (${elapsedSeconds}s)`);
-    }
-  }, intervalMs);
-  try {
-    const result = await operation();
-    return result;
-  } finally {
-    clearInterval(heartbeatInterval);
-    streamBuffer.write("\n\n");
+  if (typeof obj.content === "string") {
+    return obj.content;
   }
+  return JSON.stringify(obj, null, 2);
 }
 
 // src/userResponse/utils/component-props-processor.ts
@@ -8449,48 +9127,48 @@ ${executedToolsText}`);
   }
 };
 
-// src/userResponse/groq.ts
+// src/userResponse/anthropic.ts
 dotenv.config();
-var GroqLLM = class extends BaseLLM {
+var AnthropicLLM = class extends BaseLLM {
   constructor(config) {
     super(config);
   }
   getDefaultModel() {
-    return "groq/openai/gpt-oss-120b";
+    return "anthropic/claude-sonnet-4-5-20250929";
   }
   getDefaultFastModel() {
-    return "groq/llama-3.1-8b-instant";
+    return "anthropic/claude-haiku-4-5-20251001";
   }
   getDefaultApiKey() {
-    return process.env.GROQ_API_KEY;
+    return process.env.ANTHROPIC_API_KEY;
   }
   getProviderName() {
-    return "Groq";
+    return "Anthropic";
   }
 };
-var groqLLM = new GroqLLM();
+var anthropicLLM = new AnthropicLLM();
 
-// src/userResponse/anthropic.ts
+// src/userResponse/groq.ts
 import dotenv2 from "dotenv";
 dotenv2.config();
-var AnthropicLLM = class extends BaseLLM {
+var GroqLLM = class extends BaseLLM {
   constructor(config) {
     super(config);
   }
   getDefaultModel() {
-    return "anthropic/claude-sonnet-4-5-20250929";
+    return "groq/openai/gpt-oss-120b";
   }
   getDefaultFastModel() {
-    return "anthropic/claude-haiku-4-5-20251001";
+    return "groq/llama-3.1-8b-instant";
   }
   getDefaultApiKey() {
-    return process.env.ANTHROPIC_API_KEY;
+    return process.env.GROQ_API_KEY;
   }
   getProviderName() {
-    return "Anthropic";
+    return "Groq";
   }
 };
-var anthropicLLM = new AnthropicLLM();
+var groqLLM = new GroqLLM();
 
 // src/userResponse/gemini.ts
 import dotenv3 from "dotenv";
@@ -8536,115 +9214,214 @@ var OpenAILLM = class extends BaseLLM {
 };
 var openaiLLM = new OpenAILLM();
 
-// src/userResponse/index.ts
-import dotenv5 from "dotenv";
-dotenv5.config();
-function getLLMProviders() {
-  const envProviders = process.env.LLM_PROVIDERS;
-  const DEFAULT_PROVIDERS = ["anthropic", "gemini", "openai", "groq"];
-  if (!envProviders) {
-    return DEFAULT_PROVIDERS;
-  }
+// src/userResponse/agent-user-response.ts
+function getLLMInstance(provider) {
+  switch (provider) {
+    case "anthropic":
+      return anthropicLLM;
+    case "groq":
+      return groqLLM;
+    case "gemini":
+      return geminiLLM;
+    case "openai":
+      return openaiLLM;
+    default:
+      return anthropicLLM;
+  }
+}
+var get_agent_user_response = async (prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, conversationHistory, streamCallback, collections, externalTools, userId) => {
+  const startTime = Date.now();
+  const providers = llmProviders || ["anthropic"];
+  const provider = providers[0];
+  const llmInstance = getLLMInstance(provider);
+  logger.info(`[AgentFlow] Starting | provider: ${provider} | prompt: "${prompt.substring(0, 50)}..."`);
   try {
-    const providers = JSON.parse(envProviders);
-    const validProviders = providers.filter((p) => p === "anthropic" || p === "groq" || p === "gemini" || p === "openai");
-    if (validProviders.length === 0) {
-      return DEFAULT_PROVIDERS;
-    }
-    return validProviders;
-  } catch (error) {
-    logger.error('Failed to parse LLM_PROVIDERS, defaulting to ["anthropic"]:', error);
-    return DEFAULT_PROVIDERS;
-  }
-}
-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");
-    return { success: false, errors: [emptyMsg] };
-  }
-  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, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
-  logger.debug("[useGroqMethod] Initializing Groq LLM matching method");
-  logger.debug(`[useGroqMethod] Response mode: ${responseMode}`);
-  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");
-    return { success: false, errors: [emptyMsg] };
-  }
-  logger.debug(`[useGroqMethod] Processing with ${components.length} components`);
-  const matchResult = await groqLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-  logger.info(`[useGroqMethod] Successfully generated ${responseMode} using Groq`);
-  return matchResult;
-};
-var useGeminiMethod = async (prompt, components, apiKey, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
-  logger.debug("[useGeminiMethod] Initializing Gemini LLM matching method");
-  logger.debug(`[useGeminiMethod] Response mode: ${responseMode}`);
-  if (responseMode === "component" && components.length === 0) {
-    const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
-    logger.error("[useGeminiMethod] No components available");
-    return { success: false, errors: [emptyMsg] };
-  }
-  logger.debug(`[useGeminiMethod] Processing with ${components.length} components`);
-  const matchResult = await geminiLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-  logger.info(`[useGeminiMethod] Successfully generated ${responseMode} using Gemini`);
-  return matchResult;
-};
-var useOpenAIMethod = async (prompt, components, apiKey, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
-  logger.debug("[useOpenAIMethod] Initializing OpenAI GPT matching method");
-  logger.debug(`[useOpenAIMethod] Response mode: ${responseMode}`);
-  if (responseMode === "component" && components.length === 0) {
-    const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
-    logger.error("[useOpenAIMethod] No components available");
-    return { success: false, errors: [emptyMsg] };
-  }
-  logger.debug(`[useOpenAIMethod] Processing with ${components.length} components`);
-  const matchResult = await openaiLLM.handleUserRequest(prompt, components, apiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-  logger.info(`[useOpenAIMethod] Successfully generated ${responseMode} using OpenAI`);
-  return matchResult;
-};
-var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
-  const providers = llmProviders || getLLMProviders();
-  const errors = [];
-  logger.info(`[get_user_response] LLM Provider order: [${providers.join(", ")}]`);
-  for (let i = 0; i < providers.length; i++) {
-    const provider = providers[i];
-    const isLastProvider = i === providers.length - 1;
-    logger.info(`[get_user_response] Attempting provider: ${provider} (${i + 1}/${providers.length})`);
-    let result;
-    if (provider === "anthropic") {
-      result = await useAnthropicMethod(prompt, components, anthropicApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-    } else if (provider === "groq") {
-      result = await useGroqMethod(prompt, components, groqApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-    } else if (provider === "gemini") {
-      result = await useGeminiMethod(prompt, components, geminiApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-    } else if (provider === "openai") {
-      result = await useOpenAIMethod(prompt, components, openaiApiKey, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
-    } else {
-      logger.warn(`[get_user_response] Unknown provider: ${provider} - skipping`);
-      errors.push(`Unknown provider: ${provider}`);
-      continue;
-    }
-    if (result.success) {
-      logger.info(`[get_user_response] Success with provider: ${provider}`);
-      return result;
+    const conversationMatch = await conversation_search_default.searchConversationsWithReranking({
+      userPrompt: prompt,
+      collections,
+      userId,
+      similarityThreshold: EXACT_MATCH_SIMILARITY_THRESHOLD
+    });
+    if (conversationMatch) {
+      logger.info(`[AgentFlow] Found matching conversation (${(conversationMatch.similarity * 100).toFixed(2)}% similarity)`);
+      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 (conversationMatch.similarity >= EXACT_MATCH_SIMILARITY_THRESHOLD) {
+        if (streamCallback && cachedTextResponse) {
+          streamCallback(cachedTextResponse);
+        }
+        const elapsedTime2 = Date.now() - startTime;
+        logger.info(`[AgentFlow] Exact match \u2014 returning cached result (${elapsedTime2}ms)`);
+        return {
+          success: true,
+          data: {
+            text: cachedTextResponse,
+            component,
+            actions: conversationMatch.uiBlock?.actions || [],
+            reasoning: `Exact match from previous conversation`,
+            method: `${provider}-agent-semantic-match`,
+            semanticSimilarity: conversationMatch.similarity
+          },
+          errors: []
+        };
+      }
+      logger.info(`[AgentFlow] Similar match but below exact threshold \u2014 proceeding with agent`);
     } else {
-      const providerErrors = result.errors.map((err) => `${provider}: ${err}`);
-      errors.push(...providerErrors);
-      logger.warn(`[get_user_response] Provider ${provider} returned unsuccessful result: ${result.errors.join(", ")}`);
-      if (!isLastProvider) {
-        logger.info("[get_user_response] Falling back to next provider...");
+      logger.info(`[AgentFlow] No matching conversations \u2014 proceeding with agent`);
+    }
+    const apiKey = (() => {
+      switch (provider) {
+        case "anthropic":
+          return anthropicApiKey;
+        case "groq":
+          return groqApiKey;
+        case "gemini":
+          return geminiApiKey;
+        case "openai":
+          return openaiApiKey;
+        default:
+          return anthropicApiKey;
+      }
+    })();
+    const agentTools = (externalTools || []).map((t) => ({
+      id: t.id,
+      name: t.name,
+      description: t.description,
+      fn: t.fn,
+      limit: t.limit,
+      outputSchema: t.outputSchema,
+      executionType: t.executionType,
+      userProvidedData: t.userProvidedData,
+      params: t.params
+    }));
+    const agentConfig = {
+      ...DEFAULT_AGENT_CONFIG,
+      apiKey: apiKey || void 0
+    };
+    const streamBuffer = new StreamBuffer(streamCallback);
+    const mainAgent = new MainAgent(agentTools, agentConfig, streamBuffer);
+    const agentResponse = await mainAgent.handleQuestion(
+      prompt,
+      apiKey,
+      conversationHistory,
+      streamBuffer.hasCallback() ? (chunk) => streamBuffer.write(chunk) : void 0
+    );
+    const textResponse = streamBuffer.getFullText() || agentResponse.text || "I apologize, but I was unable to generate a response.";
+    streamBuffer.flush();
+    const hasExecutedTools = agentResponse.executedTools.length > 0;
+    let matchedComponents = [];
+    let layoutTitle = "Dashboard";
+    let layoutDescription = "Multi-component dashboard";
+    let actions = [];
+    if (!hasExecutedTools) {
+      logger.info(`[AgentFlow] No tools executed \u2014 general question, skipping component generation`);
+      const nextQuestions = await llmInstance.generateNextQuestions(
+        prompt,
+        null,
+        void 0,
+        apiKey,
+        conversationHistory,
+        textResponse
+      );
+      actions = convertQuestionsToActions(nextQuestions);
+    } else if (components && components.length > 0) {
+      logger.info(`[AgentFlow] ${agentResponse.executedTools.length} tools executed \u2014 generating components`);
+      if (streamBuffer.hasCallback()) {
+        streamBuffer.write("\n\n\u{1F4CA} **Generating visualization components...**\n\n");
+        streamBuffer.write("__TEXT_COMPLETE__COMPONENT_GENERATION_START__");
+      }
+      const componentStreamCallback = streamBuffer.hasCallback() ? (component) => {
+        const answerMarker = `__ANSWER_COMPONENT_START__${JSON.stringify(component)}__ANSWER_COMPONENT_END__`;
+        streamBuffer.write(answerMarker);
+      } : void 0;
+      const sanitizedTextResponse = textResponse.replace(
+        /<DataTable>[\s\S]*?<\/DataTable>/g,
+        "<DataTable>[Data preview removed - for table components, REUSE the exact SQL query shown above (the one that returned these results). Do NOT write a new query or embed data in props.]</DataTable>"
+      );
+      const matchResult = await llmInstance.matchComponentsFromAnalysis(
+        sanitizedTextResponse,
+        components,
+        prompt,
+        apiKey,
+        componentStreamCallback,
+        [],
+        // deferredTools — MainAgent handles tool execution
+        agentResponse.executedTools,
+        collections,
+        userId
+      );
+      matchedComponents = matchResult.components;
+      layoutTitle = matchResult.layoutTitle;
+      layoutDescription = matchResult.layoutDescription;
+      actions = matchResult.actions;
+    }
+    const securedComponents = matchedComponents.map((comp) => {
+      const props = { ...comp.props };
+      if (props.externalTool?.parameters?.sql) {
+        const { sql, ...restParams } = props.externalTool.parameters;
+        const queryId = queryCache.storeQuery(sql);
+        props.externalTool = {
+          ...props.externalTool,
+          parameters: { queryId, ...restParams }
+        };
       }
+      if (props.query) {
+        const { query, ...restProps } = props;
+        const queryId = queryCache.storeQuery(query);
+        return { ...comp, props: { ...restProps, queryId } };
+      }
+      return { ...comp, props };
+    });
+    let containerComponent = null;
+    if (securedComponents.length > 0) {
+      containerComponent = {
+        id: `container_${Date.now()}`,
+        name: "MultiComponentContainer",
+        type: "Container",
+        description: layoutDescription,
+        props: {
+          config: {
+            title: layoutTitle,
+            description: layoutDescription,
+            components: securedComponents
+          },
+          actions
+        }
+      };
     }
+    const elapsedTime = Date.now() - startTime;
+    logger.info(`[AgentFlow] Complete | ${agentResponse.executedTools.length} tools | ${matchedComponents.length} components | ${elapsedTime}ms`);
+    return {
+      success: true,
+      data: {
+        text: textResponse,
+        component: containerComponent,
+        actions,
+        method: `${provider}-agent-response`
+      },
+      errors: []
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.error(`[AgentFlow] Error: ${errorMsg}`);
+    userPromptErrorLogger.logError(
+      "agentUserResponse",
+      error instanceof Error ? error : new Error(errorMsg),
+      { userPrompt: prompt }
+    );
+    const elapsedTime = Date.now() - startTime;
+    logger.info(`[AgentFlow] Failed in ${elapsedTime}ms`);
+    return {
+      success: false,
+      errors: [errorMsg],
+      data: {
+        text: "I apologize, but I encountered an error processing your request. Please try again.",
+        method: `${provider}-agent-error`
+      }
+    };
   }
-  logger.error(`[get_user_response] All LLM providers failed. Errors: ${errors.join("; ")}`);
-  return {
-    success: false,
-    errors
-  };
 };
 
 // src/utils/conversation-saver.ts
@@ -8842,7 +9619,7 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
       sendMessage(streamMessage);
     };
   }
-  const userResponse = await get_user_response(
+  const userResponse = await get_agent_user_response(
     prompt,
     components,
     anthropicApiKey,
@@ -8851,7 +9628,6 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     openaiApiKey,
     llmProviders,
     conversationHistory,
-    responseMode,
     streamCallback,
     collections,
     externalTools,
@@ -12739,6 +13515,28 @@ async function handleSchemaRequest(message, sendMessage) {
   }
 }
 
+// src/userResponse/index.ts
+import dotenv5 from "dotenv";
+dotenv5.config();
+function getLLMProviders() {
+  const envProviders = process.env.LLM_PROVIDERS;
+  const DEFAULT_PROVIDERS = ["anthropic", "gemini", "openai", "groq"];
+  if (!envProviders) {
+    return DEFAULT_PROVIDERS;
+  }
+  try {
+    const providers = JSON.parse(envProviders);
+    const validProviders = providers.filter((p) => p === "anthropic" || p === "groq" || p === "gemini" || p === "openai");
+    if (validProviders.length === 0) {
+      return DEFAULT_PROVIDERS;
+    }
+    return validProviders;
+  } catch (error) {
+    logger.error('Failed to parse LLM_PROVIDERS, defaulting to ["anthropic"]:', error);
+    return DEFAULT_PROVIDERS;
+  }
+}
+
 // src/auth/user-manager.ts
 import fs7 from "fs";
 import path6 from "path";