@superatomai/sdk-node 0.0.39 → 0.0.41

package/dist/index.js

@@ -1276,13 +1276,16 @@ var init_prompt_loader = __esm({
         const contextMarker = "---\n\n## CONTEXT";
         if (template.system.includes(contextMarker)) {
           const [staticPart, contextPart] = template.system.split(contextMarker);
-          logger.debug(`\u2713 Prompt caching enabled for '${promptName}' (static: ${staticPart.length} chars, context: ${contextPart.length} chars)`);
+          const processedStatic = this.replaceVariables(staticPart, variables);
           const processedContext = this.replaceVariables(contextMarker + contextPart, variables);
+          const staticLength = processedStatic.length;
+          const contextLength = processedContext.length;
+          logger.debug(`\u2713 Prompt caching enabled for '${promptName}' (cached: ${staticLength} chars, dynamic: ${contextLength} chars)`);
           return {
             system: [
               {
                 type: "text",
-                text: staticPart.trim(),
+                text: processedStatic.trim(),
                 cache_control: { type: "ephemeral" }
               },
               {
@@ -1620,10 +1623,16 @@ __export(index_exports, {
   UIBlock: () => UIBlock,
   UILogCollector: () => UILogCollector,
   UserManager: () => UserManager,
+  anthropicLLM: () => anthropicLLM,
+  geminiLLM: () => geminiLLM,
+  groqLLM: () => groqLLM,
   hybridRerank: () => hybridRerank,
+  llmUsageLogger: () => llmUsageLogger,
   logger: () => logger,
+  openaiLLM: () => openaiLLM,
   rerankChromaResults: () => rerankChromaResults,
-  rerankConversationResults: () => rerankConversationResults
+  rerankConversationResults: () => rerankConversationResults,
+  userPromptErrorLogger: () => userPromptErrorLogger
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -3422,6 +3431,465 @@ var import_groq_sdk = __toESM(require("groq-sdk"));
 var import_generative_ai = require("@google/generative-ai");
 var import_openai = __toESM(require("openai"));
 var import_jsonrepair = require("jsonrepair");
+
+// src/utils/llm-usage-logger.ts
+var import_fs4 = __toESM(require("fs"));
+var import_path3 = __toESM(require("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 (December 2025)
+  "gemini-3-pro": { input: 2, output: 8 },
+  // New Gemini 3
+  "gemini-2.5-pro": { input: 1.25, output: 10 },
+  // For prompts ≤200K tokens, 2x for >200K
+  "gemini-2.5-flash": { input: 0.15, output: 0.6 },
+  // Standard mode (thinking disabled: $0.60, thinking enabled: $3.50)
+  "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 || import_path3.default.join(process.cwd(), "llm-usage-logs");
+    this.enabled = process.env.LLM_USAGE_LOGGING !== "false";
+    if (this.enabled) {
+      this.initLogStream();
+    }
+  }
+  initLogStream() {
+    try {
+      const dir = import_path3.default.dirname(this.logPath);
+      if (!import_fs4.default.existsSync(dir)) {
+        import_fs4.default.mkdirSync(dir, { recursive: true });
+      }
+      this.logStream = import_fs4.default.createWriteStream(this.logPath, { flags: "a" });
+      if (!import_fs4.default.existsSync(this.logPath) || import_fs4.default.statSync(this.logPath).size === 0) {
+        this.writeHeader();
+      }
+    } catch (error) {
+      console.error("[LLM-Usage-Logger] Failed to initialize log stream:", error);
+      this.enabled = false;
+    }
+  }
+  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.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;
+  }
+  /**
+   * Log an LLM API call
+   */
+  log(entry) {
+    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);
+    if (entry.cacheReadTokens && entry.cacheReadTokens > 0) {
+      console.log(`[LLM] \u26A1 CACHE HIT: ${entry.cacheReadTokens.toLocaleString()} tokens read from cache (${entry.method})`);
+    } else if (entry.cacheWriteTokens && entry.cacheWriteTokens > 0) {
+      console.log(`[LLM] \u{1F4DD} CACHE WRITE: ${entry.cacheWriteTokens.toLocaleString()} tokens cached for future requests (${entry.method})`);
+    }
+    if (process.env.SUPERATOM_LOG_LEVEL === "verbose") {
+      console.log("\n[LLM-Usage]", logLine);
+    }
+  }
+  /**
+   * Log session summary (call at end of request)
+   */
+  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 = `
+--------------------------------------------------------------------------------
+SESSION SUMMARY${requestContext ? ` (${requestContext})` : ""}
+--------------------------------------------------------------------------------
+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.logStream?.write(summary);
+    console.log("\n[LLM-Usage] Session Summary:");
+    console.log(`  Calls: ${this.sessionStats.totalCalls} | Tokens: ${(this.sessionStats.totalInputTokens + this.sessionStats.totalOutputTokens).toLocaleString()} | Cost: $${this.sessionStats.totalCostUSD.toFixed(4)} | Time: ${(this.sessionStats.totalDurationMs / 1e3).toFixed(2)}s`);
+    if (hasCaching) {
+      console.log(`  Cache: ${this.sessionStats.totalCacheReadTokens.toLocaleString()} read, ${this.sessionStats.totalCacheWriteTokens.toLocaleString()} written | Savings: ~$${cacheReadSavings.toFixed(4)}`);
+    }
+  }
+  /**
+   * Reset session stats (call at start of new user request)
+   */
+  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 = import_fs4.default.createWriteStream(this.logPath, { flags: "w" });
+      const header = `
+================================================================================
+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.logStream.write(header);
+      this.resetSession();
+      console.log(`[LLM-Usage] Log file reset for new request: ${this.logPath}`);
+    } catch (error) {
+      console.error("[LLM-Usage-Logger] Failed to reset log file:", error);
+    }
+  }
+  /**
+   * Get current session stats
+   */
+  getSessionStats() {
+    return { ...this.sessionStats };
+  }
+  /**
+   * Generate a unique request ID
+   */
+  generateRequestId() {
+    return `req-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+  }
+};
+var llmUsageLogger = new LLMUsageLogger();
+
+// src/utils/user-prompt-error-logger.ts
+var import_fs5 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var UserPromptErrorLogger = class {
+  constructor() {
+    this.logStream = null;
+    this.hasErrors = false;
+    this.logPath = process.env.USER_PROMPT_ERROR_LOG_PATH || import_path4.default.join(process.cwd(), "user-prompt-req-errors");
+    this.enabled = process.env.USER_PROMPT_ERROR_LOGGING !== "false";
+  }
+  /**
+   * Reset the error log file for a new request
+   */
+  resetLogFile(requestContext) {
+    if (!this.enabled) return;
+    try {
+      if (this.logStream) {
+        this.logStream.end();
+        this.logStream = null;
+      }
+      const dir = import_path4.default.dirname(this.logPath);
+      if (dir !== "." && !import_fs5.default.existsSync(dir)) {
+        import_fs5.default.mkdirSync(dir, { recursive: true });
+      }
+      this.logStream = import_fs5.default.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);
+    }
+  }
+  /**
+   * Log a JSON parse error with the raw string that failed
+   */
+  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}`);
+  }
+  /**
+   * Log a general error with full details
+   */
+  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)}
+`;
+    }
+    if (errorStack) {
+      entry += `
+Stack Trace:
+${errorStack}
+`;
+    }
+    entry += `--------------------------------------------------------------------------------
+
+`;
+    this.write(entry);
+    console.error(`[UserPromptError] ${context}: ${errorMessage}`);
+  }
+  /**
+   * Log a SQL query error with the full query
+   */
+  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}`);
+  }
+  /**
+   * Log an LLM API error
+   */
+  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}
+`;
+    }
+    if (errorStack) {
+      entry += `
+Stack Trace:
+${errorStack}
+`;
+    }
+    entry += `--------------------------------------------------------------------------------
+
+`;
+    this.write(entry);
+    console.error(`[UserPromptError] LLM Error (${provider}/${model}): ${errorMessage}`);
+  }
+  /**
+   * Log tool execution error
+   */
+  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 = `
+--------------------------------------------------------------------------------
+[${(/* @__PURE__ */ new Date()).toISOString()}] TOOL EXECUTION ERROR
+--------------------------------------------------------------------------------
+Tool: ${toolName}
+Error: ${errorMessage}
+
+Tool Input:
+${JSON.stringify(toolInput, null, 2)}
+${errorStack ? `
+Stack Trace:
+${errorStack}` : ""}
+--------------------------------------------------------------------------------
+
+`;
+    this.write(entry);
+    console.error(`[UserPromptError] Tool Error (${toolName}): ${errorMessage}`);
+  }
+  /**
+   * Write final summary if there were errors
+   */
+  writeSummary() {
+    if (!this.enabled || !this.hasErrors) return;
+    const summary = `
+================================================================================
+REQUEST COMPLETED WITH ERRORS
+Time: ${(/* @__PURE__ */ new Date()).toISOString()}
+================================================================================
+`;
+    this.write(summary);
+  }
+  /**
+   * Check if any errors were logged
+   */
+  hadErrors() {
+    return this.hasErrors;
+  }
+  write(content) {
+    if (this.logStream) {
+      this.logStream.write(content);
+    }
+  }
+};
+var userPromptErrorLogger = new UserPromptErrorLogger();
+
+// src/llm.ts
 var LLM = class {
   /* Get a complete text response from an LLM (Anthropic or Groq) */
   static async text(messages, options = {}) {
@@ -3564,68 +4032,156 @@ var LLM = class {
   // ANTHROPIC IMPLEMENTATION
   // ============================================================
   static async _anthropicText(messages, modelName, options) {
+    const startTime = Date.now();
+    const requestId = llmUsageLogger.generateRequestId();
     const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY || "";
     const client = new import_sdk.default({
       apiKey
     });
-    const response = await client.messages.create({
-      model: modelName,
-      max_tokens: options.maxTokens || 1e3,
-      temperature: options.temperature,
-      system: this._normalizeSystemPrompt(messages.sys),
-      messages: [{
-        role: "user",
-        content: messages.user
-      }]
-    });
-    const textBlock = response.content.find((block) => block.type === "text");
-    return textBlock?.type === "text" ? textBlock.text : "";
+    try {
+      const response = await client.messages.create({
+        model: modelName,
+        max_tokens: options.maxTokens || 1e3,
+        temperature: options.temperature,
+        system: this._normalizeSystemPrompt(messages.sys),
+        messages: [{
+          role: "user",
+          content: messages.user
+        }]
+      });
+      const durationMs = Date.now() - startTime;
+      const usage = response.usage;
+      const inputTokens = usage?.input_tokens || 0;
+      const outputTokens = usage?.output_tokens || 0;
+      const cacheReadTokens = usage?.cache_read_input_tokens || 0;
+      const cacheWriteTokens = usage?.cache_creation_input_tokens || 0;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "anthropic",
+        model: modelName,
+        method: "text",
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens),
+        durationMs,
+        success: true
+      });
+      const textBlock = response.content.find((block) => block.type === "text");
+      return textBlock?.type === "text" ? textBlock.text : "";
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "anthropic",
+        model: modelName,
+        method: "text",
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        costUSD: 0,
+        durationMs,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   }
   static async _anthropicStream(messages, modelName, options, json) {
+    const startTime = Date.now();
+    const requestId = llmUsageLogger.generateRequestId();
     const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY || "";
     const client = new import_sdk.default({
       apiKey
     });
-    const apiMessages = [{
-      role: "user",
-      content: messages.user
-    }];
-    const prefill = messages.prefill || (json ? "{" : void 0);
-    if (prefill) {
-      apiMessages.push({
-        role: "assistant",
-        content: prefill
+    try {
+      const apiMessages = [{
+        role: "user",
+        content: messages.user
+      }];
+      const prefill = messages.prefill || (json ? "{" : void 0);
+      if (prefill) {
+        apiMessages.push({
+          role: "assistant",
+          content: prefill
+        });
+      }
+      const stream = await client.messages.create({
+        model: modelName,
+        max_tokens: options.maxTokens || 1e3,
+        temperature: options.temperature,
+        system: this._normalizeSystemPrompt(messages.sys),
+        messages: apiMessages,
+        stream: true
       });
-    }
-    const stream = await client.messages.create({
-      model: modelName,
-      max_tokens: options.maxTokens || 1e3,
-      temperature: options.temperature,
-      system: this._normalizeSystemPrompt(messages.sys),
-      messages: apiMessages,
-      stream: true
-    });
-    let fullText = prefill || "";
-    let usage = null;
-    for await (const chunk of stream) {
-      if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
-        const text = chunk.delta.text;
-        fullText += text;
-        if (options.partial) {
-          options.partial(text);
+      let fullText = prefill || "";
+      let usage = null;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let cacheReadTokens = 0;
+      let cacheWriteTokens = 0;
+      for await (const chunk of stream) {
+        if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+          const text = chunk.delta.text;
+          fullText += text;
+          if (options.partial) {
+            options.partial(text);
+          }
+        } else if (chunk.type === "message_start" && chunk.message?.usage) {
+          const msgUsage = chunk.message.usage;
+          inputTokens = msgUsage.input_tokens || 0;
+          cacheReadTokens = msgUsage.cache_read_input_tokens || 0;
+          cacheWriteTokens = msgUsage.cache_creation_input_tokens || 0;
+        } else if (chunk.type === "message_delta" && chunk.usage) {
+          usage = chunk.usage;
+          outputTokens = usage.output_tokens || 0;
         }
-      } else if (chunk.type === "message_delta" && chunk.usage) {
-        usage = chunk.usage;
       }
+      const durationMs = Date.now() - startTime;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "anthropic",
+        model: modelName,
+        method: "stream",
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens),
+        durationMs,
+        success: true
+      });
+      if (json) {
+        return this._parseJSON(fullText);
+      }
+      return fullText;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "anthropic",
+        model: modelName,
+        method: "stream",
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        costUSD: 0,
+        durationMs,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    if (usage) {
-    }
-    if (json) {
-      return this._parseJSON(fullText);
-    }
-    return fullText;
   }
   static async _anthropicStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations) {
+    const methodStartTime = Date.now();
     const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY || "";
     const client = new import_sdk.default({
       apiKey
@@ -3636,8 +4192,15 @@ var LLM = class {
     }];
     let iterations = 0;
     let finalText = "";
+    let totalToolCalls = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCacheReadTokens = 0;
+    let totalCacheWriteTokens = 0;
     while (iterations < maxIterations) {
       iterations++;
+      const iterationStartTime = Date.now();
+      const requestId = llmUsageLogger.generateRequestId();
       const stream = await client.messages.create({
         model: modelName,
         max_tokens: options.maxTokens || 4e3,
@@ -3652,12 +4215,21 @@ var LLM = class {
       const contentBlocks = [];
       let currentTextBlock = "";
       let currentToolUse = null;
-      let usage = null;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let cacheReadTokens = 0;
+      let cacheWriteTokens = 0;
       for await (const chunk of stream) {
         if (chunk.type === "message_start") {
           contentBlocks.length = 0;
           currentTextBlock = "";
           currentToolUse = null;
+          const msgUsage = chunk.message?.usage;
+          if (msgUsage) {
+            inputTokens = msgUsage.input_tokens || 0;
+            cacheReadTokens = msgUsage.cache_read_input_tokens || 0;
+            cacheWriteTokens = msgUsage.cache_creation_input_tokens || 0;
+          }
         }
         if (chunk.type === "content_block_start") {
           if (chunk.content_block.type === "text") {
@@ -3704,15 +4276,36 @@ var LLM = class {
         if (chunk.type === "message_delta") {
           stopReason = chunk.delta.stop_reason || stopReason;
           if (chunk.usage) {
-            usage = chunk.usage;
+            outputTokens = chunk.usage.output_tokens || 0;
           }
         }
         if (chunk.type === "message_stop") {
           break;
         }
       }
-      if (usage) {
-      }
+      const iterationDuration = Date.now() - iterationStartTime;
+      const toolUsesInIteration = contentBlocks.filter((block) => block.type === "tool_use").length;
+      totalToolCalls += toolUsesInIteration;
+      totalInputTokens += inputTokens;
+      totalOutputTokens += outputTokens;
+      totalCacheReadTokens += cacheReadTokens;
+      totalCacheWriteTokens += cacheWriteTokens;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "anthropic",
+        model: modelName,
+        method: `streamWithTools[iter=${iterations}]`,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens),
+        durationMs: iterationDuration,
+        toolCalls: toolUsesInIteration,
+        success: true
+      });
       if (stopReason === "end_turn") {
         break;
       }
@@ -3756,6 +4349,25 @@ var LLM = class {
         break;
       }
     }
+    const totalDuration = Date.now() - methodStartTime;
+    if (iterations > 1) {
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId: llmUsageLogger.generateRequestId(),
+        provider: "anthropic",
+        model: modelName,
+        method: `streamWithTools[TOTAL:${iterations}iters]`,
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens,
+        cacheReadTokens: totalCacheReadTokens,
+        cacheWriteTokens: totalCacheWriteTokens,
+        totalTokens: totalInputTokens + totalOutputTokens + totalCacheReadTokens + totalCacheWriteTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, totalInputTokens, totalOutputTokens, totalCacheReadTokens, totalCacheWriteTokens),
+        durationMs: totalDuration,
+        toolCalls: totalToolCalls,
+        success: true
+      });
+    }
     if (iterations >= maxIterations) {
       throw new Error(`Max iterations (${maxIterations}) reached in tool calling loop`);
     }
@@ -3765,100 +4377,272 @@ var LLM = class {
   // GROQ IMPLEMENTATION
   // ============================================================
   static async _groqText(messages, modelName, options) {
+    const startTime = Date.now();
+    const requestId = llmUsageLogger.generateRequestId();
     const client = new import_groq_sdk.default({
       apiKey: options.apiKey || process.env.GROQ_API_KEY || ""
     });
-    const response = await client.chat.completions.create({
-      model: modelName,
-      messages: [
-        { role: "system", content: messages.sys },
-        { role: "user", content: messages.user }
-      ],
-      temperature: options.temperature,
-      max_tokens: options.maxTokens || 1e3
-    });
-    return response.choices[0]?.message?.content || "";
+    try {
+      const response = await client.chat.completions.create({
+        model: modelName,
+        messages: [
+          { role: "system", content: messages.sys },
+          { role: "user", content: messages.user }
+        ],
+        temperature: options.temperature,
+        max_tokens: options.maxTokens || 1e3
+      });
+      const durationMs = Date.now() - startTime;
+      const usage = response.usage;
+      const inputTokens = usage?.prompt_tokens || 0;
+      const outputTokens = usage?.completion_tokens || 0;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "groq",
+        model: modelName,
+        method: "text",
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, inputTokens, outputTokens),
+        durationMs,
+        success: true
+      });
+      return response.choices[0]?.message?.content || "";
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "groq",
+        model: modelName,
+        method: "text",
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        costUSD: 0,
+        durationMs,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   }
   static async _groqStream(messages, modelName, options, json) {
+    const startTime = Date.now();
+    const requestId = llmUsageLogger.generateRequestId();
     const apiKey = options.apiKey || process.env.GROQ_API_KEY || "";
     const client = new import_groq_sdk.default({
       apiKey
     });
-    const stream = await client.chat.completions.create({
-      model: modelName,
-      messages: [
-        { role: "system", content: messages.sys },
-        { role: "user", content: messages.user }
-      ],
-      temperature: options.temperature,
-      max_tokens: options.maxTokens || 1e3,
-      stream: true,
-      response_format: json ? { type: "json_object" } : void 0
-    });
-    let fullText = "";
-    for await (const chunk of stream) {
-      const text = chunk.choices[0]?.delta?.content || "";
-      if (text) {
-        fullText += text;
-        if (options.partial) {
-          options.partial(text);
+    try {
+      const stream = await client.chat.completions.create({
+        model: modelName,
+        messages: [
+          { role: "system", content: messages.sys },
+          { role: "user", content: messages.user }
+        ],
+        temperature: options.temperature,
+        max_tokens: options.maxTokens || 1e3,
+        stream: true,
+        response_format: json ? { type: "json_object" } : void 0
+      });
+      let fullText = "";
+      let inputTokens = 0;
+      let outputTokens = 0;
+      for await (const chunk of stream) {
+        const text = chunk.choices[0]?.delta?.content || "";
+        if (text) {
+          fullText += text;
+          if (options.partial) {
+            options.partial(text);
+          }
+        }
+        if (chunk.x_groq?.usage) {
+          inputTokens = chunk.x_groq.usage.prompt_tokens || 0;
+          outputTokens = chunk.x_groq.usage.completion_tokens || 0;
         }
       }
+      const durationMs = Date.now() - startTime;
+      if (inputTokens === 0) {
+        const sysPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((b) => b.text).join("");
+        inputTokens = Math.ceil((sysPrompt.length + messages.user.length) / 4);
+      }
+      if (outputTokens === 0) {
+        outputTokens = Math.ceil(fullText.length / 4);
+      }
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "groq",
+        model: modelName,
+        method: "stream",
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, inputTokens, outputTokens),
+        durationMs,
+        success: true
+      });
+      if (json) {
+        return this._parseJSON(fullText);
+      }
+      return fullText;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "groq",
+        model: modelName,
+        method: "stream",
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        costUSD: 0,
+        durationMs,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    if (json) {
-      return this._parseJSON(fullText);
-    }
-    return fullText;
   }
   // ============================================================
   // GEMINI IMPLEMENTATION
   // ============================================================
   static async _geminiText(messages, modelName, options) {
+    const startTime = Date.now();
+    const requestId = llmUsageLogger.generateRequestId();
     const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
     const genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
     const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
-    const model = genAI.getGenerativeModel({
-      model: modelName,
-      systemInstruction: systemPrompt,
-      generationConfig: {
-        maxOutputTokens: options.maxTokens || 1e3,
-        temperature: options.temperature,
-        topP: options.topP
-      }
-    });
-    const result = await model.generateContent(messages.user);
-    const response = await result.response;
-    return response.text();
+    try {
+      const model = genAI.getGenerativeModel({
+        model: modelName,
+        systemInstruction: systemPrompt,
+        generationConfig: {
+          maxOutputTokens: options.maxTokens || 1e3,
+          temperature: options.temperature,
+          topP: options.topP
+        }
+      });
+      const result = await model.generateContent(messages.user);
+      const response = await result.response;
+      const text = response.text();
+      const durationMs = Date.now() - startTime;
+      const usage = response.usageMetadata;
+      const inputTokens = usage?.promptTokenCount || Math.ceil((systemPrompt.length + messages.user.length) / 4);
+      const outputTokens = usage?.candidatesTokenCount || Math.ceil(text.length / 4);
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "gemini",
+        model: modelName,
+        method: "text",
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, inputTokens, outputTokens),
+        durationMs,
+        success: true
+      });
+      return text;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "gemini",
+        model: modelName,
+        method: "text",
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        costUSD: 0,
+        durationMs,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   }
   static async _geminiStream(messages, modelName, options, json) {
+    const startTime = Date.now();
+    const requestId = llmUsageLogger.generateRequestId();
     const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
     const genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
     const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
-    const model = genAI.getGenerativeModel({
-      model: modelName,
-      systemInstruction: systemPrompt,
-      generationConfig: {
-        maxOutputTokens: options.maxTokens || 1e3,
-        temperature: options.temperature,
-        topP: options.topP,
-        responseMimeType: json ? "application/json" : void 0
-      }
-    });
-    const result = await model.generateContentStream(messages.user);
-    let fullText = "";
-    for await (const chunk of result.stream) {
-      const text = chunk.text();
-      if (text) {
-        fullText += text;
-        if (options.partial) {
-          options.partial(text);
+    try {
+      const model = genAI.getGenerativeModel({
+        model: modelName,
+        systemInstruction: systemPrompt,
+        generationConfig: {
+          maxOutputTokens: options.maxTokens || 1e3,
+          temperature: options.temperature,
+          topP: options.topP,
+          responseMimeType: json ? "application/json" : void 0
+        }
+      });
+      const result = await model.generateContentStream(messages.user);
+      let fullText = "";
+      let inputTokens = 0;
+      let outputTokens = 0;
+      for await (const chunk of result.stream) {
+        const text = chunk.text();
+        if (text) {
+          fullText += text;
+          if (options.partial) {
+            options.partial(text);
+          }
+        }
+        if (chunk.usageMetadata) {
+          inputTokens = chunk.usageMetadata.promptTokenCount || 0;
+          outputTokens = chunk.usageMetadata.candidatesTokenCount || 0;
         }
       }
+      const durationMs = Date.now() - startTime;
+      if (inputTokens === 0) {
+        inputTokens = Math.ceil((systemPrompt.length + messages.user.length) / 4);
+      }
+      if (outputTokens === 0) {
+        outputTokens = Math.ceil(fullText.length / 4);
+      }
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "gemini",
+        model: modelName,
+        method: "stream",
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, inputTokens, outputTokens),
+        durationMs,
+        success: true
+      });
+      if (json) {
+        return this._parseJSON(fullText);
+      }
+      return fullText;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "gemini",
+        model: modelName,
+        method: "stream",
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        costUSD: 0,
+        durationMs,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    if (json) {
-      return this._parseJSON(fullText);
-    }
-    return fullText;
   }
   static async _geminiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations) {
     const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
@@ -3952,51 +4736,138 @@ var LLM = class {
   // OPENAI IMPLEMENTATION
   // ============================================================
   static async _openaiText(messages, modelName, options) {
+    const startTime = Date.now();
+    const requestId = llmUsageLogger.generateRequestId();
     const apiKey = options.apiKey || process.env.OPENAI_API_KEY || "";
     const openai = new import_openai.default({ apiKey });
     const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
-    const response = await openai.chat.completions.create({
-      model: modelName,
-      messages: [
-        { role: "system", content: systemPrompt },
-        { role: "user", content: messages.user }
-      ],
-      max_tokens: options.maxTokens || 1e3,
-      temperature: options.temperature,
-      top_p: options.topP
-    });
-    return response.choices[0]?.message?.content || "";
+    try {
+      const response = await openai.chat.completions.create({
+        model: modelName,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: messages.user }
+        ],
+        max_tokens: options.maxTokens || 1e3,
+        temperature: options.temperature,
+        top_p: options.topP
+      });
+      const durationMs = Date.now() - startTime;
+      const usage = response.usage;
+      const inputTokens = usage?.prompt_tokens || 0;
+      const outputTokens = usage?.completion_tokens || 0;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "openai",
+        model: modelName,
+        method: "text",
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, inputTokens, outputTokens),
+        durationMs,
+        success: true
+      });
+      return response.choices[0]?.message?.content || "";
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "openai",
+        model: modelName,
+        method: "text",
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        costUSD: 0,
+        durationMs,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   }
   static async _openaiStream(messages, modelName, options, json) {
+    const startTime = Date.now();
+    const requestId = llmUsageLogger.generateRequestId();
     const apiKey = options.apiKey || process.env.OPENAI_API_KEY || "";
     const openai = new import_openai.default({ apiKey });
     const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
-    const stream = await openai.chat.completions.create({
-      model: modelName,
-      messages: [
-        { role: "system", content: systemPrompt },
-        { role: "user", content: messages.user }
-      ],
-      max_tokens: options.maxTokens || 1e3,
-      temperature: options.temperature,
-      top_p: options.topP,
-      response_format: json ? { type: "json_object" } : void 0,
-      stream: true
-    });
-    let fullText = "";
-    for await (const chunk of stream) {
-      const content = chunk.choices[0]?.delta?.content || "";
-      if (content) {
-        fullText += content;
-        if (options.partial) {
-          options.partial(content);
+    try {
+      const stream = await openai.chat.completions.create({
+        model: modelName,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: messages.user }
+        ],
+        max_tokens: options.maxTokens || 1e3,
+        temperature: options.temperature,
+        top_p: options.topP,
+        response_format: json ? { type: "json_object" } : void 0,
+        stream: true,
+        stream_options: { include_usage: true }
+        // Request usage info in stream
+      });
+      let fullText = "";
+      let inputTokens = 0;
+      let outputTokens = 0;
+      for await (const chunk of stream) {
+        const content = chunk.choices[0]?.delta?.content || "";
+        if (content) {
+          fullText += content;
+          if (options.partial) {
+            options.partial(content);
+          }
+        }
+        if (chunk.usage) {
+          inputTokens = chunk.usage.prompt_tokens || 0;
+          outputTokens = chunk.usage.completion_tokens || 0;
         }
       }
+      const durationMs = Date.now() - startTime;
+      if (inputTokens === 0) {
+        inputTokens = Math.ceil((systemPrompt.length + messages.user.length) / 4);
+      }
+      if (outputTokens === 0) {
+        outputTokens = Math.ceil(fullText.length / 4);
+      }
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "openai",
+        model: modelName,
+        method: "stream",
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, inputTokens, outputTokens),
+        durationMs,
+        success: true
+      });
+      if (json) {
+        return this._parseJSON(fullText);
+      }
+      return fullText;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "openai",
+        model: modelName,
+        method: "stream",
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        costUSD: 0,
+        durationMs,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
     }
-    if (json) {
-      return this._parseJSON(fullText);
-    }
-    return fullText;
   }
   static async _openaiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations) {
     const apiKey = options.apiKey || process.env.OPENAI_API_KEY || "";
@@ -4142,11 +5013,9 @@ var LLM = class {
       closeChar = "]";
     }
     if (startIdx === -1) {
-      const preview = text.length > 500 ? text.substring(0, 500) + "..." : text;
-      throw new Error(`No JSON found in response. LLM returned plain text instead of JSON.
-
-Full response:
-${preview}`);
+      const error = new Error(`No JSON found in response. LLM returned plain text instead of JSON.`);
+      userPromptErrorLogger.logJsonParseError("LLM._parseJSON - No JSON structure found", text, error);
+      throw error;
     }
     let depth = 0;
     let inString = false;
@@ -4173,24 +5042,17 @@ ${preview}`);
     if (endIdx !== -1) {
       jsonText = jsonText.substring(startIdx, endIdx + 1);
     } else {
-      const preview = text.length > 500 ? text.substring(0, 500) + "..." : text;
-      throw new Error(`Incomplete JSON - no matching closing ${closeChar} found.
-
-Full response:
-${preview}`);
+      const error = new Error(`Incomplete JSON - no matching closing ${closeChar} found.`);
+      userPromptErrorLogger.logJsonParseError("LLM._parseJSON - Incomplete JSON", text, error);
+      throw error;
     }
     try {
       const repairedJson = (0, import_jsonrepair.jsonrepair)(jsonText);
       return JSON.parse(repairedJson);
     } catch (error) {
-      const preview = text.length > 500 ? text.substring(0, 500) + "..." : text;
-      throw new Error(`Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}
-
-Extracted JSON:
-${jsonText.substring(0, 300)}...
-
-Full response:
-${preview}`);
+      const parseError = error instanceof Error ? error : new Error(String(error));
+      userPromptErrorLogger.logJsonParseError("LLM._parseJSON - JSON parse/repair failed", text, parseError);
+      throw new Error(`Failed to parse JSON: ${parseError.message}`);
     }
   }
 };
