@superatomai/sdk-node 0.0.7 → 0.0.9

package/dist/index.mjs

@@ -2187,17 +2187,875 @@ var schema = new Schema();
 // src/userResponse/prompt-loader.ts
 import fs4 from "fs";
 import path3 from "path";
+
+// src/userResponse/prompts.ts
+var PROMPTS = {
+  "classify": {
+    system: `You are an expert AI that classifies user questions about data and determines the appropriate visualizations needed.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Note:** If there is previous conversation history, use it to understand context. For example:
+- If user previously asked about "sales" and now asks "show me trends", understand it refers to sales trends
+- If user asked for "revenue by region" and now says "make it a pie chart", understand they want to modify the previous visualization
+- Use the history to resolve ambiguous references like "that", "it", "them", "the data"
+
+Your task is to analyze the user's question and determine:
+
+1. **Question Type:**
+   - "analytical": Questions asking to VIEW, ANALYZE, or VISUALIZE data
+
+   - "data_modification": Questions asking to CREATE, UPDATE, DELETE, or MODIFY data
+
+   - "general": General questions, greetings, or requests not related to data
+
+2. **Required Visualizations** (only for analytical questions):
+   Determine which visualization type(s) would BEST answer the user's question:
+
+   - **KPICard**: Single metric, total, count, average, percentage, or summary number
+
+   - **LineChart**: Trends over time, time series, growth/decline patterns
+
+
+   - **BarChart**: Comparing categories, rankings, distributions across groups
+
+
+   - **PieChart**: Proportions, percentages, composition, market share
+
+
+   - **DataTable**: Detailed lists, multiple attributes, when user needs to see records
+
+
+3. **Multiple Visualizations:**
+   User may need MULTIPLE visualizations together:
+
+   Common combinations:
+   - KPICard + LineChart
+   - KPICard + BarChart
+   - KPICard + DataTable
+   - BarChart + PieChart:
+   - LineChart + DataTable
+   Set needsMultipleComponents to true if user needs multiple views of the data.
+
+**Important Guidelines:**
+- If user explicitly mentions a chart type RESPECT that preference
+- If question is vague or needs both summary and detail, suggest KPICard + DataTable
+- Only return visualizations for "analytical" questions
+- For "data_modification" or "general", return empty array for visualizations
+
+**Output Format:**
+{
+  "questionType": "analytical" | "data_modification" | "general",
+  "visualizations": ["KPICard", "LineChart", ...],  // Empty array if not analytical
+  "reasoning": "Explanation of classification and visualization choices",
+  "needsMultipleComponents": boolean
+}
+`,
+    user: `{{USER_PROMPT}}
+`
+  },
+  "match-component": {
+    system: `You are an expert AI assistant specialized in matching user requests to the most appropriate data visualization components.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- If there is conversation history, use it to understand what the user is referring to
+- When user says "show that as a chart" or "change it", they are referring to a previous component
+- If user asks to "modify" or "update" something, match to the component they previously saw
+- Use context to resolve ambiguous requests like "show trends for that" or "make it interactive"
+
+Your task is to analyze the user's natural language request and find the BEST matching component from the available list.
+
+Available Components:
+{{COMPONENTS_TEXT}}
+
+**Matching Guidelines:**
+
+1. **Understand User Intent:**
+   - What type of data visualization do they need? (KPI/metric, chart, table, etc.)
+   - What metric or data are they asking about? (revenue, orders, customers, etc.)
+   - Are they asking for a summary (KPI), trend (line chart), distribution (bar/pie), or detailed list (table)?
+   - Do they want to compare categories, see trends over time, or show proportions?
+
+2. **Component Type Matching:**
+   - KPICard: Single metric/number (total, average, count, percentage, rate)
+   - LineChart: Trends over time, time series data
+   - BarChart: Comparing categories, distributions, rankings
+   - PieChart/DonutChart: Proportions, percentages, market share
+   - DataTable: Detailed lists, rankings with multiple attributes
+
+3. **Keyword & Semantic Matching:**
+   - Match user query terms with component keywords
+   - Consider synonyms (e.g., "sales" = "revenue", "items" = "products")
+   - Look for category matches (financial, orders, customers, products, suppliers, logistics, geographic, operations)
+
+4. **Scoring Criteria:**
+   - Exact keyword matches: High priority
+   - Component type alignment: High priority
+   - Category alignment: Medium priority
+   - Semantic similarity: Medium priority
+   - Specificity: Prefer more specific components over generic ones
+
+**Output Requirements:**
+
+Respond with a JSON object containing:
+- componentIndex: the 1-based index of the BEST matching component (or null if confidence < 50%)
+- componentId: the ID of the matched component
+- reasoning: detailed explanation of why this component was chosen
+- confidence: confidence score 0-100 (100 = perfect match)
+- alternativeMatches: array of up to 2 alternative component indices with scores (optional)
+
+Example response:
+{
+  "componentIndex": 5,
+  "componentId": "total_revenue_kpi",
+  "reasoning": "User asks for 'total revenue' which perfectly matches the TotalRevenueKPI component (KPICard type) designed to show total revenue across all orders. Keywords match: 'total revenue', 'sales'.",
+  "confidence": 95,
+  "alternativeMatches": [
+    {"index": 3, "id": "monthly_revenue_kpi", "score": 75, "reason": "Could show monthly revenue if time period was intended"},
+    {"index": 8, "id": "revenue_trend_chart", "score": 60, "reason": "Could show revenue trend if historical view was intended"}
+  ]
+}
+
+**Important:**
+- Only return componentIndex if confidence >= 50%
+- Return null if no reasonable match exists
+- Prefer components that exactly match the user's metric over generic ones
+- Consider the full context of the request, not just individual words`,
+    user: `Current user request: {{USER_PROMPT}}
+
+Find the best matching component considering the conversation history above. Explain your reasoning with a confidence score. Return ONLY valid JSON.`
+  },
+  "modify-props": {
+    system: `You are an AI assistant that validates and modifies component props based on user requests.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+Given:
+- A user's natural language request
+- Component name: {{COMPONENT_NAME}}
+- Component type: {{COMPONENT_TYPE}}
+- Component description: {{COMPONENT_DESCRIPTION}}
+
+-
+- Current component props with structure:
+  {
+    query?: string,        // SQL query to fetch data
+    title?: string,        // Component title
+    description?: string,  // Component description
+    config?: {            // Additional configuration
+      [key: string]: any
+    }
+  }
+
+  Schema definition for the  prop that must be passed to the component
+  -{{CURRENT_PROPS}}
+
+Database Schema:
+{{SCHEMA_DOC}}
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- Review the conversation history to understand the evolution of the component
+- If user says "add filter for X", understand they want to modify the current query
+- If user says "change to last month" or "filter by Y", apply modifications to existing query
+- Previous questions can clarify what the user means by ambiguous requests like "change that filter"
+- Use context to determine appropriate time ranges if user says "recent" or "latest"
+
+Your task is to intelligently modify the props based on the user's request:
+
+1. **Query Modification**:
+   - Modify SQL query if user requests different data, filters, time ranges, limits, or aggregations
+   - Use correct table and column names from the schema
+   - Ensure valid SQL syntax
+   - ALWAYS include a LIMIT clause (default: {{DEFAULT_LIMIT}} rows) to prevent large result sets
+   - Preserve the query structure that the component expects (e.g., column aliases)
+
+   **CRITICAL - PostgreSQL Query Rules:**
+
+   **NO AGGREGATE FUNCTIONS IN WHERE CLAUSE:**
+   \u274C WRONG: \`WHERE COUNT(orders) > 0\` or \`WHERE SUM(price) > 100\`
+   \u2705 CORRECT: Use HAVING (with GROUP BY), EXISTS, or subquery
+
+
+   **WHERE vs HAVING:**
+   - WHERE filters rows BEFORE grouping (cannot use aggregates)
+   - HAVING filters groups AFTER grouping (can use aggregates)
+   - If using HAVING, you MUST have GROUP BY
+
+   **Subquery Rules:**
+   - When using a subquery with scalar comparison operators (=, <, >, <=, >=, <>), the subquery MUST return exactly ONE row
+   - ALWAYS add \`LIMIT 1\` to scalar subqueries to prevent "more than one row returned" errors
+   - Example: \`WHERE location_id = (SELECT store_id FROM orders ORDER BY total_amount DESC LIMIT 1)\`
+   - For multiple values, use \`IN\` instead: \`WHERE location_id IN (SELECT store_id FROM orders)\`
+   - Test your subqueries mentally: if they could return multiple rows, add LIMIT 1 or use IN
+
+2. **Title Modification**:
+   - Update title to reflect the user's specific request
+   - Keep it concise and descriptive
+   - Match the tone of the original title
+
+3. **Description Modification**:
+   - Update description to explain what data is shown
+   - Be specific about filters, time ranges, or groupings applied
+
+4. **Config Modification** (based on component type):
+   - For KPICard: formatter, gradient, icon
+   - For Charts: colors, height, xKey, yKey, nameKey, valueKey
+   - For Tables: columns, pageSize, formatters
+
+
+Respond with a JSON object:
+{
+  "props": { /* modified props object with query, title, description, config */ },
+  "isModified": boolean,
+  "reasoning": "brief explanation of changes",
+  "modifications": ["list of specific changes made"]
+}
+
+IMPORTANT:
+- Return the COMPLETE props object, not just modified fields
+- Preserve the structure expected by the component type
+- Ensure query returns columns with expected aliases
+- Keep config properties that aren't affected by the request`,
+    user: `{{USER_PROMPT}}`
+  },
+  "single-component": {
+    system: `You are an expert AI assistant specialized in matching user requests to the most appropriate component from a filtered list.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- If there is previous conversation history, use it to understand what the user is referring to
+- When user says "show trends", "add filters", "change that", understand they may be building on previous queries
+- Use previous component types and queries as context to inform your current matching
+
+## Available Components (Type: {{COMPONENT_TYPE}})
+The following components have been filtered by type {{COMPONENT_TYPE}}. Select the BEST matching one:
+
+{{COMPONENTS_LIST}}
+
+{{VISUALIZATION_CONSTRAINT}}
+
+**Select the BEST matching component** from the available {{COMPONENT_TYPE}} components listed above that would best answer the user's question.
+
+**Matching Guidelines:**
+1. **Semantic Matching:**
+   - Match based on component name, description, and keywords
+   - Consider what metrics/data the user is asking about
+   - Look for semantic similarity (e.g., "sales" matches "revenue", "orders" matches "purchases")
+
+2. **Query Relevance:**
+   - Consider the component's existing query structure
+   - Does it query the right tables/columns for the user's question?
+   - Can it be modified to answer the user's specific question?
+
+3. **Scoring Criteria:**
+   - Exact keyword matches in name/description: High priority
+   - Semantic similarity to user intent: High priority
+   - Appropriate aggregation/grouping: Medium priority
+   - Category alignment: Medium priority
+
+**Output Requirements:**
+
+Respond with a JSON object:
+{
+  "componentId": "matched_component_id",
+  "componentIndex": 1,  // 1-based index from the filtered list above
+  "reasoning": "Detailed explanation of why this component best matches the user's question",
+  "confidence": 85,  // Confidence score 0-100
+  "canGenerate": true  // false if no suitable component found (confidence < 50)
+}
+
+**Important:**
+- Only set canGenerate to true if confidence >= 50%
+- If no component from the list matches well (all have low relevance), set canGenerate to false
+- Consider the full context of the request and conversation history
+- The component's props (query, title, description, config) will be modified later based on the user's specific request
+- Focus on finding the component that is closest to what the user needs, even if it needs modification`,
+    user: `{{USER_PROMPT}}
+
+`
+  },
+  "mutli-component": {
+    system: `You are an expert data analyst AI that creates comprehensive multi-component analytical dashboards with aesthetically pleasing and balanced layouts.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+Database Schema:
+{{SCHEMA_DOC}}
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- Review the conversation history to understand what the user has asked before
+- If user is building on previous insights (e.g., "now show me X and Y"), use context to inform dashboard design
+- Previous queries can help determine appropriate filters, date ranges, or categories to use
+- If user asks for "comprehensive view" or "dashboard for X", include complementary components based on context
+
+Given a user's analytical question and the required visualization types, your task is to:
+
+1. **Determine Container Metadata:**
+   - title: Clear, descriptive title for the entire dashboard (2-5 words)
+   - description: Brief explanation of what insights this dashboard provides (1-2 sentences)
+
+2. **Generate Props for Each Component:**
+   For each visualization type requested, create tailored props:
+
+   - **query**: SQL query specific to this visualization using the database schema
+     * Use correct table and column names
+     * **DO NOT USE TOP keyword - use LIMIT instead (e.g., LIMIT 20, not TOP 20)**
+     * ALWAYS include LIMIT clause ONCE at the end (default: {{DEFAULT_LIMIT}})
+     * For KPICard: Return single row with column alias "value"
+     * For Charts: Return appropriate columns (name/label and value, or x and y)
+     * For Table: Return relevant columns
+
+   - **title**: Specific title for this component (2-4 words)
+
+   - **description**: What this specific component shows (1 sentence)
+
+   - **config**: Type-specific configuration
+     * KPICard: { gradient, formatter, icon }
+     * BarChart: { xKey, yKey, colors, height }
+     * LineChart: { xKey, yKeys, colors, height }
+     * PieChart: { nameKey, valueKey, colors, height }
+     * DataTable: { pageSize }
+
+3. **CRITICAL: Component Hierarchy and Ordering:**
+   The ORDER of components in the array MUST follow this STRICT hierarchy for proper visual layout:
+
+   **HIERARCHY RULES (MUST FOLLOW IN THIS ORDER):**
+   1. KPICards - ALWAYS FIRST (top of dashboard for summary metrics)
+   2. Charts/Graphs - AFTER KPICards (middle of dashboard for visualizations)
+      * BarChart, LineChart, PieChart, DonutChart
+   3. DataTable - ALWAYS LAST (bottom of dashboard, full width for detailed data)
+
+   **LAYOUT BEHAVIOR (Frontend enforces):**
+   - KPICards: Display in responsive grid (3 columns)
+   - Single Chart (if only 1 chart): Takes FULL WIDTH
+   - Multiple Charts (if 2+ charts): Display in 2-column grid
+   - DataTable (if present): Always spans FULL WIDTH at bottom
+
+
+   **ABSOLUTELY DO NOT deviate from this hierarchy. Always place:**
+   - KPICards first
+   - Charts/Graphs second
+   - DataTable last (if present)
+
+**Important Guidelines:**
+- Each component should answer a DIFFERENT aspect of the user's question
+- Queries should be complementary, not duplicated
+- If user asks "Show total revenue and trend", generate:
+  * KPICard: Single total value (FIRST)
+  * LineChart: Revenue over time (SECOND)
+- Ensure queries use valid columns from the schema
+- Make titles descriptive and specific to what each component shows
+- **Snowflake Syntax MUST be used:**
+  * Use LIMIT (not TOP)
+  * Use DATE_TRUNC, DATEDIFF (not DATEPART)
+  * Include LIMIT only ONCE per query at the end
+
+**Output Format:**
+{
+  "containerTitle": "Dashboard Title",
+  "containerDescription": "Brief description of the dashboard insights",
+  "components": [
+    {
+      "componentType": "KPICard" | "BarChart" | "LineChart" | "PieChart" | "DataTable",
+      "query": "SQL query",
+      "title": "Component title",
+      "description": "Component description",
+      "config": { /* type-specific config */ }
+    },
+    ...
+  ],
+  "reasoning": "Explanation of the dashboard design and component ordering",
+  "canGenerate": boolean
+}`,
+    user: `Current user question: {{USER_PROMPT}}
+
+Required visualization types: {{VISUALIZATION_TYPES}}
+
+Generate a complete multi-component dashboard with appropriate container metadata and tailored props for each component. Consider the conversation history above when designing the dashboard. Return ONLY valid JSON.`
+  },
+  "container-metadata": {
+    system: `You are an expert AI assistant that generates titles and descriptions for multi-component dashboards.
+
+CRITICAL: You MUST respond with ONLY valid JSON, no other text before or after.
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- If there is previous conversation history, use it to understand what the user is referring to
+- Use context to create relevant titles and descriptions that align with the user's intent
+
+Your task is to generate a concise title and description for a multi-component dashboard that will contain the following visualization types:
+{{VISUALIZATION_TYPES}}
+
+**Guidelines:**
+
+1. **Title:**
+   - Should be clear and descriptive (3-8 words)
+   - Should reflect what the user is asking about
+   - Should NOT include "Dashboard" suffix (that will be added automatically)
+
+2. **Description:**
+   - Should be a brief summary (1-2 sentences)
+   - Should explain what insights the dashboard provides
+
+**Output Requirements:**
+
+Respond with a JSON object:
+{
+  "title": "Dashboard title without 'Dashboard' suffix",
+  "description": "Brief description of what this dashboard shows"
+}
+
+**Important:**
+- Keep the title concise and meaningful
+- Make the description informative but brief
+- Focus on what insights the user will gain
+`,
+    user: `{{USER_PROMPT}}
+`
+  },
+  "text-response": {
+    system: `You are an intelligent AI assistant that provides helpful, accurate, and contextual text responses to user questions.
+
+## Your Task
+
+Analyze the user's question and provide a helpful text response. Your response should:
+
+1. **Be Clear and Concise**: Provide direct answers without unnecessary verbosity
+2. **Be Contextual**: Use conversation history to understand what the user is asking about
+3. **Be Accurate**: Provide factually correct information based on the context
+4. **Be Helpful**: Offer additional relevant information or suggestions when appropriate
+
+## Handling Data Questions
+
+When the user asks about data
+
+1. **Generate a SQL query** using the database schema provided above
+2. **Use the execute_query tool** to run the query
+3. **If the query fails**, analyze the error and generate a corrected query
+4. **Format the results** in a clear, readable way for the user
+
+**Query Guidelines:**
+- Use correct table and column names from the schema
+- ALWAYS include a LIMIT clause with a MAXIMUM of 32 rows
+- Ensure valid SQL syntax
+- For time-based queries, use appropriate date functions
+- When using subqueries with scalar operators (=, <, >, etc.), add LIMIT 1 to prevent "more than one row" errors
+
+## Response Guidelines
+
+- If the question is about data, use the execute_query tool to fetch data and present it
+- If the question is general knowledge, provide a helpful conversational response
+- If asking for clarification, provide options or ask specific follow-up questions
+- If you don't have enough information, acknowledge it and ask for more details
+- Keep responses focused and avoid going off-topic
+
+## Component Suggestions
+
+After analyzing the query results, you MUST suggest appropriate dashboard components for displaying the data. Use this format:
+
+<DashboardComponents>
+**Dashboard Components:**
+Format: \`{number}.{component_type} : {clear reasoning}\`
+
+
+**Rules for component suggestions:**
+1. Analyze the query results structure and data type
+2. Suggest components that would best visualize the data
+3. Each component suggestion must be on a new line
+</DashboardComponents>
+
+IMPORTANT: Always wrap component suggestions with <DashboardComponents> tags and include at least one component suggestion when data is returned.
+
+## Output Format
+
+Respond with plain text that includes:
+
+1. **Query Analysis** (if applicable): Brief explanation of what data was fetched
+2. **Results Summary**: Present the data in a clear, readable format
+3. **Dashboard Components**: List suggested components wrapped in <DashboardComponents> tags
+
+
+**CRITICAL:**
+- Return ONLY plain text (no JSON, no markdown code blocks)
+
+
+You have access to a database and can execute SQL queries to answer data-related questions.
+## Database Schema
+{{SCHEMA_DOC}}
+
+**Database Type: PostgreSQL**
+
+**CRITICAL PostgreSQL Query Rules:**
+
+1. **NO AGGREGATE FUNCTIONS IN WHERE CLAUSE** - This is a fundamental SQL error
+   \u274C WRONG: \`WHERE COUNT(orders) > 0\`
+   \u274C WRONG: \`WHERE SUM(price) > 100\`
+   \u274C WRONG: \`WHERE AVG(rating) > 4.5\`
+
+   \u2705 CORRECT: Use HAVING (with GROUP BY), EXISTS, or subquery
+
+2. **WHERE vs HAVING**
+   - WHERE filters rows BEFORE grouping (cannot use aggregates)
+   - HAVING filters groups AFTER grouping (can use aggregates)
+   - If using HAVING, you MUST have GROUP BY
+
+3. **NO NESTED AGGREGATE FUNCTIONS** - PostgreSQL does NOT allow aggregates inside aggregates
+   \u274C WRONG: \`AVG(ROUND(AVG(column), 2))\` or \`SELECT AVG(SUM(price)) FROM ...\`
+   \u2705 CORRECT: \`ROUND(AVG(column), 2)\`
+
+4. **GROUP BY Requirements**
+   - ALL non-aggregated columns in SELECT must be in GROUP BY
+   - If you SELECT a column and don't aggregate it, add it to GROUP BY
+
+5. **LIMIT Clause**
+   - ALWAYS include LIMIT (max 32 rows)
+   - For scalar subqueries in WHERE/HAVING, add LIMIT 1
+
+
+## Knowledge Base Context
+
+The following relevant information has been retrieved from the knowledge base for this question:
+
+{{KNOWLEDGE_BASE_CONTEXT}}
+
+Use this knowledge base information to:
+- Provide more accurate and informed responses
+- Reference specific facts, concepts, or domain knowledge
+- Enhance your understanding of the user's question
+- Give context-aware recommendations
+
+**Note:** If there is previous conversation history, use it to understand context and provide coherent responses:
+- Reference previous questions and answers when relevant
+- Maintain consistency with earlier responses
+- Use the history to resolve ambiguous references like "that", "it", "them", "the previous data"
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+
+`,
+    user: `{{USER_PROMPT}}
+
+`
+  },
+  "match-text-components": {
+    system: `You are a component matching expert that creates beautiful, well-structured dashboard visualizations from analysis results.
+
+## Your Task
+
+You will receive a text response containing:
+1. Query execution results (with "\u2705 Query executed successfully!" markers)
+2. Data analysis and insights
+3. **Dashboard Components:** suggestions (1:component_type : reasoning format)
+
+Your job is to:
+1. **Parse the component suggestions** from the text response (format: 1:component_type : reasoning)
+2. **Match each suggestion with an actual component** from the available list
+3. **Generate proper props** for each matched component to **visualize the analysis results** that were already fetched
+4. **SELECT the best dashboard layout component** that can accommodate all the matched components
+5. **Generate intelligent follow-up questions (actions)** that the user might naturally ask next based on the data analysis
+
+**CRITICAL GOAL**: Create dashboard components that display the **same data that was already analyzed** - NOT new data. The queries already ran and got results. You're just creating different visualizations of those results.
+
+**APPROACH**: First match all the components suggested in the text response, THEN find the layout that best fits those components.
+
+## Available Components
+
+{{AVAILABLE_COMPONENTS}}
+
+## Component Matching Rules (STEP 1)
+For each component suggestion (c1, c2, c3, etc.) from the text response:
+
+1. **Match by type**: Find components whose \`type\` matches the suggested component type
+2. **Refine by relevance**: If multiple components match, choose based on:
+   - Description and keywords matching the use case
+   - Best fit for the data being visualized
+3. **Fallback**: If no exact type match, find the closest alternative
+
+## Layout Selection Logic (STEP 2 - After Matching Components)
+
+**After you have matched all components**, select the best dashboard layout:
+
+1. **Find layout components** by looking for components with \`type: "DashboardLayout"\` in the available components list
+2. **Read each layout's description** to understand:
+   - What structure it provides
+   - When it's best used (e.g., comprehensive analysis vs focused analysis)
+   - The number and types of components it can accommodate
+3. **Select the best layout** based on:
+   - Which layout can best display ALL the matched components
+   - The layout's capacity (how many components it supports)
+   - The types of matched components (KPI, charts, tables, etc.)
+   - The user question and data complexity
+4. **If no specific layout fits**, fall back to "MultiComponentContainer" as the default layout
+
+**IMPORTANT:** The layout should be chosen to FIT the matched components, not the other way around. Don't force components to fit a layout - find a layout that accommodates your components.
+
+## Props Generation Rules
+
+For each matched component, generate complete props:
+
+### 1. Query - When to Reuse vs Generate
+
+**Option A: REUSE the successful query** (preferred when possible)
+- Look for "\u2705 Query executed successfully!" in the text response
+- Extract the exact SQL query that worked
+- Use this SAME query for components that visualize the same data differently
+
+**Option B: GENERATE a new query** (when necessary)
+- Only generate new queries when you need DIFFERENT data
+- Use the database schema below to write valid SQL
+
+
+**Decision Logic:**
+- Different aggregation needed \u2192 Generate new query \u2705
+- Same data, different view \u2192 Reuse query \u2705
+
+**Database Schema:**
+{{SCHEMA_DOC}}
+
+**Database Type: PostgreSQL**
+
+**CRITICAL PostgreSQL Query Rules**
+
+1. **NO AGGREGATE FUNCTIONS IN WHERE CLAUSE** - This is a fundamental SQL error
+   \u274C WRONG: \`WHERE COUNT(orders) > 0\`
+   \u274C WRONG: \`WHERE SUM(price) > 100\`
+   \u274C WRONG: \`WHERE AVG(rating) > 4.5\`
+
+    \u2705 CORRECT: Use HAVING (with GROUP BY), EXISTS, or subquery
+
+2. **NO NESTED AGGREGATE FUNCTIONS** - PostgreSQL does NOT allow aggregates inside aggregates
+   \u274C WRONG: \`AVG(ROUND(AVG(column), 2))\`
+   \u2705 CORRECT: \`ROUND(AVG(column), 2)\`
+
+3. **Aggregate Functions Can Only Appear Once Per Level**
+   \u274C WRONG: \`SELECT AVG(SUM(price)) FROM ...\` (nested)
+   \u2705 CORRECT: Use subquery: \`SELECT AVG(total) FROM (SELECT SUM(price) as total FROM ... GROUP BY ...) subq\`
+
+4. **WHERE vs HAVING**
+   - WHERE filters rows BEFORE grouping (cannot use aggregates)
+   - HAVING filters groups AFTER grouping (can use aggregates)
+   - Use WHERE for column comparisons: \`WHERE price > 100\`
+   - Use HAVING for aggregate comparisons: \`HAVING COUNT(*) > 5\`
+
+5. **GROUP BY Requirements**
+   - ALL non-aggregated columns in SELECT must be in GROUP BY
+   - Use proper column references (table.column or aliases)
+   - If using HAVING, you MUST have GROUP BY
+
+6. **LIMIT Clause**
+   - ALWAYS include LIMIT clause (max 32 rows for dashboard queries)
+   - For scalar subqueries in WHERE/HAVING, add LIMIT 1
+
+7. **Scalar Subqueries**
+   - Subqueries used with =, <, >, etc. must return single value
+   - Always add LIMIT 1 to scalar subqueries
+
+**Query Generation Guidelines** (when creating new queries):
+- Use correct table and column names from the schema above
+- ALWAYS include LIMIT clause (max 32 rows)
+
+### 2. Title
+- Create a clear, descriptive title
+- Should explain what the component shows
+- Use context from the original question
+
+### 3. Description
+- Brief explanation of what this component displays
+- Why it's useful for this data
+
+### 4. Config
+- **CRITICAL**: Look at the component's "Props Structure" to see what config fields it expects
+- Map query result columns to the appropriate config fields
+- Keep other existing config properties that don't need to change
+- Ensure config field values match actual column names from the query
+
+**Special Rules for Bar Charts**
+- \`xAxisKey\` = ALWAYS the category/label column (text field )
+- \`yAxisKey\` = ALWAYS the numeric value column (number field )
+- \`orientation\` = "vertical" or "horizontal" (controls visual direction only)
+- **DO NOT swap xAxisKey/yAxisKey based on orientation** - they always represent category and value respectively
+
+## Follow-Up Questions (Actions) Generation
+
+After analyzing the text response and matched components, generate 4-5 intelligent follow-up questions that the user might naturally ask next. These questions should:
+
+1. **Build upon the data analysis** shown in the text response and components
+2. **Explore natural next steps** in the data exploration journey
+3. **Be progressively more detailed or specific** - go deeper into the analysis
+4. **Consider the insights revealed** - suggest questions that help users understand implications
+5. **Be phrased naturally** as if a real user would ask them
+6. **Vary in scope** - include both broad trends and specific details
+7. **Avoid redundancy** - don't ask questions already answered in the text response
+
+
+## Output Format
+
+You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
+
+**IMPORTANT JSON FORMATTING RULES:**
+- Put SQL queries on a SINGLE LINE (no newlines in the query string)
+- Escape all quotes in SQL properly (use \\" for quotes inside strings)
+- Remove any newlines, tabs, or special characters from SQL
+- Do NOT use markdown code blocks (no \`\`\`)
+- Return ONLY the JSON object, nothing else
+
+\`\`\`json
+{
+  "selectedLayoutId": "id_of_the_selected_layout_component",
+  "layoutReasoning": "Why this layout was selected based on its description and the analysis needs",
+  "matchedComponents": [
+    {
+      "componentId": "id_from_available_list",
+      "componentName": "name_of_component",
+      "componentType": "type_of_component",
+      "reasoning": "Why this component was selected for this suggestion",
+      "originalSuggestion": "c1:table : original reasoning from text",
+      "props": {
+        "query": "SQL query for this component",
+        "title": "Component title",
+        "description": "Component description",
+        "config": {
+          "field1": "value1",
+          "field2": "value2"
+        }
+      }
+    }
+  ],
+  "actions": [
+    "Follow-up question 1?",
+    "Follow-up question 2?",
+    "Follow-up question 3?",
+    "Follow-up question 4?",
+    "Follow-up question 5?"
+  ]
+}
+\`\`\`
+
+**CRITICAL:**
+- \`matchedComponents\` MUST include ALL components suggested in the text response (match them first!)
+- \`selectedLayoutId\` MUST be the ID of the selected layout component (must have type "DashboardLayout")
+- \`layoutReasoning\` MUST explain:
+  - Why you chose this specific layout component
+  - How many components you matched (e.g., "Matched 3 components: 1 KPI, 1 chart, 1 table")
+  - Why this layout is the best fit for displaying these specific matched components
+  - What makes this layout appropriate for the component types and count
+- The layout selection happens AFTER component matching - don't force components to fit a pre-selected layout
+- \`actions\` MUST be an array of 4-5 intelligent follow-up questions based on the analysis
+- Return ONLY valid JSON (no markdown code blocks, no text before/after)
+- Generate complete props for each component
+
+
+`,
+    user: `## Text Response
+
+{{TEXT_RESPONSE}}
+
+---
+
+Match the component suggestions from the text response above with available components, and generate proper props for each matched component.
+`
+  },
+  "actions": {
+    system: `You are an expert data analyst. Your task is to suggest intelligent follow-up questions based on the conversation history and the current data visualization. The questions should help users explore the data more deeply and make better insights.
+
+## Previous Conversation
+{{CONVERSATION_HISTORY}}
+
+**Context Instructions:**
+- Review the entire conversation history to understand the user's journey and interests
+- Suggest questions that naturally progress from previous explorations
+- Avoid suggesting questions about topics already covered in the conversation
+- Build upon insights from previous components to suggest deeper analysis
+- Consider what the user might want to explore next based on their question pattern`,
+    user: `Given the following context:
+
+Latest User Question: {{ORIGINAL_USER_PROMPT}}
+
+Current Component:
+{{COMPONENT_INFO}}
+
+{{COMPONENT_DATA}}
+
+Generate a JSON array of 4-5 intelligent follow-up questions that the user might naturally ask next. These questions should:
+1. Build upon the conversation history and insights shown in the current component
+2. NOT repeat questions or topics already covered in the conversation history
+3. Explore natural next steps in the data exploration journey
+4. Be progressively more detailed or specific
+5. Consider the user's apparent interests based on their question pattern
+6. Be phrased naturally as if a real user would ask them
+
+Format your response as a JSON object with this structure:
+{
+  "nextQuestions": [
+    "Question 1?",
+    "Question 2?",
+    ...
+  ]
+}
+
+Return ONLY valid JSON.`
+  }
+};
+
+// src/userResponse/prompt-loader.ts
 var PromptLoader = class {
   constructor(config) {
     this.promptCache = /* @__PURE__ */ new Map();
     this.isInitialized = false;
-    logger.debug("Initializing PromptLoader...", process.cwd());
+    logger.debug("Initializing PromptLoader...");
     this.promptsDir = config?.promptsDir || path3.join(process.cwd(), ".prompts");
-    this.defaultPromptsDir = path3.join(__dirname, "..", "..", ".prompts");
+    logger.debug(`Prompts directory set to: ${this.promptsDir}`);
+  }
+  /**
+   * Load a prompt template from file system OR fallback to hardcoded prompts
+   * @param promptName - Name of the prompt folder
+   * @returns Template with system and user prompts
+   */
+  loadPromptTemplate(promptName) {
+    try {
+      const systemPath = path3.join(this.promptsDir, promptName, "system.md");
+      const userPath = path3.join(this.promptsDir, promptName, "user.md");
+      if (fs4.existsSync(systemPath) && fs4.existsSync(userPath)) {
+        const system = fs4.readFileSync(systemPath, "utf-8");
+        const user = fs4.readFileSync(userPath, "utf-8");
+        logger.info(`\u2713 Loaded prompt '${promptName}' from file system: ${this.promptsDir}`);
+        return { system, user };
+      }
+    } catch (error) {
+      logger.error(`Could not load '${promptName}' from file system, trying fallback...`);
+    }
+    const hardcodedPrompt = PROMPTS[promptName];
+    if (hardcodedPrompt) {
+      logger.info(`\u2713 Loaded prompt '${promptName}' from hardcoded fallback`);
+      return hardcodedPrompt;
+    }
+    throw new Error(`Prompt template '${promptName}' not found in either ${this.promptsDir} or hardcoded prompts. Available prompts: ${Object.keys(PROMPTS).join(", ")}`);
   }
   /**
    * Initialize and cache all prompts into memory
-   * This should be called once at SDK startup
+   * Tries file system first, then falls back to hardcoded prompts
    */
   async initialize() {
     if (this.isInitialized) {
@@ -2205,61 +3063,19 @@ var PromptLoader = class {
       return;
     }
     logger.info("Loading prompts into memory...");
-    const promptTypes = [
-      "classify",
-      "match-component",
-      "modify-props",
-      "single-component",
-      "mutli-component",
-      "actions",
-      "container-metadata",
-      "text-response",
-      "match-text-components"
-    ];
-    for (const promptType of promptTypes) {
+    const promptTypes = Object.keys(PROMPTS);
+    for (const promptName of promptTypes) {
       try {
-        const template = await this.loadPromptTemplate(promptType);
-        this.promptCache.set(promptType, template);
-        logger.debug(`Cached prompt: ${promptType}`);
+        const template = this.loadPromptTemplate(promptName);
+        this.promptCache.set(promptName, template);
       } catch (error) {
-        logger.error(`Failed to load prompt '${promptType}':`, error);
+        logger.error(`Failed to load prompt '${promptName}':`, 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
-   * @returns Template with system and user prompts
-   */
-  async loadPromptTemplate(promptName) {
-    const tryLoadFromDir = (dir) => {
-      try {
-        const systemPath = path3.join(dir, promptName, "system.md");
-        const userPath = path3.join(dir, promptName, "user.md");
-        if (fs4.existsSync(systemPath) && fs4.existsSync(userPath)) {
-          const system = fs4.readFileSync(systemPath, "utf-8");
-          const user = fs4.readFileSync(userPath, "utf-8");
-          logger.debug(`Loaded prompt '${promptName}' from ${dir}`);
-          return { system, user };
-        }
-        return null;
-      } catch (error) {
-        return null;
-      }
-    };
-    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;
-  }
   /**
    * Replace variables in a template string using {{VARIABLE_NAME}} pattern
    * @param template - Template string with placeholders
@@ -2277,13 +3093,13 @@ var PromptLoader = class {
   }
   /**
    * Load both system and user prompts from cache and replace variables
-   * @param promptName - Name of the prompt folder
+   * @param promptName - Name of the prompt
    * @param variables - Variables to replace in the templates
    * @returns Object containing both system and user prompts
    */
   async loadPrompts(promptName, variables) {
     if (!this.isInitialized) {
-      logger.warn("PromptLoader not initialized, loading prompts on-demand (not recommended)");
+      logger.warn("PromptLoader not initialized, initializing now...");
       await this.initialize();
     }
     const template = this.promptCache.get(promptName);
@@ -2311,6 +3127,7 @@ var PromptLoader = class {
     this.promptsDir = dir;
     this.isInitialized = false;
     this.promptCache.clear();
+    logger.debug(`Prompts directory changed to: ${dir}`);
   }
   /**
    * Get current prompts directory
@@ -2340,6 +3157,7 @@ var promptLoader = new PromptLoader({
 // src/llm.ts
 import Anthropic from "@anthropic-ai/sdk";
 import Groq from "groq-sdk";
+import { jsonrepair } from "jsonrepair";
 var LLM = class {
   /* Get a complete text response from an LLM (Anthropic or Groq) */
   static async text(messages, options = {}) {
@@ -2461,65 +3279,110 @@ var LLM = class {
     let finalText = "";
     while (iterations < maxIterations) {
       iterations++;
-      const response = await client.messages.create({
+      const stream = await client.messages.create({
         model: modelName,
         max_tokens: options.maxTokens || 4e3,
         temperature: options.temperature,
         system: messages.sys,
         messages: conversationMessages,
-        tools
+        tools,
+        stream: true
+        // Enable streaming
       });
-      if (response.stop_reason === "end_turn") {
-        const textBlock = response.content.find((block) => block.type === "text");
-        if (textBlock && textBlock.type === "text") {
-          finalText = textBlock.text;
-          if (options.partial) {
-            options.partial(finalText);
+      let stopReason = null;
+      const contentBlocks = [];
+      let currentTextBlock = "";
+      let currentToolUse = null;
+      for await (const chunk of stream) {
+        if (chunk.type === "message_start") {
+          contentBlocks.length = 0;
+          currentTextBlock = "";
+          currentToolUse = null;
+        }
+        if (chunk.type === "content_block_start") {
+          if (chunk.content_block.type === "text") {
+            currentTextBlock = "";
+          } else if (chunk.content_block.type === "tool_use") {
+            currentToolUse = {
+              type: "tool_use",
+              id: chunk.content_block.id,
+              name: chunk.content_block.name,
+              input: {}
+            };
+          }
+        }
+        if (chunk.type === "content_block_delta") {
+          if (chunk.delta.type === "text_delta") {
+            const text = chunk.delta.text;
+            currentTextBlock += text;
+            if (options.partial) {
+              options.partial(text);
+            }
+          } else if (chunk.delta.type === "input_json_delta" && currentToolUse) {
+            currentToolUse.inputJson = (currentToolUse.inputJson || "") + chunk.delta.partial_json;
+          }
+        }
+        if (chunk.type === "content_block_stop") {
+          if (currentTextBlock) {
+            contentBlocks.push({
+              type: "text",
+              text: currentTextBlock
+            });
+            finalText = currentTextBlock;
+            currentTextBlock = "";
+          } else if (currentToolUse) {
+            try {
+              currentToolUse.input = currentToolUse.inputJson ? JSON.parse(currentToolUse.inputJson) : {};
+            } catch (error) {
+              currentToolUse.input = {};
+            }
+            delete currentToolUse.inputJson;
+            contentBlocks.push(currentToolUse);
+            currentToolUse = null;
           }
         }
+        if (chunk.type === "message_delta") {
+          stopReason = chunk.delta.stop_reason || stopReason;
+        }
+        if (chunk.type === "message_stop") {
+          break;
+        }
+      }
+      if (stopReason === "end_turn") {
         break;
       }
-      if (response.stop_reason === "tool_use") {
-        const toolUses = response.content.filter((block) => block.type === "tool_use");
+      if (stopReason === "tool_use") {
+        const toolUses = contentBlocks.filter((block) => block.type === "tool_use");
         if (toolUses.length === 0) {
           break;
         }
         conversationMessages.push({
           role: "assistant",
-          content: response.content
+          content: contentBlocks
         });
         const toolResults = {
           role: "user",
           content: []
         };
         for (const toolUse of toolUses) {
-          if (toolUse.type === "tool_use") {
-            try {
-              const result = await toolHandler(toolUse.name, toolUse.input);
-              toolResults.content.push({
-                type: "tool_result",
-                tool_use_id: toolUse.id,
-                content: typeof result === "string" ? result : JSON.stringify(result)
-              });
-            } catch (error) {
-              toolResults.content.push({
-                type: "tool_result",
-                tool_use_id: toolUse.id,
-                content: error instanceof Error ? error.message : String(error),
-                is_error: true
-              });
-            }
+          try {
+            const result = await toolHandler(toolUse.name, toolUse.input);
+            toolResults.content.push({
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: typeof result === "string" ? result : JSON.stringify(result)
+            });
+          } catch (error) {
+            toolResults.content.push({
+              type: "tool_result",
+              tool_use_id: toolUse.id,
+              content: error instanceof Error ? error.message : String(error),
+              is_error: true
+            });
           }
         }
         conversationMessages.push(toolResults);
       } else {
-        const textBlock = response.content.find((block) => block.type === "text");
-        if (textBlock && textBlock.type === "text") {
-          finalText = textBlock.text;
-          if (options.partial) {
-            options.partial(finalText);
-          }
-        }
         break;
       }
     }
@@ -2582,9 +3445,9 @@ var LLM = class {
   // ============================================================
   /**
    * Parse JSON string, handling markdown code blocks and surrounding text
-   * Enhanced version from anthropic.ts implementation
+   * Enhanced version with jsonrepair to handle malformed JSON from LLMs
    * @param text - Text that may contain JSON wrapped in ```json...``` or with surrounding text
-   * @returns Parsed JSON object
+   * @returns Parsed JSON object or array
    */
   static _parseJSON(text) {
     let jsonText = text.trim();
@@ -2594,11 +3457,29 @@ var LLM = class {
       jsonText = jsonText.replace(/^```\s*\n?/, "").replace(/\n?```\s*$/, "");
     }
     const firstBrace = jsonText.indexOf("{");
+    const firstBracket = jsonText.indexOf("[");
     const lastBrace = jsonText.lastIndexOf("}");
-    if (firstBrace !== -1 && lastBrace !== -1 && firstBrace < lastBrace) {
-      jsonText = jsonText.substring(firstBrace, lastBrace + 1);
+    const lastBracket = jsonText.lastIndexOf("]");
+    let startIdx = -1;
+    let endIdx = -1;
+    if (firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket)) {
+      startIdx = firstBrace;
+      endIdx = lastBrace;
+    } else if (firstBracket !== -1) {
+      startIdx = firstBracket;
+      endIdx = lastBracket;
+    }
+    if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
+      jsonText = jsonText.substring(startIdx, endIdx + 1);
+    }
+    try {
+      const repairedJson = jsonrepair(jsonText);
+      return JSON.parse(repairedJson);
+    } catch (error) {
+      throw new Error(`Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}
+
+Original text: ${jsonText.substring(0, 200)}...`);
     }
-    return JSON.parse(jsonText);
   }
 };
 
@@ -3211,7 +4092,7 @@ var BaseLLM = class {
       logger.debug(`[${this.getProviderName()}] Loaded match-text-components prompts`);
       logger.file("\n=============================\nmatch text components system prompt:", prompts.system);
       logCollector?.info("Matching components from text response...");
-      const rawResponse = await LLM.stream(
+      const result = await LLM.stream(
         {
           sys: prompts.system,
           user: prompts.user
@@ -3222,60 +4103,12 @@ var BaseLLM = class {
           temperature: 0.2,
           apiKey: this.getApiKey(apiKey)
         },
-        false
-        // Don't parse as JSON yet, get raw response
+        true
+        // Parse as JSON
       );
-      logger.debug(`[${this.getProviderName()}] Raw component matching response length: ${rawResponse?.length || 0}`);
-      let result;
-      try {
-        let cleanedResponse = rawResponse || "";
-        cleanedResponse = cleanedResponse.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-        const jsonMatch = cleanedResponse.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-          cleanedResponse = jsonMatch[0];
-        }
-        result = JSON.parse(cleanedResponse);
-      } catch (parseError) {
-        logger.error(`[${this.getProviderName()}] Failed to parse component matching JSON response`);
-        const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
-        const posMatch = errorMsg.match(/position (\d+)/);
-        const errorPos = posMatch ? parseInt(posMatch[1]) : -1;
-        if (errorPos > 0 && rawResponse) {
-          const start = Math.max(0, errorPos - 200);
-          const end = Math.min(rawResponse.length, errorPos + 200);
-          logger.debug(`[${this.getProviderName()}] Error context (position ${errorPos}):`);
-          logger.debug(rawResponse.substring(start, end));
-          logger.debug(" ".repeat(Math.min(200, errorPos - start)) + "^--- Error here");
-        }
-        logger.debug(`[${this.getProviderName()}] Raw response (first 2000 chars):`, rawResponse?.substring(0, 2e3));
-        logger.debug(`[${this.getProviderName()}] Parse error:`, parseError);
-        logCollector?.error(`Failed to parse component matching response: ${errorMsg}`);
-        try {
-          logger.info(`[${this.getProviderName()}] Attempting aggressive JSON cleanup...`);
-          let aggressive = rawResponse || "";
-          aggressive = aggressive.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-          const match = aggressive.match(/\{[\s\S]*\}/);
-          if (match) {
-            aggressive = match[0];
-          }
-          aggressive = aggressive.replace(/,(\s*[}\]])/g, "$1");
-          result = JSON.parse(aggressive);
-          logger.info(`[${this.getProviderName()}] Aggressive cleanup succeeded!`);
-        } catch (secondError) {
-          logger.error(`[${this.getProviderName()}] Aggressive cleanup also failed`);
-          return {
-            components: [],
-            selectedLayout: "MultiComponentContainer",
-            selectedLayoutId: "",
-            selectedLayoutComponent: null,
-            layoutReasoning: "No layout selected",
-            actions: []
-          };
-        }
-      }
+      logger.debug(`[${this.getProviderName()}] Component matching response parsed successfully`);
       const matchedComponents = result.matchedComponents || [];
-      const selectedLayout = result.selectedLayout || "MultiComponentContainer";
-      const selectedLayoutId = result.selectedLayoutId || "";
+      const selectedLayoutId = result.selectedLayoutId || "multi-component-container";
       const layoutReasoning = result.layoutReasoning || "No layout reasoning provided";
       const rawActions = result.actions || [];
       const actions = convertQuestionsToActions(rawActions);
@@ -3287,11 +4120,11 @@ var BaseLLM = class {
         }
       }
       logger.info(`[${this.getProviderName()}] Matched ${matchedComponents.length} components from text response`);
-      logger.info(`[${this.getProviderName()}] Selected layout: ${selectedLayout} (ID: ${selectedLayoutId})`);
+      logger.info(`[${this.getProviderName()}] Selected layout: (ID: ${selectedLayoutId})`);
       logger.info(`[${this.getProviderName()}] Layout reasoning: ${layoutReasoning}`);
       logger.info(`[${this.getProviderName()}] Generated ${actions.length} follow-up actions`);
       if (matchedComponents.length > 0) {
-        logCollector?.info(`Matched ${matchedComponents.length} components for visualization using ${selectedLayout}`);
+        logCollector?.info(`Matched ${matchedComponents.length} components for visualization `);
         logCollector?.info(`Layout reasoning: ${layoutReasoning}`);
         matchedComponents.forEach((comp, idx) => {
           logCollector?.info(`  ${idx + 1}. ${comp.componentName} (${comp.componentType}): ${comp.reasoning}`);
@@ -3326,7 +4159,6 @@ var BaseLLM = class {
       }).filter(Boolean);
       return {
         components: finalComponents,
-        selectedLayout,
         selectedLayoutId,
         selectedLayoutComponent,
         layoutReasoning,
@@ -3334,15 +4166,13 @@ var BaseLLM = class {
       };
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      logger.error(`[${this.getProviderName()}] Error matching components from text response: ${errorMsg}`);
-      logger.debug(`[${this.getProviderName()}] Component matching error details:`, error);
-      logCollector?.error(`Error matching components: ${errorMsg}`);
+      logger.error(`[${this.getProviderName()}] Error matching components: ${errorMsg}`);
+      logCollector?.error(`Failed to match components: ${errorMsg}`);
       return {
         components: [],
-        selectedLayout: "MultiComponentContainer",
         selectedLayoutId: "",
         selectedLayoutComponent: null,
-        layoutReasoning: "Error occurred during component matching",
+        layoutReasoning: "Failed to match components due to parsing error",
         actions: []
       };
     }
@@ -3609,7 +4439,7 @@ ${errorMsg}
           container_componet = {
             ...selectedLayoutComponent,
             id: `${selectedLayoutComponent.id}_${Date.now()}`,
-            description: layoutReasoning,
+            // Make ID unique for each instance
             props: {
               ...selectedLayoutComponent.props,
               config: {
@@ -6382,6 +7212,7 @@ var SuperatomSDK = class {
   }
   /**
    * Initialize PromptLoader and load prompts into memory
+   * Tries to load from file system first, then falls back to hardcoded prompts
    */
   async initializePromptLoader(promptsDir) {
     try {
@@ -6455,7 +7286,7 @@ var SuperatomSDK = class {
         url.searchParams.set("projectId", this.projectId);
         url.searchParams.set("userId", this.userId);
         url.searchParams.set("type", this.type);
-        logger.info(`Connecting to WebSocket: ${url.host}`);
+        logger.info(`Connecting to WebSocket: ${url.toString()}`);
         this.ws = createWebSocket(url.toString());
         this.ws.addEventListener("open", () => {
           this.connected = true;