@superatomai/sdk-node 0.0.1 → 0.0.3

package/dist/index.js

@@ -1883,53 +1883,126 @@ var import_fs2 = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
 var PromptLoader = class {
   constructor(config) {
+    this.promptCache = /* @__PURE__ */ new Map();
+    this.isInitialized = false;
+    logger.debug("Initializing PromptLoader...", process.cwd());
     this.promptsDir = config?.promptsDir || import_path2.default.join(process.cwd(), ".prompts");
+    this.defaultPromptsDir = import_path2.default.join(__dirname, "..", "..", ".prompts");
   }
   /**
-   * Load a single prompt file and replace variables using {{VARIABLE_NAME}} pattern
+   * Initialize and cache all prompts into memory
+   * This should be called once at SDK startup
+   */
+  async initialize() {
+    if (this.isInitialized) {
+      logger.debug("PromptLoader already initialized, skipping...");
+      return;
+    }
+    logger.info("Loading prompts into memory...");
+    const promptTypes = [
+      "classify",
+      "match-component",
+      "modify-props",
+      "single-component",
+      "mutli-component",
+      "actions",
+      "container-metadata"
+    ];
+    for (const promptType of promptTypes) {
+      try {
+        const template = await this.loadPromptTemplate(promptType);
+        this.promptCache.set(promptType, template);
+        logger.debug(`Cached prompt: ${promptType}`);
+      } catch (error) {
+        logger.error(`Failed to load prompt '${promptType}':`, error);
+        throw error;
+      }
+    }
+    this.isInitialized = true;
+    logger.info(`Successfully loaded ${this.promptCache.size} prompt templates into memory`);
+  }
+  /**
+   * Load a prompt template from file system (tries custom dir first, then defaults to SDK dir)
    * @param promptName - Name of the prompt folder
-   * @param promptType - Type of prompt ('system' or 'user')
-   * @param variables - Variables to replace in the template
-   * @returns Processed prompt string
+   * @returns Template with system and user prompts
    */
-  async loadPrompt(promptName, promptType, variables) {
-    try {
-      const promptPath = import_path2.default.join(
-        this.promptsDir,
-        promptName,
-        `${promptType}.md`
-      );
-      let content = import_fs2.default.readFileSync(promptPath, "utf-8");
-      for (const [key, value] of Object.entries(variables)) {
-        const pattern = new RegExp(`{{${key}}}`, "g");
-        const replacementValue = typeof value === "string" ? value : JSON.stringify(value);
-        content = content.replace(pattern, replacementValue);
+  async loadPromptTemplate(promptName) {
+    const tryLoadFromDir = (dir) => {
+      try {
+        const systemPath = import_path2.default.join(dir, promptName, "system.md");
+        const userPath = import_path2.default.join(dir, promptName, "user.md");
+        if (import_fs2.default.existsSync(systemPath) && import_fs2.default.existsSync(userPath)) {
+          const system = import_fs2.default.readFileSync(systemPath, "utf-8");
+          const user = import_fs2.default.readFileSync(userPath, "utf-8");
+          logger.debug(`Loaded prompt '${promptName}' from ${dir}`);
+          return { system, user };
+        }
+        return null;
+      } catch (error) {
+        return null;
       }
-      return content;
-    } catch (error) {
-      console.error(`Error loading prompt '${promptName}/${promptType}.md':`, error);
-      throw error;
+    };
+    let template = tryLoadFromDir(this.promptsDir);
+    if (!template) {
+      logger.warn(`Prompt '${promptName}' not found in ${this.promptsDir}, trying default location...`);
+      template = tryLoadFromDir(this.defaultPromptsDir);
+    }
+    if (!template) {
+      throw new Error(`Prompt template '${promptName}' not found in either ${this.promptsDir} or ${this.defaultPromptsDir}`);
     }
+    return template;
   }
   /**
-   * Load both system and user prompts and replace variables
+   * Replace variables in a template string using {{VARIABLE_NAME}} pattern
+   * @param template - Template string with placeholders
+   * @param variables - Variables to replace in the template
+   * @returns Processed string
+   */
+  replaceVariables(template, variables) {
+    let content = template;
+    for (const [key, value] of Object.entries(variables)) {
+      const pattern = new RegExp(`{{${key}}}`, "g");
+      const replacementValue = typeof value === "string" ? value : JSON.stringify(value);
+      content = content.replace(pattern, replacementValue);
+    }
+    return content;
+  }
+  /**
+   * Load both system and user prompts from cache and replace variables
    * @param promptName - Name of the prompt folder
    * @param variables - Variables to replace in the templates
    * @returns Object containing both system and user prompts
    */
   async loadPrompts(promptName, variables) {
-    const [system, user] = await Promise.all([
-      this.loadPrompt(promptName, "system", variables),
-      this.loadPrompt(promptName, "user", variables)
-    ]);
-    return { system, user };
+    if (!this.isInitialized) {
+      logger.warn("PromptLoader not initialized, loading prompts on-demand (not recommended)");
+      await this.initialize();
+    }
+    const template = this.promptCache.get(promptName);
+    if (!template) {
+      throw new Error(`Prompt template '${promptName}' not found in cache. Available prompts: ${Array.from(this.promptCache.keys()).join(", ")}`);
+    }
+    return {
+      system: this.replaceVariables(template.system, variables),
+      user: this.replaceVariables(template.user, variables)
+    };
   }
   /**
-   * Set custom prompts directory
+   * DEPRECATED: Use loadPrompts instead
+   * Load a single prompt file and replace variables using {{VARIABLE_NAME}} pattern
+   */
+  async loadPrompt(promptName, promptType, variables) {
+    const prompts = await this.loadPrompts(promptName, variables);
+    return promptType === "system" ? prompts.system : prompts.user;
+  }
+  /**
+   * Set custom prompts directory (requires re-initialization)
    * @param dir - Path to the prompts directory
    */
   setPromptsDir(dir) {
     this.promptsDir = dir;
+    this.isInitialized = false;
+    this.promptCache.clear();
   }
   /**
    * Get current prompts directory
@@ -1938,8 +2011,23 @@ var PromptLoader = class {
   getPromptsDir() {
     return this.promptsDir;
   }
+  /**
+   * Check if prompts are loaded in memory
+   */
+  isReady() {
+    return this.isInitialized;
+  }
+  /**
+   * Get the number of cached prompts
+   */
+  getCacheSize() {
+    return this.promptCache.size;
+  }
 };
-var promptLoader = new PromptLoader();
+var defaultPromptsPath = process.env.PROMPTS_DIR || import_path2.default.join(process.cwd(), ".prompts");
+var promptLoader = new PromptLoader({
+  promptsDir: defaultPromptsPath
+});
 
 // src/llm.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
@@ -1977,7 +2065,7 @@ var LLM = class {
    *
    * @example
    * "anthropic/claude-sonnet-4-5" → ["anthropic", "claude-sonnet-4-5"]
-   * "groq/gpt-oss-120b" → ["groq", "gpt-oss-120b"]
+   * "groq/openai/gpt-oss-120b" → ["groq", "openai/gpt-oss-120b"]
    * "claude-sonnet-4-5" → ["anthropic", "claude-sonnet-4-5"] (default)
    */
   static _parseModel(modelString) {
@@ -1985,8 +2073,10 @@ var LLM = class {
       return ["anthropic", "claude-sonnet-4-5"];
     }
     if (modelString.includes("/")) {
-      const [provider, model] = modelString.split("/");
-      return [provider.toLowerCase().trim(), model.trim()];
+      const firstSlashIndex = modelString.indexOf("/");
+      const provider = modelString.substring(0, firstSlashIndex).toLowerCase().trim();
+      const model = modelString.substring(firstSlashIndex + 1).trim();
+      return [provider, model];
     }
     return ["anthropic", modelString];
   }
@@ -1994,8 +2084,9 @@ var LLM = class {
   // ANTHROPIC IMPLEMENTATION
   // ============================================================
   static async _anthropicText(messages, modelName, options) {
+    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY || "";
     const client = new import_sdk.default({
-      apiKey: options.apiKey || process.env.ANTHROPIC_API_KEY || ""
+      apiKey
     });
     const response = await client.messages.create({
       model: modelName,
@@ -2011,8 +2102,9 @@ var LLM = class {
     return textBlock?.type === "text" ? textBlock.text : "";
   }
   static async _anthropicStream(messages, modelName, options, json) {
+    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY || "";
     const client = new import_sdk.default({
-      apiKey: options.apiKey || process.env.ANTHROPIC_API_KEY || ""
+      apiKey
     });
     const stream = await client.messages.create({
       model: modelName,
@@ -2059,8 +2151,9 @@ var LLM = class {
     return response.choices[0]?.message?.content || "";
   }
   static async _groqStream(messages, modelName, options, json) {
+    const apiKey = options.apiKey || process.env.GROQ_API_KEY || "";
     const client = new import_groq_sdk.default({
-      apiKey: options.apiKey || process.env.GROQ_API_KEY || ""
+      apiKey
     });
     const stream = await client.chat.completions.create({
       model: modelName,
@@ -2130,10 +2223,8 @@ var BaseLLM = class {
    * Classify user question to determine the type and required visualizations
    */
   async classifyUserQuestion(userPrompt, apiKey, logCollector, conversationHistory) {
-    const schemaDoc = schema.generateSchemaDocumentation();
     try {
       const prompts = await promptLoader.loadPrompts("classify", {
-        SCHEMA_DOC: schemaDoc || "No schema available",
         USER_PROMPT: userPrompt,
         CONVERSATION_HISTORY: conversationHistory || "No previous conversation"
       });
@@ -2188,6 +2279,7 @@ var BaseLLM = class {
         CURRENT_PROPS: JSON.stringify(originalProps, null, 2),
         CONVERSATION_HISTORY: conversationHistory || "No previous conversation"
       });
+      logger.debug("props-modification: System prompt\n", prompts.system.substring(0, 100), "\n\n\n", "User prompt:", prompts.user.substring(0, 50));
       const result = await LLM.stream(
         {
           sys: prompts.system,
@@ -2235,21 +2327,47 @@ var BaseLLM = class {
     }
   }
   /**
-   * Generate a dynamic component for analytical questions when no matching component exists
-   * This creates a custom component with appropriate visualization and query
+   * Match and select a component from available components filtered by type
+   * This picks the best matching component based on user prompt and modifies its props
    */
-  async generateAnalyticalComponent(userPrompt, preferredVisualizationType, apiKey, logCollector, conversationHistory) {
-    const schemaDoc = schema.generateSchemaDocumentation();
+  async generateAnalyticalComponent(userPrompt, components, preferredVisualizationType, apiKey, logCollector, conversationHistory) {
     try {
+      const filteredComponents = preferredVisualizationType ? components.filter((c) => c.type === preferredVisualizationType) : components;
+      if (filteredComponents.length === 0) {
+        logCollector?.warn(
+          `No components found of type ${preferredVisualizationType}`,
+          "explanation",
+          { reason: "No matching components available for this visualization type" }
+        );
+        return {
+          component: null,
+          reasoning: `No components available of type ${preferredVisualizationType}`,
+          isGenerated: false
+        };
+      }
+      const componentsText = filteredComponents.map((comp, idx) => {
+        const keywords = comp.keywords ? comp.keywords.join(", ") : "";
+        const category = comp.category || "general";
+        const propsPreview = comp.props ? JSON.stringify(comp.props, null, 2) : "No props";
+        return `${idx + 1}. ID: ${comp.id}
+   Name: ${comp.name}
+   Type: ${comp.type}
+   Category: ${category}
+   Description: ${comp.description || "No description"}
+   Keywords: ${keywords}
+   Props Preview: ${propsPreview}`;
+      }).join("\n\n");
       const visualizationConstraint = preferredVisualizationType ? `
-**IMPORTANT: The user has specifically requested a ${preferredVisualizationType} visualization. You MUST use this type.**
+**IMPORTANT: Components are filtered to type ${preferredVisualizationType}. Select the best match.**
 ` : "";
       const prompts = await promptLoader.loadPrompts("single-component", {
-        SCHEMA_DOC: schemaDoc || "No schema available",
+        COMPONENT_TYPE: preferredVisualizationType || "any",
+        COMPONENTS_LIST: componentsText,
         VISUALIZATION_CONSTRAINT: visualizationConstraint,
         USER_PROMPT: userPrompt,
         CONVERSATION_HISTORY: conversationHistory || "No previous conversation"
       });
+      logger.debug("single-component: System prompt\n", prompts.system.substring(0, 100), "\n\n\n", "User prompt:", prompts.user.substring(0, 50));
       const result = await LLM.stream(
         {
           sys: prompts.system,
@@ -2264,53 +2382,63 @@ var BaseLLM = class {
         true
         // Parse as JSON
       );
-      if (!result.canGenerate) {
+      if (!result.canGenerate || result.confidence < 50) {
         logCollector?.warn(
-          "Cannot generate component",
+          "Cannot match component",
           "explanation",
-          { reason: result.reasoning || "Unable to generate component for this question" }
+          { reason: result.reasoning || "Unable to find matching component for this question" }
         );
         return {
           component: null,
-          reasoning: result.reasoning || "Unable to generate component for this question",
+          reasoning: result.reasoning || "Unable to find matching component for this question",
           isGenerated: false
         };
       }
-      const query = ensureQueryLimit(result.query, this.defaultLimit);
-      logCollector?.logQuery(
-        "Analytical component query generated",
-        query,
-        {
-          componentType: result.componentType,
-          visualization: preferredVisualizationType || result.componentType,
-          title: result.title
-        }
+      const componentIndex = result.componentIndex;
+      const componentId = result.componentId;
+      let matchedComponent = null;
+      if (componentId) {
+        matchedComponent = filteredComponents.find((c) => c.id === componentId);
+      }
+      if (!matchedComponent && componentIndex) {
+        matchedComponent = filteredComponents[componentIndex - 1];
+      }
+      if (!matchedComponent) {
+        logCollector?.warn("Component not found in filtered list");
+        return {
+          component: null,
+          reasoning: "Component not found in filtered list",
+          isGenerated: false
+        };
+      }
+      logCollector?.info(`Matched component: ${matchedComponent.name} (confidence: ${result.confidence}%)`);
+      const propsValidation = await this.validateAndModifyProps(
+        userPrompt,
+        matchedComponent.props,
+        matchedComponent.name,
+        matchedComponent.type,
+        matchedComponent.description,
+        apiKey,
+        logCollector,
+        conversationHistory
       );
+      const modifiedComponent = {
+        ...matchedComponent,
+        props: propsValidation.props
+      };
       logCollector?.logExplanation(
-        "Analytical component generated",
-        result.reasoning || "Generated dynamic component based on analytical question",
+        "Analytical component selected and modified",
+        result.reasoning || "Selected component based on analytical question",
         {
-          componentType: result.componentType,
-          description: result.description
+          componentName: matchedComponent.name,
+          componentType: matchedComponent.type,
+          confidence: result.confidence,
+          propsModified: propsValidation.isModified
         }
       );
-      const dynamicComponent = {
-        id: `dynamic_${Date.now()}`,
-        name: `Dynamic${result.componentType}`,
-        type: result.componentType,
-        description: result.description,
-        category: "dynamic",
-        keywords: [],
-        props: {
-          query,
-          title: result.title,
-          description: result.description,
-          config: result.config || {}
-        }
-      };
       return {
-        component: dynamicComponent,
-        reasoning: result.reasoning || "Generated dynamic component based on analytical question",
+        component: modifiedComponent,
+        reasoning: result.reasoning || "Selected and modified component based on analytical question",
         isGenerated: true
       };
     } catch (error) {
@@ -2318,6 +2446,51 @@ var BaseLLM = class {
       throw error;
     }
   }
+  /**
+   * Generate container metadata (title and description) for multi-component dashboard
+   */
+  async generateContainerMetadata(userPrompt, visualizationTypes, apiKey, logCollector, conversationHistory) {
+    try {
+      const prompts = await promptLoader.loadPrompts("container-metadata", {
+        USER_PROMPT: userPrompt,
+        VISUALIZATION_TYPES: visualizationTypes.join(", "),
+        CONVERSATION_HISTORY: conversationHistory || "No previous conversation"
+      });
+      const result = await LLM.stream(
+        {
+          sys: prompts.system,
+          user: prompts.user
+        },
+        {
+          model: this.model,
+          maxTokens: 500,
+          temperature: 0.3,
+          apiKey: this.getApiKey(apiKey)
+        },
+        true
+        // Parse as JSON
+      );
+      logCollector?.logExplanation(
+        "Container metadata generated",
+        `Generated title and description for multi-component dashboard`,
+        {
+          title: result.title,
+          description: result.description,
+          visualizationTypes
+        }
+      );
+      return {
+        title: result.title || `${userPrompt} - Dashboard`,
+        description: result.description || `Multi-component dashboard showing ${visualizationTypes.join(", ")}`
+      };
+    } catch (error) {
+      console.error("Error generating container metadata:", error);
+      return {
+        title: `${userPrompt} - Dashboard`,
+        description: `Multi-component dashboard showing ${visualizationTypes.join(", ")}`
+      };
+    }
+  }
   /**
    * Match component from a list with enhanced props modification
    */
@@ -2379,12 +2552,12 @@ var BaseLLM = class {
         const noMatchMsg = `No matching component found (confidence: ${confidence}%)`;
         console.log("\u2717", noMatchMsg);
         logCollector?.warn(noMatchMsg);
-        const genMsg = "Attempting to generate dynamic component from analytical question...";
+        const genMsg = "Attempting to match component from analytical question...";
         console.log("\u2713", genMsg);
         logCollector?.info(genMsg);
-        const generatedResult = await this.generateAnalyticalComponent(userPrompt, void 0, apiKey, logCollector, conversationHistory);
+        const generatedResult = await this.generateAnalyticalComponent(userPrompt, components, void 0, apiKey, logCollector, conversationHistory);
         if (generatedResult.component) {
-          const genSuccessMsg = `Successfully generated component: ${generatedResult.component.name}`;
+          const genSuccessMsg = `Successfully matched component: ${generatedResult.component.name}`;
           logCollector?.info(genSuccessMsg);
           return {
             component: generatedResult.component,
@@ -2396,10 +2569,10 @@ var BaseLLM = class {
             queryModified: false
           };
         }
-        logCollector?.error("Failed to generate dynamic component");
+        logCollector?.error("Failed to match component");
         return {
           component: null,
-          reasoning: result.reasoning || "No matching component found and unable to generate dynamic component",
+          reasoning: result.reasoning || "No matching component found and unable to match component",
           method: `${this.getProviderName()}-llm`,
           confidence
         };
@@ -2447,15 +2620,15 @@ var BaseLLM = class {
     }
   }
   /**
-   * Generate multiple dynamic components for analytical questions
+   * Match multiple components for analytical questions by visualization types
    * This is used when the user needs multiple visualizations
    */
-  async generateMultipleAnalyticalComponents(userPrompt, visualizationTypes, apiKey, logCollector, conversationHistory) {
+  async generateMultipleAnalyticalComponents(userPrompt, availableComponents, visualizationTypes, apiKey, logCollector, conversationHistory) {
     try {
-      console.log("\u2713 Generating multiple components:", visualizationTypes);
+      console.log("\u2713 Matching multiple components:", visualizationTypes);
       const components = [];
       for (const vizType of visualizationTypes) {
-        const result = await this.generateAnalyticalComponent(userPrompt, vizType, apiKey, logCollector, conversationHistory);
+        const result = await this.generateAnalyticalComponent(userPrompt, availableComponents, vizType, apiKey, logCollector, conversationHistory);
         if (result.component) {
           components.push(result.component);
         }
@@ -2463,75 +2636,45 @@ var BaseLLM = class {
       if (components.length === 0) {
         return {
           components: [],
-          reasoning: "Failed to generate any components",
+          reasoning: "Failed to match any components",
           isGenerated: false
         };
       }
       return {
         components,
-        reasoning: `Generated ${components.length} components: ${visualizationTypes.join(", ")}`,
+        reasoning: `Matched ${components.length} components: ${visualizationTypes.join(", ")}`,
         isGenerated: true
       };
     } catch (error) {
-      console.error("Error generating multiple analytical components:", error);
+      console.error("Error matching multiple analytical components:", error);
       return {
         components: [],
-        reasoning: "Error occurred while generating components",
+        reasoning: "Error occurred while matching components",
         isGenerated: false
       };
     }
   }
   /**
-   * Generate a complete multi-component response with intelligent container and component props
+   * Match multiple components and wrap them in a container
    */
-  async generateMultiComponentResponse(userPrompt, visualizationTypes, apiKey, logCollector, conversationHistory) {
-    const schemaDoc = schema.generateSchemaDocumentation();
+  async generateMultiComponentResponse(userPrompt, availableComponents, visualizationTypes, apiKey, logCollector, conversationHistory) {
     try {
-      const prompts = await promptLoader.loadPrompts("mutli-component", {
-        SCHEMA_DOC: schemaDoc || "No schema available",
-        DEFAULT_LIMIT: this.defaultLimit,
-        USER_PROMPT: userPrompt,
-        VISUALIZATION_TYPES: visualizationTypes.join(", "),
-        CONVERSATION_HISTORY: conversationHistory || "No previous conversation"
-      });
-      const result = await LLM.stream(
-        {
-          sys: prompts.system,
-          user: prompts.user
-        },
-        {
-          model: this.model,
-          maxTokens: 3e3,
-          temperature: 0.2,
-          apiKey: this.getApiKey(apiKey)
-        },
-        true
-        // Parse as JSON
+      const matchResult = await this.generateMultipleAnalyticalComponents(
+        userPrompt,
+        availableComponents,
+        visualizationTypes,
+        apiKey,
+        logCollector,
+        conversationHistory
       );
-      if (!result.canGenerate || !result.components || result.components.length === 0) {
+      if (!matchResult.isGenerated || matchResult.components.length === 0) {
         return {
           containerComponent: null,
-          reasoning: result.reasoning || "Unable to generate multi-component dashboard",
+          reasoning: matchResult.reasoning || "Unable to match multi-component dashboard",
           isGenerated: false
         };
       }
-      const generatedComponents = result.components.map((compData, index) => {
-        const query = ensureQueryLimit(compData.query, this.defaultLimit);
-        return {
-          id: `dynamic_${compData.componentType.toLowerCase()}_${Date.now()}_${index}`,
-          name: `Dynamic${compData.componentType}`,
-          type: compData.componentType,
-          description: compData.description,
-          category: "dynamic",
-          keywords: [],
-          props: {
-            query,
-            title: compData.title,
-            description: compData.description,
-            config: compData.config || {}
-          }
-        };
-      });
+      const generatedComponents = matchResult.components;
       generatedComponents.forEach((component, index) => {
         if (component.props.query) {
           logCollector?.logQuery(
@@ -2546,21 +2689,24 @@ var BaseLLM = class {
           );
         }
       });
+      const containerTitle = `${userPrompt} - Dashboard`;
+      const containerDescription = `Multi-component dashboard showing ${visualizationTypes.join(", ")}`;
       logCollector?.logExplanation(
-        "Multi-component dashboard generated",
-        result.reasoning || `Generated ${generatedComponents.length} components for comprehensive analysis`,
+        "Multi-component dashboard matched",
+        matchResult.reasoning || `Matched ${generatedComponents.length} components for comprehensive analysis`,
         {
           totalComponents: generatedComponents.length,
           componentTypes: generatedComponents.map((c) => c.type),
-          containerTitle: result.containerTitle,
-          containerDescription: result.containerDescription
+          componentNames: generatedComponents.map((c) => c.name),
+          containerTitle,
+          containerDescription
         }
       );
       const containerComponent = {
         id: `multi_container_${Date.now()}`,
         name: "MultiComponentContainer",
         type: "Container",
-        description: result.containerDescription,
+        description: containerDescription,
         category: "dynamic",
         keywords: ["multi", "container", "dashboard"],
         props: {
@@ -2568,14 +2714,14 @@ var BaseLLM = class {
             components: generatedComponents,
             layout: "grid",
             spacing: 24,
-            title: result.containerTitle,
-            description: result.containerDescription
+            title: containerTitle,
+            description: containerDescription
           }
         }
       };
       return {
         containerComponent,
-        reasoning: result.reasoning || `Generated multi-component dashboard with ${generatedComponents.length} components`,
+        reasoning: matchResult.reasoning || `Matched multi-component dashboard with ${generatedComponents.length} components`,
         isGenerated: true
       };
     } catch (error) {
@@ -2596,41 +2742,89 @@ var BaseLLM = class {
       const classInfo = `Question type: ${classification.questionType}, Visualizations: ${classification.visualizations.join(", ") || "None"}, Multiple components: ${classification.needsMultipleComponents}`;
       logCollector?.info(classInfo);
       if (classification.questionType === "analytical") {
-        if (classification.visualizations.length > 0) {
-          if (classification.needsMultipleComponents && classification.visualizations.length > 1) {
-            const multiMsg = "Generating multi-component dashboard...";
-            logCollector?.info(multiMsg);
-            const result = await this.generateMultiComponentResponse(
+        if (classification.visualizations.length > 1) {
+          const multiMsg = `Matching ${classification.visualizations.length} components for types: ${classification.visualizations.join(", ")}`;
+          logCollector?.info(multiMsg);
+          const matchedComponents = [];
+          for (const vizType of classification.visualizations) {
+            logCollector?.info(`Matching component for type: ${vizType}`);
+            const result = await this.generateAnalyticalComponent(
               userPrompt,
-              classification.visualizations,
+              components,
+              vizType,
               apiKey,
               logCollector,
               conversationHistory
             );
+            if (result.component) {
+              matchedComponents.push(result.component);
+              logCollector?.info(`Matched: ${result.component.name}`);
+            } else {
+              logCollector?.warn(`Failed to match component for type: ${vizType}`);
+            }
+          }
+          if (matchedComponents.length === 0) {
             return {
-              component: result.containerComponent,
-              reasoning: result.reasoning,
-              method: "classification-multi-generated",
+              component: null,
+              reasoning: "Failed to match any components for the requested visualization types",
+              method: "classification-multi-failed",
               questionType: classification.questionType,
               needsMultipleComponents: true,
               propsModified: false,
               queryModified: false
             };
-          } else {
-            const vizType = classification.visualizations[0];
-            const result = await this.generateAnalyticalComponent(userPrompt, vizType, apiKey, logCollector, conversationHistory);
-            return {
-              component: result.component,
-              reasoning: result.reasoning,
-              method: "classification-generated",
-              questionType: classification.questionType,
-              needsMultipleComponents: false,
-              propsModified: false,
-              queryModified: false
-            };
           }
+          logCollector?.info("Generating container metadata...");
+          const containerMetadata = await this.generateContainerMetadata(
+            userPrompt,
+            classification.visualizations,
+            apiKey,
+            logCollector,
+            conversationHistory
+          );
+          const containerComponent = {
+            id: `multi_container_${Date.now()}`,
+            name: "MultiComponentContainer",
+            type: "Container",
+            description: containerMetadata.description,
+            category: "dynamic",
+            keywords: ["multi", "container", "dashboard"],
+            props: {
+              config: {
+                components: matchedComponents,
+                layout: "grid",
+                spacing: 24,
+                title: containerMetadata.title,
+                description: containerMetadata.description
+              }
+            }
+          };
+          logCollector?.info(`Created multi-component container with ${matchedComponents.length} components: "${containerMetadata.title}"`);
+          return {
+            component: containerComponent,
+            reasoning: `Matched ${matchedComponents.length} components for visualization types: ${classification.visualizations.join(", ")}`,
+            method: "classification-multi-generated",
+            questionType: classification.questionType,
+            needsMultipleComponents: true,
+            propsModified: false,
+            queryModified: false
+          };
+        } else if (classification.visualizations.length === 1) {
+          const vizType = classification.visualizations[0];
+          logCollector?.info(`Matching single component for type: ${vizType}`);
+          const result = await this.generateAnalyticalComponent(userPrompt, components, vizType, apiKey, logCollector, conversationHistory);
+          return {
+            component: result.component,
+            reasoning: result.reasoning,
+            method: "classification-generated",
+            questionType: classification.questionType,
+            needsMultipleComponents: false,
+            propsModified: false,
+            queryModified: false
+          };
         } else {
-          const result = await this.generateAnalyticalComponent(userPrompt, void 0, apiKey, logCollector, conversationHistory);
+          logCollector?.info("No specific visualization type - matching from all components");
+          const result = await this.generateAnalyticalComponent(userPrompt, components, void 0, apiKey, logCollector, conversationHistory);
           return {
             component: result.component,
             reasoning: result.reasoning,
@@ -2641,7 +2835,7 @@ var BaseLLM = class {
             queryModified: false
           };
         }
-      } else if (classification.questionType === "data_modification") {
+      } else if (classification.questionType === "data_modification" || classification.questionType === "general") {
         const matchMsg = "Using component matching for data modification...";
         logCollector?.info(matchMsg);
         const matchResult = await this.matchComponent(userPrompt, components, apiKey, logCollector, conversationHistory);
@@ -2787,8 +2981,14 @@ var useAnthropicMethod = async (prompt, components, apiKey, logCollector, conver
     logCollector?.error(emptyMsg);
     return { success: false, reason: emptyMsg };
   }
-  const matchResult = await anthropicLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory);
-  return { success: true, data: matchResult };
+  try {
+    const matchResult = await anthropicLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory);
+    return { success: true, data: matchResult };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logCollector?.error(`Anthropic method failed: ${errorMsg}`);
+    throw error;
+  }
 };
 var useGroqMethod = async (prompt, components, apiKey, logCollector, conversationHistory) => {
   const msg = "Using Groq LLM matching method...";
@@ -2799,8 +2999,14 @@ var useGroqMethod = async (prompt, components, apiKey, logCollector, conversatio
     logCollector?.error(emptyMsg);
     return { success: false, reason: emptyMsg };
   }
-  const matchResult = await groqLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory);
-  return { success: true, data: matchResult };
+  try {
+    const matchResult = await groqLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory);
+    return { success: true, data: matchResult };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logCollector?.error(`Groq method failed: ${errorMsg}`);
+    throw error;
+  }
 };
 var getUserResponseFromCache = async (prompt) => {
   return false;
@@ -3021,6 +3227,7 @@ var CONTEXT_CONFIG = {
 };
 
 // src/handlers/user-prompt-request.ts
+var processedMessageIds = /* @__PURE__ */ new Set();
 async function handleUserPromptRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders) {
   try {
     const userPromptRequest = UserPromptRequestMessageSchema.parse(data);
@@ -3028,6 +3235,18 @@ async function handleUserPromptRequest(data, components, sendMessage, anthropicA
     const prompt = payload.prompt;
     const SA_RUNTIME = payload.SA_RUNTIME;
     const wsId = userPromptRequest.from.id || "unknown";
+    logger.info(`[REQUEST ${id}] Processing user prompt: "${prompt.substring(0, 50)}..."`);
+    if (processedMessageIds.has(id)) {
+      logger.warn(`[REQUEST ${id}] Duplicate request detected - ignoring`);
+      return;
+    }
+    processedMessageIds.add(id);
+    if (processedMessageIds.size > 100) {
+      const firstId = processedMessageIds.values().next().value;
+      if (firstId) {
+        processedMessageIds.delete(firstId);
+      }
+    }
     if (!SA_RUNTIME) {
       sendDataResponse4(id, {
         success: false,
@@ -3067,7 +3286,6 @@ async function handleUserPromptRequest(data, components, sendMessage, anthropicA
       return;
     }
     logCollector.info(`Starting user prompt request with ${components.length} components`);
-    logger.info(`components length: ${components.length}`);
     const threadManager = ThreadManager.getInstance();
     let thread = threadManager.getThread(threadId);
     if (!thread) {
@@ -4227,6 +4445,9 @@ var UserManager = class {
     if (!user) {
       return false;
     }
+    if (!user.wsIds || !Array.isArray(user.wsIds)) {
+      user.wsIds = [];
+    }
     if (!user.wsIds.includes(wsId)) {
       user.wsIds.push(wsId);
       this.hasChanged = true;
@@ -4245,6 +4466,9 @@ var UserManager = class {
     if (!user) {
       return false;
     }
+    if (!user.wsIds || !Array.isArray(user.wsIds)) {
+      return false;
+    }
     const initialLength = user.wsIds.length;
     user.wsIds = user.wsIds.filter((id) => id !== wsId);
     if (user.wsIds.length < initialLength) {
@@ -4810,6 +5034,9 @@ var SuperatomSDK = class {
     this.userManager = new UserManager(this.projectId, 5e3);
     this.dashboardManager = new DashboardManager(this.projectId);
     this.reportManager = new ReportManager(this.projectId);
+    this.initializePromptLoader(config.promptsDir).catch((error) => {
+      logger.error("Failed to initialize PromptLoader:", error);
+    });
     this.initializeUserManager().catch((error) => {
       logger.error("Failed to initialize UserManager:", error);
     });
@@ -4819,6 +5046,21 @@ var SuperatomSDK = class {
       logger.error("Failed to connect to Superatom:", error);
     });
   }
+  /**
+   * Initialize PromptLoader and load prompts into memory
+   */
+  async initializePromptLoader(promptsDir) {
+    try {
+      if (promptsDir) {
+        promptLoader.setPromptsDir(promptsDir);
+      }
+      await promptLoader.initialize();
+      logger.info(`PromptLoader initialized with ${promptLoader.getCacheSize()} prompts from ${promptLoader.getPromptsDir()}`);
+    } catch (error) {
+      logger.error("Failed to initialize PromptLoader:", error);
+      throw error;
+    }
+  }
   /**
    * Initialize UserManager for the project
    */