@@ -4538,8 +5400,41 @@ var conversation_search_default = ConversationSearch;
 var BaseLLM = class {
   constructor(config) {
     this.model = config?.model || this.getDefaultModel();
+    this.fastModel = config?.fastModel || this.getDefaultFastModel();
     this.defaultLimit = config?.defaultLimit || 50;
     this.apiKey = config?.apiKey;
+    this.modelStrategy = config?.modelStrategy || "fast";
+  }
+  /**
+   * Get the appropriate model based on task type and model strategy
+   * @param taskType - 'complex' for text generation/matching, 'simple' for classification/actions
+   * @returns The model string to use for this task
+   */
+  getModelForTask(taskType) {
+    switch (this.modelStrategy) {
+      case "best":
+        return this.model;
+      case "fast":
+        return this.fastModel;
+      case "balanced":
+      default:
+        return taskType === "complex" ? this.model : this.fastModel;
+    }
+  }
+  /**
+   * Set the model strategy at runtime
+   * @param strategy - 'best', 'fast', or 'balanced'
+   */
+  setModelStrategy(strategy) {
+    this.modelStrategy = strategy;
+    logger.info(`[${this.getProviderName()}] Model strategy set to: ${strategy}`);
+  }
+  /**
+   * Get the current model strategy
+   * @returns The current model strategy
+   */
+  getModelStrategy() {
+    return this.modelStrategy;
   }
   /**
    * Get the API key (from instance, parameter, or environment)
@@ -4724,7 +5619,7 @@ ${JSON.stringify(tool.requiredFields || [], null, 2)}`;
           user: prompts.user
         },
         {
-          model: this.model,
+          model: this.getModelForTask("complex"),
           maxTokens: 8192,
           temperature: 0.2,
           apiKey: this.getApiKey(apiKey),
@@ -4847,7 +5742,7 @@ ${JSON.stringify(tool.requiredFields || [], null, 2)}`;
           user: prompts.user
         },
         {
-          model: this.model,
+          model: this.getModelForTask("simple"),
           maxTokens: 1500,
           temperature: 0.2,
           apiKey: this.getApiKey(apiKey)
@@ -4908,7 +5803,7 @@ ${JSON.stringify(tool.requiredFields || [], null, 2)}`;
           user: prompts.user
         },
         {
-          model: this.model,
+          model: this.getModelForTask("complex"),
           maxTokens: 3e3,
           temperature: 0.2,
           apiKey: this.getApiKey(apiKey)
@@ -5279,6 +6174,7 @@ ${sql}
             const errorMsg = error instanceof Error ? error.message : String(error);
             logger.error(`[${this.getProviderName()}] Query execution failed (attempt ${attempts}/${MAX_QUERY_ATTEMPTS}): ${errorMsg}`);
             logCollector?.error(`Query failed (attempt ${attempts}/${MAX_QUERY_ATTEMPTS}): ${errorMsg}`);
+            userPromptErrorLogger.logSqlError(sql, error instanceof Error ? error : new Error(errorMsg), Object.keys(params).length > 0 ? Object.values(params) : void 0);
             if (wrappedStreamCallback) {
               wrappedStreamCallback(`\u274C **Query execution failed:**
 \`\`\`
@@ -5369,6 +6265,7 @@ Please try rephrasing your request or contact support.
               const errorMsg = error instanceof Error ? error.message : String(error);
               logger.error(`[${this.getProviderName()}] External tool ${externalTool.name} failed (attempt ${attempts}/${MAX_TOOL_ATTEMPTS}): ${errorMsg}`);
               logCollector?.error(`\u2717 ${externalTool.name} failed: ${errorMsg}`);
+              userPromptErrorLogger.logToolError(externalTool.name, toolInput, error instanceof Error ? error : new Error(errorMsg));
               if (wrappedStreamCallback) {
                 wrappedStreamCallback(`\u274C **${externalTool.name} failed:**
 \`\`\`
@@ -5396,7 +6293,7 @@ ${errorMsg}
         tools,
         toolHandler,
         {
-          model: this.model,
+          model: this.getModelForTask("complex"),
           maxTokens: 4e3,
           temperature: 0.7,
           apiKey: this.getApiKey(apiKey),
@@ -5441,6 +6338,21 @@ ${errorMsg}
       if (category === "general") {
         logger.info(`[${this.getProviderName()}] Skipping component generation for general/conversational question`);
         logCollector?.info("Skipping component generation for general question");
+        logger.info(`[${this.getProviderName()}] Generating actions for general question...`);
+        const nextQuestions = await this.generateNextQuestions(
+          userPrompt,
+          null,
+          // no component
+          void 0,
+          // no component data
+          apiKey,
+          logCollector,
+          conversationHistory,
+          textResponse
+          // pass text response as context
+        );
+        actions = convertQuestionsToActions(nextQuestions);
+        logger.info(`[${this.getProviderName()}] Generated ${actions.length} follow-up actions for general question`);
       } else if (components && components.length > 0) {
         logger.info(`[${this.getProviderName()}] Matching components from text response...`);
         const componentStreamCallback = wrappedStreamCallback && category !== "data_modification" ? (component) => {
@@ -5511,6 +6423,13 @@ ${errorMsg}
       const errorMsg = error instanceof Error ? error.message : String(error);
       logger.error(`[${this.getProviderName()}] Error generating text response: ${errorMsg}`);
       logCollector?.error(`Error generating text response: ${errorMsg}`);
+      userPromptErrorLogger.logLlmError(
+        this.getProviderName(),
+        this.model,
+        "generateTextResponse",
+        error instanceof Error ? error : new Error(errorMsg),
+        { userPrompt }
+      );
       errors.push(errorMsg);
       return {
         success: false,
@@ -5592,10 +6511,18 @@ ${errorMsg}
             logger.info(`[${this.getProviderName()}] \u2713 100% match - returning UI block directly without adaptation`);
             logCollector?.info(`\u2713 Exact match (${(conversationMatch.similarity * 100).toFixed(2)}%) - returning cached result`);
             logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            if (streamCallback && cachedTextResponse) {
+              logger.info(`[${this.getProviderName()}] Streaming cached text response to frontend`);
+              streamCallback(cachedTextResponse);
+            }
+            const cachedActions = conversationMatch.uiBlock?.actions || [];
             return {
               success: true,
               data: {
+                text: cachedTextResponse,
                 component,
+                matchedComponents: component?.props?.config?.components || [],
+                actions: cachedActions,
                 reasoning: `Exact match from previous conversation (${(conversationMatch.similarity * 100).toFixed(2)}% similarity)`,
                 method: `${this.getProviderName()}-semantic-match-exact`,
                 semanticSimilarity: conversationMatch.similarity
@@ -5618,10 +6545,18 @@ ${errorMsg}
             logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
             logCollector?.info(`\u2713 UI block adapted successfully`);
             logCollector?.info(`Total time taken: ${elapsedTime2}ms (${(elapsedTime2 / 1e3).toFixed(2)}s)`);
+            if (streamCallback && cachedTextResponse) {
+              logger.info(`[${this.getProviderName()}] Streaming cached text response to frontend (adapted match)`);
+              streamCallback(cachedTextResponse);
+            }
+            const cachedActions = conversationMatch.uiBlock?.actions || [];
             return {
               success: true,
               data: {
+                text: cachedTextResponse,
                 component: adaptResult.adaptedComponent,
+                matchedComponents: adaptResult.adaptedComponent?.props?.config?.components || [],
+                actions: cachedActions,
                 reasoning: `Adapted from previous conversation: ${originalPrompt}`,
                 method: `${this.getProviderName()}-semantic-match`,
                 semanticSimilarity: conversationMatch.similarity,
@@ -5713,6 +6648,11 @@ ${errorMsg}
       logger.error(`[${this.getProviderName()}] Error in handleUserRequest: ${errorMsg}`);
       logger.debug(`[${this.getProviderName()}] Error details:`, error);
       logCollector?.error(`Error processing request: ${errorMsg}`);
+      userPromptErrorLogger.logError(
+        "handleUserRequest",
+        error instanceof Error ? error : new Error(errorMsg),
+        { userPrompt }
+      );
       const elapsedTime = Date.now() - startTime;
       logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime}ms (${(elapsedTime / 1e3).toFixed(2)}s)`);
       logCollector?.info(`Total time taken: ${elapsedTime}ms (${(elapsedTime / 1e3).toFixed(2)}s)`);
@@ -5729,15 +6669,26 @@ ${errorMsg}
   /**
    * Generate next questions that the user might ask based on the original prompt and generated component
    * This helps provide intelligent suggestions for follow-up queries
+   * For general/conversational questions without components, pass textResponse instead
    */
-  async generateNextQuestions(originalUserPrompt, component, componentData, apiKey, logCollector, conversationHistory) {
+  async generateNextQuestions(originalUserPrompt, component, componentData, apiKey, logCollector, conversationHistory, textResponse) {
     try {
-      const component_info = `
+      let component_info;
+      if (component) {
+        component_info = `
 				Component Name: ${component.name}
 				Component Type: ${component.type}
 				Component Description: ${component.description || "No description"}
 				Component Props: ${component.props ? JSON.stringify(component.props, null, 2) : "No props"}
 			`;
+      } else if (textResponse) {
+        component_info = `
+				Response Type: Text/Conversational Response
+				Response Content: ${textResponse.substring(0, 1e3)}${textResponse.length > 1e3 ? "..." : ""}
+			`;
+      } else {
+        component_info = "No component or response context available";
+      }
       const component_data = componentData ? `Component Data: ${JSON.stringify(componentData, null, 2)}` : "";
       const prompts = await promptLoader.loadPrompts("actions", {
         ORIGINAL_USER_PROMPT: originalUserPrompt,
@@ -5751,7 +6702,7 @@ ${errorMsg}
           user: prompts.user
         },
         {
-          model: this.model,
+          model: this.getModelForTask("simple"),
           maxTokens: 1200,
           temperature: 0.7,
           apiKey: this.getApiKey(apiKey)
@@ -5788,6 +6739,9 @@ var GroqLLM = class extends BaseLLM {
   getDefaultModel() {
     return "groq/openai/gpt-oss-120b";
   }
+  getDefaultFastModel() {
+    return "groq/llama-3.1-8b-instant";
+  }
   getDefaultApiKey() {
     return process.env.GROQ_API_KEY;
   }
@@ -5807,6 +6761,9 @@ var AnthropicLLM = class extends BaseLLM {
   getDefaultModel() {
     return "anthropic/claude-sonnet-4-5-20250929";
   }
+  getDefaultFastModel() {
+    return "anthropic/claude-haiku-4-5-20251001";
+  }
   getDefaultApiKey() {
     return process.env.ANTHROPIC_API_KEY;
   }
@@ -5826,6 +6783,9 @@ var GeminiLLM = class extends BaseLLM {
   getDefaultModel() {
     return "gemini/gemini-2.5-flash";
   }
+  getDefaultFastModel() {
+    return "gemini/gemini-2.0-flash-exp";
+  }
   getDefaultApiKey() {
     return process.env.GEMINI_API_KEY;
   }
@@ -5845,6 +6805,9 @@ var OpenAILLM = class extends BaseLLM {
   getDefaultModel() {
     return "openai/gpt-4.1";
   }
+  getDefaultFastModel() {
+    return "openai/gpt-4o-mini";
+  }
   getDefaultApiKey() {
     return process.env.OPENAI_API_KEY;
   }
@@ -6351,6 +7314,9 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
   const prompt = payload.prompt;
   const SA_RUNTIME = payload.SA_RUNTIME;
   const wsId = userPromptRequest.from.id || "unknown";
+  const promptContext = `User Prompt: ${prompt?.substring(0, 50)}${(prompt?.length || 0) > 50 ? "..." : ""}`;
+  llmUsageLogger.resetLogFile(promptContext);
+  userPromptErrorLogger.resetLogFile(promptContext);
   if (!SA_RUNTIME) {
     errors.push("SA_RUNTIME is required");
   }
@@ -6424,6 +7390,14 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
   const uiBlockId = existingUiBlockId;
   if (!userResponse.success) {
     logger.error(`User prompt request failed with errors: ${userResponse.errors.join(", ")}`);
+    userPromptErrorLogger.logError("User Response Failed", userResponse.errors.join("\n"), {
+      prompt,
+      uiBlockId,
+      threadId,
+      responseData: userResponse.data
+    });
+    userPromptErrorLogger.writeSummary();
+    llmUsageLogger.logSessionSummary(`FAILED: ${prompt?.substring(0, 30)}`);
     return {
       success: false,
       data: userResponse.data,
@@ -6499,6 +7473,7 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
       }
     }
   }
+  llmUsageLogger.logSessionSummary(prompt?.substring(0, 50));
   return {
     success: userResponse.success,
     data: userResponse.data,
@@ -9400,8 +10375,8 @@ function sendDashCompResponse(id, res, sendMessage, clientId) {
 }
 
 // src/auth/user-manager.ts
-var import_fs4 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
+var import_fs6 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
 var import_os = __toESM(require("os"));
 init_logger();
 var UserManager = class {
@@ -9415,7 +10390,7 @@ var UserManager = class {
     this.hasChanged = false;
     this.syncInterval = null;
     this.isInitialized = false;
-    this.filePath = import_path3.default.join(import_os.default.homedir(), ".superatom", "projects", projectId, "users.json");
+    this.filePath = import_path5.default.join(import_os.default.homedir(), ".superatom", "projects", projectId, "users.json");
     this.syncIntervalMs = syncIntervalMs;
   }
   /**
@@ -9440,20 +10415,20 @@ var UserManager = class {
    */
   async loadUsersFromFile() {
     try {
-      const dir = import_path3.default.dirname(this.filePath);
-      if (!import_fs4.default.existsSync(dir)) {
+      const dir = import_path5.default.dirname(this.filePath);
+      if (!import_fs6.default.existsSync(dir)) {
         logger.info(`Creating directory structure: ${dir}`);
-        import_fs4.default.mkdirSync(dir, { recursive: true });
+        import_fs6.default.mkdirSync(dir, { recursive: true });
       }
-      if (!import_fs4.default.existsSync(this.filePath)) {
+      if (!import_fs6.default.existsSync(this.filePath)) {
         logger.info(`Users file does not exist at ${this.filePath}, creating with empty users`);
         const initialData = { users: [] };
-        import_fs4.default.writeFileSync(this.filePath, JSON.stringify(initialData, null, 4));
+        import_fs6.default.writeFileSync(this.filePath, JSON.stringify(initialData, null, 4));
         this.users = [];
         this.hasChanged = false;
         return;
       }
-      const fileContent = import_fs4.default.readFileSync(this.filePath, "utf-8");
+      const fileContent = import_fs6.default.readFileSync(this.filePath, "utf-8");
       const rawData = JSON.parse(fileContent);
       const validatedData = UsersDataSchema.parse(rawData);
       this.users = validatedData.users;
@@ -9472,16 +10447,16 @@ var UserManager = class {
       return;
     }
     try {
-      const dir = import_path3.default.dirname(this.filePath);
-      if (!import_fs4.default.existsSync(dir)) {
-        import_fs4.default.mkdirSync(dir, { recursive: true });
+      const dir = import_path5.default.dirname(this.filePath);
+      if (!import_fs6.default.existsSync(dir)) {
+        import_fs6.default.mkdirSync(dir, { recursive: true });
       }
       const usersToSave = this.users.map((user) => {
         const { wsIds, ...userWithoutWsIds } = user;
         return userWithoutWsIds;
       });
       const data = { users: usersToSave };
-      import_fs4.default.writeFileSync(this.filePath, JSON.stringify(data, null, 4));
+      import_fs6.default.writeFileSync(this.filePath, JSON.stringify(data, null, 4));
       this.hasChanged = false;
       logger.debug(`Synced ${this.users.length} users to file (wsIds excluded)`);
     } catch (error) {
@@ -9699,8 +10674,8 @@ var UserManager = class {
 };
 
 // src/dashboards/dashboard-manager.ts
-var import_fs5 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
+var import_fs7 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
 var import_os2 = __toESM(require("os"));
 init_logger();
 var DashboardManager = class {
@@ -9710,7 +10685,7 @@ var DashboardManager = class {
    */
   constructor(projectId = "snowflake-dataset") {
     this.projectId = projectId;
-    this.dashboardsBasePath = import_path4.default.join(
+    this.dashboardsBasePath = import_path6.default.join(
       import_os2.default.homedir(),
       ".superatom",
       "projects",
@@ -9724,7 +10699,7 @@ var DashboardManager = class {
    * @returns Full path to dashboard data.json file
    */
   getDashboardPath(dashboardId) {
-    return import_path4.default.join(this.dashboardsBasePath, dashboardId, "data.json");
+    return import_path6.default.join(this.dashboardsBasePath, dashboardId, "data.json");
   }
   /**
    * Create a new dashboard
@@ -9734,13 +10709,13 @@ var DashboardManager = class {
    */
   createDashboard(dashboardId, dashboard) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    const dashboardDir = import_path4.default.dirname(dashboardPath);
-    if (import_fs5.default.existsSync(dashboardPath)) {
+    const dashboardDir = import_path6.default.dirname(dashboardPath);
+    if (import_fs7.default.existsSync(dashboardPath)) {
       throw new Error(`Dashboard '${dashboardId}' already exists`);
     }
     const validated = DSLRendererPropsSchema.parse(dashboard);
-    import_fs5.default.mkdirSync(dashboardDir, { recursive: true });
-    import_fs5.default.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
+    import_fs7.default.mkdirSync(dashboardDir, { recursive: true });
+    import_fs7.default.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
     logger.info(`Dashboard created: ${dashboardId}`);
     return validated;
   }
@@ -9751,12 +10726,12 @@ var DashboardManager = class {
    */
   getDashboard(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    if (!import_fs5.default.existsSync(dashboardPath)) {
+    if (!import_fs7.default.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found: ${dashboardId}`);
       return null;
     }
     try {
-      const fileContent = import_fs5.default.readFileSync(dashboardPath, "utf-8");
+      const fileContent = import_fs7.default.readFileSync(dashboardPath, "utf-8");
       const dashboard = JSON.parse(fileContent);
       const validated = DSLRendererPropsSchema.parse(dashboard);
       return validated;
@@ -9770,16 +10745,16 @@ var DashboardManager = class {
    * @returns Array of dashboard objects with their IDs
    */
   getAllDashboards() {
-    if (!import_fs5.default.existsSync(this.dashboardsBasePath)) {
-      import_fs5.default.mkdirSync(this.dashboardsBasePath, { recursive: true });
+    if (!import_fs7.default.existsSync(this.dashboardsBasePath)) {
+      import_fs7.default.mkdirSync(this.dashboardsBasePath, { recursive: true });
       return [];
     }
     const dashboards = [];
     try {
-      const dashboardDirs = import_fs5.default.readdirSync(this.dashboardsBasePath);
+      const dashboardDirs = import_fs7.default.readdirSync(this.dashboardsBasePath);
       for (const dashboardId of dashboardDirs) {
         const dashboardPath = this.getDashboardPath(dashboardId);
-        if (import_fs5.default.existsSync(dashboardPath)) {
+        if (import_fs7.default.existsSync(dashboardPath)) {
           const dashboard = this.getDashboard(dashboardId);
           if (dashboard) {
             dashboards.push({ dashboardId, dashboard });
@@ -9801,13 +10776,13 @@ var DashboardManager = class {
    */
   updateDashboard(dashboardId, dashboard) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    if (!import_fs5.default.existsSync(dashboardPath)) {
+    if (!import_fs7.default.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found for update: ${dashboardId}`);
       return null;
     }
     try {
       const validated = DSLRendererPropsSchema.parse(dashboard);
-      import_fs5.default.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
+      import_fs7.default.writeFileSync(dashboardPath, JSON.stringify(validated, null, 4));
       logger.info(`Dashboard updated: ${dashboardId}`);
       return validated;
     } catch (error) {
@@ -9822,13 +10797,13 @@ var DashboardManager = class {
    */
   deleteDashboard(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    const dashboardDir = import_path4.default.dirname(dashboardPath);
-    if (!import_fs5.default.existsSync(dashboardPath)) {
+    const dashboardDir = import_path6.default.dirname(dashboardPath);
+    if (!import_fs7.default.existsSync(dashboardPath)) {
       logger.warn(`Dashboard not found for deletion: ${dashboardId}`);
       return false;
     }
     try {
-      import_fs5.default.rmSync(dashboardDir, { recursive: true, force: true });
+      import_fs7.default.rmSync(dashboardDir, { recursive: true, force: true });
       logger.info(`Dashboard deleted: ${dashboardId}`);
       return true;
     } catch (error) {
@@ -9843,21 +10818,21 @@ var DashboardManager = class {
    */
   dashboardExists(dashboardId) {
     const dashboardPath = this.getDashboardPath(dashboardId);
-    return import_fs5.default.existsSync(dashboardPath);
+    return import_fs7.default.existsSync(dashboardPath);
   }
   /**
    * Get dashboard count
    * @returns Number of dashboards
    */
   getDashboardCount() {
-    if (!import_fs5.default.existsSync(this.dashboardsBasePath)) {
+    if (!import_fs7.default.existsSync(this.dashboardsBasePath)) {
       return 0;
     }
     try {
-      const dashboardDirs = import_fs5.default.readdirSync(this.dashboardsBasePath);
+      const dashboardDirs = import_fs7.default.readdirSync(this.dashboardsBasePath);
       return dashboardDirs.filter((dir) => {
         const dashboardPath = this.getDashboardPath(dir);
-        return import_fs5.default.existsSync(dashboardPath);
+        return import_fs7.default.existsSync(dashboardPath);
       }).length;
     } catch (error) {
       logger.error("Failed to get dashboard count:", error);
@@ -9867,8 +10842,8 @@ var DashboardManager = class {
 };
 
 // src/reports/report-manager.ts
-var import_fs6 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
+var import_fs8 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
 var import_os3 = __toESM(require("os"));
 init_logger();
 var ReportManager = class {
@@ -9878,7 +10853,7 @@ var ReportManager = class {
    */
   constructor(projectId = "snowflake-dataset") {
     this.projectId = projectId;
-    this.reportsBasePath = import_path5.default.join(
+    this.reportsBasePath = import_path7.default.join(
       import_os3.default.homedir(),
       ".superatom",
       "projects",
@@ -9892,7 +10867,7 @@ var ReportManager = class {
    * @returns Full path to report data.json file
    */
   getReportPath(reportId) {
-    return import_path5.default.join(this.reportsBasePath, reportId, "data.json");
+    return import_path7.default.join(this.reportsBasePath, reportId, "data.json");
   }
   /**
    * Create a new report
@@ -9902,13 +10877,13 @@ var ReportManager = class {
    */
   createReport(reportId, report) {
     const reportPath = this.getReportPath(reportId);
-    const reportDir = import_path5.default.dirname(reportPath);
-    if (import_fs6.default.existsSync(reportPath)) {
+    const reportDir = import_path7.default.dirname(reportPath);
+    if (import_fs8.default.existsSync(reportPath)) {
       throw new Error(`Report '${reportId}' already exists`);
     }
     const validated = DSLRendererPropsSchema2.parse(report);
-    import_fs6.default.mkdirSync(reportDir, { recursive: true });
-    import_fs6.default.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
+    import_fs8.default.mkdirSync(reportDir, { recursive: true });
+    import_fs8.default.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
     logger.info(`Report created: ${reportId}`);
     return validated;
   }
@@ -9919,12 +10894,12 @@ var ReportManager = class {
    */
   getReport(reportId) {
     const reportPath = this.getReportPath(reportId);
-    if (!import_fs6.default.existsSync(reportPath)) {
+    if (!import_fs8.default.existsSync(reportPath)) {
       logger.warn(`Report not found: ${reportId}`);
       return null;
     }
     try {
-      const fileContent = import_fs6.default.readFileSync(reportPath, "utf-8");
+      const fileContent = import_fs8.default.readFileSync(reportPath, "utf-8");
       const report = JSON.parse(fileContent);
       const validated = DSLRendererPropsSchema2.parse(report);
       return validated;
@@ -9938,16 +10913,16 @@ var ReportManager = class {
    * @returns Array of report objects with their IDs
    */
   getAllReports() {
-    if (!import_fs6.default.existsSync(this.reportsBasePath)) {
-      import_fs6.default.mkdirSync(this.reportsBasePath, { recursive: true });
+    if (!import_fs8.default.existsSync(this.reportsBasePath)) {
+      import_fs8.default.mkdirSync(this.reportsBasePath, { recursive: true });
       return [];
     }
     const reports = [];
     try {
-      const reportDirs = import_fs6.default.readdirSync(this.reportsBasePath);
+      const reportDirs = import_fs8.default.readdirSync(this.reportsBasePath);
       for (const reportId of reportDirs) {
         const reportPath = this.getReportPath(reportId);
-        if (import_fs6.default.existsSync(reportPath)) {
+        if (import_fs8.default.existsSync(reportPath)) {
           const report = this.getReport(reportId);
           if (report) {
             reports.push({ reportId, report });
@@ -9969,13 +10944,13 @@ var ReportManager = class {
    */
   updateReport(reportId, report) {
     const reportPath = this.getReportPath(reportId);
-    if (!import_fs6.default.existsSync(reportPath)) {
+    if (!import_fs8.default.existsSync(reportPath)) {
       logger.warn(`Report not found for update: ${reportId}`);
       return null;
     }
     try {
       const validated = DSLRendererPropsSchema2.parse(report);
-      import_fs6.default.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
+      import_fs8.default.writeFileSync(reportPath, JSON.stringify(validated, null, 4));
       logger.info(`Report updated: ${reportId}`);
       return validated;
     } catch (error) {
@@ -9990,13 +10965,13 @@ var ReportManager = class {
    */
   deleteReport(reportId) {
     const reportPath = this.getReportPath(reportId);
-    const reportDir = import_path5.default.dirname(reportPath);
-    if (!import_fs6.default.existsSync(reportPath)) {
+    const reportDir = import_path7.default.dirname(reportPath);
+    if (!import_fs8.default.existsSync(reportPath)) {
       logger.warn(`Report not found for deletion: ${reportId}`);
       return false;
     }
     try {
-      import_fs6.default.rmSync(reportDir, { recursive: true, force: true });
+      import_fs8.default.rmSync(reportDir, { recursive: true, force: true });
       logger.info(`Report deleted: ${reportId}`);
       return true;
     } catch (error) {
@@ -10011,21 +10986,21 @@ var ReportManager = class {
    */
   reportExists(reportId) {
     const reportPath = this.getReportPath(reportId);
-    return import_fs6.default.existsSync(reportPath);
+    return import_fs8.default.existsSync(reportPath);
   }
   /**
    * Get report count
    * @returns Number of reports
    */
   getReportCount() {
-    if (!import_fs6.default.existsSync(this.reportsBasePath)) {
+    if (!import_fs8.default.existsSync(this.reportsBasePath)) {
       return 0;
     }
     try {
-      const reportDirs = import_fs6.default.readdirSync(this.reportsBasePath);
+      const reportDirs = import_fs8.default.readdirSync(this.reportsBasePath);
       return reportDirs.filter((dir) => {
         const reportPath = this.getReportPath(dir);
-        return import_fs6.default.existsSync(reportPath);
+        return import_fs8.default.existsSync(reportPath);
       }).length;
     } catch (error) {
       logger.error("Failed to get report count:", error);
@@ -10254,7 +11229,9 @@ var SuperatomSDK = class {
     this.openaiApiKey = config.OPENAI_API_KEY || process.env.OPENAI_API_KEY || "";
     this.llmProviders = config.LLM_PROVIDERS || getLLMProviders();
     this.databaseType = config.databaseType || "postgresql";
-    logger.info(`Initializing Superatom SDK v${SDK_VERSION} for project ${this.projectId}, llm providers: ${this.llmProviders.join(", ")}, database type: ${this.databaseType}`);
+    this.modelStrategy = config.modelStrategy || "fast";
+    this.applyModelStrategy(this.modelStrategy);
+    logger.info(`Initializing Superatom SDK v${SDK_VERSION} for project ${this.projectId}, llm providers: ${this.llmProviders.join(", ")}, database type: ${this.databaseType}, model strategy: ${this.modelStrategy}`);
     this.userManager = new UserManager(this.projectId, 5e3);
     this.dashboardManager = new DashboardManager(this.projectId);
     this.reportManager = new ReportManager(this.projectId);
@@ -10633,6 +11610,31 @@ var SuperatomSDK = class {
   getTools() {
     return this.tools;
   }
+  /**
+   * Apply model strategy to all LLM provider singletons
+   * @param strategy - 'best', 'fast', or 'balanced'
+   */
+  applyModelStrategy(strategy) {
+    anthropicLLM.setModelStrategy(strategy);
+    groqLLM.setModelStrategy(strategy);
+    geminiLLM.setModelStrategy(strategy);
+    openaiLLM.setModelStrategy(strategy);
+    logger.info(`Model strategy '${strategy}' applied to all LLM providers`);
+  }
+  /**
+   * Set model strategy at runtime
+   * @param strategy - 'best', 'fast', or 'balanced'
+   */
+  setModelStrategy(strategy) {
+    this.modelStrategy = strategy;
+    this.applyModelStrategy(strategy);
+  }
+  /**
+   * Get current model strategy
+   */
+  getModelStrategy() {
+    return this.modelStrategy;
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -10648,9 +11650,15 @@ var SuperatomSDK = class {
   UIBlock,
   UILogCollector,
   UserManager,
+  anthropicLLM,
+  geminiLLM,
+  groqLLM,
   hybridRerank,
+  llmUsageLogger,
   logger,
+  openaiLLM,
   rerankChromaResults,
-  rerankConversationResults
+  rerankConversationResults,
+  userPromptErrorLogger
 });
 //# sourceMappingURL=index.js.map