@superatomai/sdk-node 0.0.41 → 0.0.43

package/dist/index.js

@@ -1050,11 +1050,29 @@ Analyze the user's request and:
 2. **Match by Type**: Choose the component type that best fits the data visualization or action need
 3. **Match by Description**: Use component descriptions and keywords to find the best fit
 
+## Component Update Handling
+
+The user prompt may contain an **existing component** to update. Detect this by looking for:
+- JSON object with \`componentId\`, \`props\`, or similar component structure in the prompt
+- Phrases like "update this", "modify", "change", "edit this component"
+
+### When UPDATING an existing component:
+1. **Preserve the \`componentId\`** from the current component (do NOT pick a new one)
+2. **Keep the same \`componentType\`** unless the user explicitly asks to change it
+3. **Merge props**: Start with existing props, then modify only what the user requested
+4. **Set \`isUpdate: true\`** in your response
+5. **Preserve unmentioned props**: If user only asks to change the query, keep title/config unchanged
+
+### When CREATING a new component:
+1. Pick the best component from the available list
+2. Generate all props from scratch
+3. Set \`isUpdate: false\` in your response
+
 ## Data Source Decision
 
 ### Use DATABASE when:
-- User asks about data that exists in the database schema (customers, orders, products, etc.)
-- Questions about internal business data (sales, inventory, users, transactions)
+- User asks about data that exists in the database schema
+- Questions about internal business data
 - CRUD operations on database tables
 
 ### Use EXTERNAL TOOL when:
@@ -1135,11 +1153,12 @@ Analyze the user's request and:
 You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 
 {
-  "componentId": "id_from_available_list",
+  "componentId": "id_from_available_list_or_existing_component_id",
   "componentName": "name_of_component",
   "componentType": "type_of_component",
   "dataSourceType": "database" | "external_tool",
   "operationType": "view" | "create" | "update" | "delete",
+  "isUpdate": true | false,
   "reasoning": "Why this component was selected and why this data source",
   "props": {
     // Generate ALL props based on the component's Props Structure
@@ -1150,25 +1169,165 @@ You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 
 **CRITICAL:**
 - Return ONLY valid JSON (no markdown code blocks, no text before/after)
-- \`componentId\` MUST match an ID from the available components list
+- \`componentId\`: For new components, MUST match an ID from the available components list. For updates, preserve the existing component's ID
+- \`isUpdate\`: Set to \`true\` if updating an existing component, \`false\` if creating new
 - \`dataSourceType\` indicates whether data comes from database or external tool
-- \`operationType\` indicates the type of operation (view/create/update/delete)
+- \`operationType\` indicates the type of data operation (view/create/update/delete)
 - Generate COMPLETE props based on the component's "Props Structure"
 - For queries, ALWAYS use \`$paramName\` placeholders and include \`params\` object
 - For external tools, \`toolId\` MUST match an ID from the available tools list
 
+## Database Schema
+{{SCHEMA_DOC}}
+
+## Available External Tools
+{{AVAILABLE_TOOLS}}
+
+## Available Components
+{{AVAILABLE_COMPONENTS}}
+
 ---
 
-## CONTEXT (for this specific request)
+## CONTEXT`,
+        user: `{{USER_PROMPT}}`
+      },
+      "dash-filter-picker": {
+        system: `You are a dashboard filter expert that creates filter components and updates existing dashboard components to work with the filter.
+
+## Your Task
+
+1. **Create a filter component** based on the user's request (DatePicker, Dropdown, SearchBox, etc.)
+2. **Update all existing components** to use the filter values in their queries/params
+
+## Filter Types
+
+Choose the appropriate filter component based on user intent:
+- **DateRangePicker**: For date range filtering (start date, end date)
+- **DatePicker**: For single date filtering
+- **Dropdown**: For categorical filtering (status, category, type, etc.)
+- **MultiSelect**: For multiple value selection
+- **SearchBox**: For text search filtering
+- **NumberRange**: For numeric range filtering
+
+## Filter Component Structure
+
+Generate a filter component with these props:
+\`\`\`json
+{
+  "componentId": "unique_filter_id",
+  "componentType": "DateRangePicker | Dropdown | SearchBox | etc.",
+  "componentName": "Display Name",
+  "props": {
+    "filterId": "unique_filter_id",
+    "label": "Filter Label",
+    "defaultValue": "optional default value",
+    "options": []
+  }
+}
+\`\`\`
+
+## Updating Existing Components
+
+For each existing component, update its query/externalTool to use the filter:
+
+### For Database Queries:
+- Add filter conditions to WHERE clause using \`$paramName\` placeholders
+- Add the filter param to the \`params\` object with binding reference
+
+### For External Tools:
+- Add filter params to the tool's params object with binding reference
+
+## Filter Bindings
 
-### Database Schema
+Use this binding format to connect filter values to component params:
+\`\`\`json
+{
+  "paramName": "$filter.filterId.value"
+}
+\`\`\`
+
+For DateRangePicker:
+- \`$filter.filterId.startDate\`
+- \`$filter.filterId.endDate\`
+
+For Dropdown/MultiSelect:
+- \`$filter.filterId.value\`
+
+For SearchBox:
+- \`$filter.filterId.searchText\`
+
+### Database Query Rules
+{{DATABASE_RULES}}
+
+## Output Format
+
+You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
+
+{
+  "filterComponent": {
+    "componentId": "filter_unique_id",
+    "componentType": "DateRangePicker | Dropdown | etc.",
+    "componentName": "Filter Display Name",
+    "props": {
+      "filterId": "filter_unique_id",
+      "label": "Filter Label",
+      "defaultValue": null,
+      "options": []
+    }
+  },
+  "updatedComponents": [
+    {
+      "componentId": "existing_component_id",
+      "componentType": "existing_type",
+      "componentName": "existing_name",
+      "props": {
+        // RETURN THE COMPLETE PROPS OBJECT
+        // Copy ALL existing props and only modify the necessary fields
+        "title": "Existing Title",
+        "description": "Existing Description",
+        "config": {},
+        "query": {
+          "sql": "SELECT ... WHERE column BETWEEN $startDate AND $endDate",
+          "params": {
+            "existingParam": "existing_value",
+            "startDate": "$filter.filterId.startDate",
+            "endDate": "$filter.filterId.endDate"
+          }
+        }
+      }
+    }
+  ],
+  "filterBindings": {
+    "startDate": "$filter.filterId.startDate",
+    "endDate": "$filter.filterId.endDate"
+  },
+  "reasoning": "Explanation of filter choice and how components were updated"
+}
+
+**CRITICAL:**
+- Return ONLY valid JSON (no markdown code blocks, no text before/after)
+- **RETURN COMPLETE PROPS**: Copy ALL existing props from each component, only modify what's needed for the filter
+- Do NOT omit existing props like title, description, config - include them unchanged
+- Only modify query.sql (add WHERE conditions) and query.params (add filter bindings)
+- For externalTool, only add filter params to the params object
+- Use consistent param naming across all components
+- Ensure SQL syntax is valid with the new filter conditions
+
+## Database Schema
 {{SCHEMA_DOC}}
 
-### Available External Tools
+## Available External Tools
 {{AVAILABLE_TOOLS}}
 
-### Available Components
-{{AVAILABLE_COMPONENTS}}`,
+## Available Filter Components
+{{AVAILABLE_COMPONENTS}}
+
+## Existing Dashboard Components
+{{EXISTING_COMPONENTS}}
+
+---
+
+## CONTEXT`,
         user: `{{USER_PROMPT}}`
       }
     };
@@ -1904,6 +2063,7 @@ var AuthVerifyRequestMessageSchema = import_zod3.z.object({
 });
 var UserPromptRequestPayloadSchema = import_zod3.z.object({
   prompt: import_zod3.z.string(),
+  userId: import_zod3.z.string().optional(),
   SA_RUNTIME: import_zod3.z.object({
     threadId: import_zod3.z.string(),
     uiBlockId: import_zod3.z.string()
@@ -1918,6 +2078,7 @@ var UserPromptRequestMessageSchema = import_zod3.z.object({
 });
 var UserPromptSuggestionsPayloadSchema = import_zod3.z.object({
   prompt: import_zod3.z.string(),
+  userId: import_zod3.z.string().optional(),
   limit: import_zod3.z.number().int().positive().default(5),
   similarityThreshold: import_zod3.z.number().min(0).max(1).default(0.4)
 });
@@ -1933,7 +2094,7 @@ var ComponentPropsSchema = import_zod3.z.object({
   description: import_zod3.z.string().optional(),
   config: import_zod3.z.record(import_zod3.z.unknown()).optional(),
   actions: import_zod3.z.array(import_zod3.z.any()).optional()
-});
+}).passthrough();
 var ComponentSchema = import_zod3.z.object({
   id: import_zod3.z.string(),
   name: import_zod3.z.string(),
@@ -2007,6 +2168,7 @@ var UILogsMessageSchema = import_zod3.z.object({
   payload: UILogsPayloadSchema
 });
 var ActionsRequestPayloadSchema = import_zod3.z.object({
+  userId: import_zod3.z.string().optional(),
   SA_RUNTIME: import_zod3.z.object({
     threadId: import_zod3.z.string(),
     uiBlockId: import_zod3.z.string()
@@ -2207,10 +2369,15 @@ var KbNodesRequestMessageSchema = import_zod3.z.object({
 });
 var DashCompRequestPayloadSchema = import_zod3.z.object({
   prompt: import_zod3.z.string(),
+  userId: import_zod3.z.string().optional(),
   SA_RUNTIME: import_zod3.z.object({
     threadId: import_zod3.z.string().optional(),
     uiBlockId: import_zod3.z.string().optional()
-  }).optional()
+  }).optional(),
+  /** Existing components in the dashboard (for update/filter operations) */
+  existingComponents: import_zod3.z.array(ComponentSchema).optional(),
+  /** Request type: create (new component), update (modify existing), filter (create filter + update components) */
+  req_type: import_zod3.z.enum(["create", "update", "filter"]).optional()
 });
 var DashCompRequestMessageSchema = import_zod3.z.object({
   id: import_zod3.z.string(),
@@ -3458,9 +3625,9 @@ var PRICING = {
   "gpt-4": { input: 30, output: 60 },
   "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
   // Google Gemini (December 2025)
-  "gemini-3-pro": { input: 2, output: 8 },
+  "gemini-3-pro-preview": { input: 2, output: 12 },
   // New Gemini 3
-  "gemini-2.5-pro": { input: 1.25, output: 10 },
+  "gemini-3-flash-preview": { input: 0.5, output: 3 },
   // For prompts ≤200K tokens, 2x for >200K
   "gemini-2.5-flash": { input: 0.15, output: 0.6 },
   // Standard mode (thinking disabled: $0.60, thinking enabled: $3.50)
@@ -4645,6 +4812,7 @@ var LLM = class {
     }
   }
   static async _geminiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations) {
+    const methodStartTime = Date.now();
     const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
     const genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
     const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
@@ -4673,11 +4841,18 @@ var LLM = class {
     let iterations = 0;
     let finalText = "";
     let currentUserMessage = messages.user;
+    let totalToolCalls = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
     while (iterations < maxIterations) {
       iterations++;
+      const iterationStartTime = Date.now();
+      const requestId = llmUsageLogger.generateRequestId();
       const result = await chat.sendMessageStream(currentUserMessage);
       let responseText = "";
       const functionCalls = [];
+      let inputTokens = 0;
+      let outputTokens = 0;
       for await (const chunk of result.stream) {
         const candidate = chunk.candidates?.[0];
         if (!candidate) continue;
@@ -4694,7 +4869,37 @@ var LLM = class {
             });
           }
         }
+        if (chunk.usageMetadata) {
+          inputTokens = chunk.usageMetadata.promptTokenCount || 0;
+          outputTokens = chunk.usageMetadata.candidatesTokenCount || 0;
+        }
+      }
+      const iterationDuration = Date.now() - iterationStartTime;
+      const toolCallsInIteration = functionCalls.length;
+      totalToolCalls += toolCallsInIteration;
+      if (inputTokens === 0) {
+        const userMsg = typeof currentUserMessage === "string" ? currentUserMessage : JSON.stringify(currentUserMessage);
+        inputTokens = Math.ceil((systemPrompt.length + userMsg.length) / 4);
+      }
+      if (outputTokens === 0) {
+        outputTokens = Math.ceil(responseText.length / 4);
       }
+      totalInputTokens += inputTokens;
+      totalOutputTokens += outputTokens;
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId,
+        provider: "gemini",
+        model: modelName,
+        method: `streamWithTools[iter=${iterations}]`,
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, inputTokens, outputTokens),
+        durationMs: iterationDuration,
+        toolCalls: toolCallsInIteration,
+        success: true
+      });
       if (functionCalls.length === 0) {
         finalText = responseText;
         break;
@@ -4727,6 +4932,23 @@ var LLM = class {
       }));
       currentUserMessage = functionResponseParts;
     }
+    const totalDuration = Date.now() - methodStartTime;
+    if (iterations > 1) {
+      llmUsageLogger.log({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        requestId: llmUsageLogger.generateRequestId(),
+        provider: "gemini",
+        model: modelName,
+        method: `streamWithTools[TOTAL:${iterations}iters]`,
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens,
+        totalTokens: totalInputTokens + totalOutputTokens,
+        costUSD: llmUsageLogger.calculateCost(modelName, totalInputTokens, totalOutputTokens),
+        durationMs: totalDuration,
+        toolCalls: totalToolCalls,
+        success: true
+      });
+    }
     if (iterations >= maxIterations) {
       throw new Error(`Max iterations (${maxIterations}) reached in tool calling loop`);
     }
@@ -6781,10 +7003,10 @@ var GeminiLLM = class extends BaseLLM {
     super(config);
   }
   getDefaultModel() {
-    return "gemini/gemini-2.5-flash";
+    return "gemini/gemini-3-pro-preview";
   }
   getDefaultFastModel() {
-    return "gemini/gemini-2.0-flash-exp";
+    return "gemini/gemini-3-flash-preview";
   }
   getDefaultApiKey() {
     return process.env.GEMINI_API_KEY;
@@ -7298,7 +7520,7 @@ var CONTEXT_CONFIG = {
 };
 
 // src/handlers/user-prompt-request.ts
-var get_user_request = async (data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools, userId) => {
+var get_user_request = async (data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools) => {
   const errors = [];
   logger.debug("[USER_PROMPT_REQ] Parsing incoming message data");
   const parseResult = UserPromptRequestMessageSchema.safeParse(data);
@@ -7312,6 +7534,7 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
   const userPromptRequest = parseResult.data;
   const { id, payload } = userPromptRequest;
   const prompt = payload.prompt;
+  const userId = payload.userId;
   const SA_RUNTIME = payload.SA_RUNTIME;
   const wsId = userPromptRequest.from.id || "unknown";
   const promptContext = `User Prompt: ${prompt?.substring(0, 50)}${(prompt?.length || 0) > 50 ? "..." : ""}`;
@@ -7484,8 +7707,8 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     wsId
   };
 };
-async function handleUserPromptRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools, userId) {
-  const response = await get_user_request(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools, userId);
+async function handleUserPromptRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools) {
+  const response = await get_user_request(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools);
   sendDataResponse4(
     response.id || data.id,
     {
@@ -7517,11 +7740,11 @@ function sendDataResponse4(id, res, sendMessage, clientId) {
 
 // src/handlers/user-prompt-suggestions.ts
 init_logger();
-async function handleUserPromptSuggestions(data, components, sendMessage, collections, userId) {
+async function handleUserPromptSuggestions(data, components, sendMessage, collections) {
   try {
     const request = UserPromptSuggestionsMessageSchema.parse(data);
     const { id, payload, from } = request;
-    const { prompt, limit = 10 } = payload;
+    const { prompt, userId, limit = 10 } = payload;
     const wsId = from.id;
     logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Processing user prompt suggestions: ${prompt}`);
     if (!prompt || prompt.trim().length === 0) {
@@ -10161,34 +10384,108 @@ function sendResponse8(id, res, sendMessage, clientId) {
   sendMessage(response);
 }
 
-// src/handlers/dash-comp-request.ts
+// src/dashComp/index.ts
 init_logger();
-init_prompt_loader();
-async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, _collections, tools) {
-  const errors = [];
-  let availableComponentsText = "No components available";
-  if (components && components.length > 0) {
-    availableComponentsText = components.map((comp, idx) => {
-      const keywords = comp.keywords ? comp.keywords.join(", ") : "";
-      const propsPreview = comp.props ? JSON.stringify(comp.props, null, 2) : "No props";
-      return `${idx + 1}. ID: ${comp.id}
+
+// src/dashComp/types.ts
+var DEFAULT_DASH_COMP_MODELS = {
+  anthropic: "anthropic/claude-haiku-4-5-20251001",
+  gemini: "gemini/gemini-3-flash-preview",
+  openai: "openai/gpt-4o-mini",
+  groq: "groq/llama-3.3-70b-versatile"
+};
+
+// src/dashComp/utils.ts
+function getApiKeyAndModel(anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, dashCompModels) {
+  const providers = llmProviders || ["anthropic", "gemini", "openai", "groq"];
+  let apiKey;
+  let model;
+  if (dashCompModels?.model) {
+    model = dashCompModels.model;
+    const modelProvider = model.split("/")[0];
+    if (modelProvider === "anthropic") apiKey = anthropicApiKey;
+    else if (modelProvider === "gemini") apiKey = geminiApiKey;
+    else if (modelProvider === "openai") apiKey = openaiApiKey;
+    else if (modelProvider === "groq") apiKey = groqApiKey;
+  } else {
+    for (const provider of providers) {
+      if (provider === "anthropic" && anthropicApiKey) {
+        apiKey = anthropicApiKey;
+        model = DEFAULT_DASH_COMP_MODELS.anthropic;
+        break;
+      } else if (provider === "gemini" && geminiApiKey) {
+        apiKey = geminiApiKey;
+        model = DEFAULT_DASH_COMP_MODELS.gemini;
+        break;
+      } else if (provider === "openai" && openaiApiKey) {
+        apiKey = openaiApiKey;
+        model = DEFAULT_DASH_COMP_MODELS.openai;
+        break;
+      } else if (provider === "groq" && groqApiKey) {
+        apiKey = groqApiKey;
+        model = DEFAULT_DASH_COMP_MODELS.groq;
+        break;
+      }
+    }
+  }
+  return { apiKey, model };
+}
+function formatComponentsForPrompt(components) {
+  if (!components || components.length === 0) {
+    return "No components available";
+  }
+  return components.map((comp, idx) => {
+    const keywords = comp.keywords ? comp.keywords.join(", ") : "";
+    const propsPreview = comp.props ? JSON.stringify(comp.props, null, 2) : "No props";
+    return `${idx + 1}. ID: ${comp.id}
    Name: ${comp.name}
    Type: ${comp.type}
    Description: ${comp.description || "No description"}
    Keywords: ${keywords}
    Props Structure: ${propsPreview}`;
-    }).join("\n\n");
+  }).join("\n\n");
+}
+function formatToolsForPrompt(tools) {
+  if (!tools || tools.length === 0) {
+    return "No external tools available.";
   }
-  let availableToolsText = "No external tools available.";
-  if (tools && tools.length > 0) {
-    availableToolsText = tools.map((tool, idx) => {
-      const paramsStr = Object.entries(tool.params || {}).map(([key, type]) => `${key}: ${type}`).join(", ");
-      return `${idx + 1}. ID: ${tool.id}
+  return tools.map((tool, idx) => {
+    const paramsStr = Object.entries(tool.params || {}).map(([key, type]) => `${key}: ${type}`).join(", ");
+    return `${idx + 1}. ID: ${tool.id}
    Name: ${tool.name}
    Description: ${tool.description}
    Parameters: { ${paramsStr} }`;
-    }).join("\n\n");
+  }).join("\n\n");
+}
+function formatExistingComponentsForPrompt(existingComponents) {
+  if (!existingComponents || existingComponents.length === 0) {
+    return "No existing components in dashboard";
   }
+  return JSON.stringify(existingComponents, null, 2);
+}
+function sendDashCompResponse(id, res, sendMessage, clientId) {
+  const response = {
+    id,
+    type: "DASH_COMP_RES",
+    from: { type: "data-agent" },
+    to: {
+      type: "runtime",
+      id: clientId
+    },
+    payload: {
+      ...res
+    }
+  };
+  sendMessage(response);
+}
+
+// src/dashComp/pick-component.ts
+init_logger();
+init_prompt_loader();
+async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, _collections, tools, dashCompModels) {
+  const errors = [];
+  const availableComponentsText = formatComponentsForPrompt(components);
+  const availableToolsText = formatToolsForPrompt(tools);
   try {
     const schemaDoc = schema.generateSchemaDocumentation();
     const databaseRules = await promptLoader.loadDatabaseRules();
@@ -10200,29 +10497,15 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
       AVAILABLE_TOOLS: availableToolsText
     });
     logger.debug("[DASH_COMP_REQ] Loaded dash-comp-picker prompts with schema and tools");
-    const providers = llmProviders || ["anthropic", "gemini", "openai", "groq"];
-    let apiKey;
-    let model = "anthropic/claude-sonnet-4-5-20250929";
-    for (const provider of providers) {
-      if (provider === "anthropic" && anthropicApiKey) {
-        apiKey = anthropicApiKey;
-        model = "anthropic/claude-sonnet-4-5-20250929";
-        break;
-      } else if (provider === "openai" && openaiApiKey) {
-        apiKey = openaiApiKey;
-        model = "openai/gpt-4o-mini";
-        break;
-      } else if (provider === "gemini" && geminiApiKey) {
-        apiKey = geminiApiKey;
-        model = "google/gemini-2.0-flash-001";
-        break;
-      } else if (provider === "groq" && groqApiKey) {
-        apiKey = groqApiKey;
-        model = "groq/llama-3.3-70b-versatile";
-        break;
-      }
-    }
-    if (!apiKey) {
+    const { apiKey, model } = getApiKeyAndModel(
+      anthropicApiKey,
+      groqApiKey,
+      geminiApiKey,
+      openaiApiKey,
+      llmProviders,
+      dashCompModels
+    );
+    if (!apiKey || !model) {
       errors.push("No API key available for any LLM provider");
       return { success: false, errors };
     }
@@ -10245,11 +10528,21 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
     logger.file("[DASH_COMP_REQ] LLM response:", JSON.stringify(result, null, 2));
     if (!result.componentId || !result.props) {
       errors.push("Invalid LLM response: missing componentId or props");
+      userPromptErrorLogger.logError("DASH_COMP_REQ", "Invalid LLM response structure", {
+        prompt,
+        result,
+        missingFields: { componentId: !result.componentId, props: !result.props }
+      });
       return { success: false, errors };
     }
     const originalComponent = components.find((c) => c.id === result.componentId);
     if (!originalComponent) {
       errors.push(`Component ${result.componentId} not found in available components`);
+      userPromptErrorLogger.logError("DASH_COMP_REQ", "Component not found", {
+        prompt,
+        componentId: result.componentId,
+        availableComponentIds: components.map((c) => c.id)
+      });
       return { success: false, errors };
     }
     const finalComponent = {
@@ -10271,18 +10564,102 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
       data: {
         component: finalComponent,
         reasoning: result.reasoning || "Component selected based on user prompt",
-        dataSource: result.props.query ? "database" : result.props.externalTool ? "external_tool" : "none"
+        dataSource: result.props.query ? "database" : result.props.externalTool ? "external_tool" : "none",
+        isUpdate: result.isUpdate || false
       },
       errors: []
     };
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
     logger.error(`[DASH_COMP_REQ] Error picking component: ${errorMsg}`);
+    userPromptErrorLogger.logError("DASH_COMP_REQ", error instanceof Error ? error : new Error(errorMsg), {
+      prompt,
+      componentsCount: components.length,
+      toolsCount: tools?.length || 0
+    });
+    errors.push(errorMsg);
+    return { success: false, errors };
+  }
+}
+
+// src/dashComp/create-filter.ts
+init_logger();
+init_prompt_loader();
+async function createFilterWithLLM(prompt, components, existingComponents, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, tools, dashCompModels) {
+  const errors = [];
+  try {
+    const filterComponents = components.filter((c) => c.type.startsWith("Filter"));
+    if (filterComponents.length === 0) {
+      errors.push("No filter components available");
+      return { success: false, errors };
+    }
+    logger.debug(`[DASH_COMP_REQ:FILTER] Found ${filterComponents.length} filter components`);
+    const schemaDoc = schema.generateSchemaDocumentation();
+    const databaseRules = await promptLoader.loadDatabaseRules();
+    const prompts = await promptLoader.loadPrompts("dash-filter-picker", {
+      USER_PROMPT: prompt,
+      AVAILABLE_COMPONENTS: formatComponentsForPrompt(filterComponents),
+      EXISTING_COMPONENTS: formatExistingComponentsForPrompt(existingComponents),
+      SCHEMA_DOC: schemaDoc || "No database schema available",
+      DATABASE_RULES: databaseRules,
+      AVAILABLE_TOOLS: formatToolsForPrompt(tools)
+    });
+    logger.debug("[DASH_COMP_REQ:FILTER] Loaded dash-filter-picker prompts");
+    const { apiKey, model } = getApiKeyAndModel(
+      anthropicApiKey,
+      groqApiKey,
+      geminiApiKey,
+      openaiApiKey,
+      llmProviders,
+      dashCompModels
+    );
+    if (!apiKey || !model) {
+      errors.push("No API key available for any LLM provider");
+      return { success: false, errors };
+    }
+    logger.info(`[DASH_COMP_REQ:FILTER] Using model: ${model}`);
+    const result = await LLM.stream(
+      { sys: prompts.system, user: prompts.user },
+      { model, maxTokens: 16384, temperature: 0.2, apiKey },
+      true
+    );
+    logger.debug("[DASH_COMP_REQ:FILTER] LLM response received");
+    logger.file("[DASH_COMP_REQ:FILTER] LLM response:", JSON.stringify(result, null, 2));
+    if (!result.filterComponent) {
+      errors.push("Invalid LLM response: missing filterComponent");
+      userPromptErrorLogger.logError("DASH_COMP_REQ:FILTER", "Invalid LLM response structure", {
+        prompt,
+        result,
+        missingFields: { filterComponent: !result.filterComponent }
+      });
+      return { success: false, errors };
+    }
+    logger.info(`[DASH_COMP_REQ:FILTER] Successfully created filter: ${result.filterComponent.componentType}`);
+    logger.info(`[DASH_COMP_REQ:FILTER] Updated ${result.updatedComponents?.length || 0} components`);
+    return {
+      success: true,
+      data: {
+        filterComponent: result.filterComponent,
+        updatedComponents: result.updatedComponents || [],
+        filterBindings: result.filterBindings || {},
+        reasoning: result.reasoning || "Filter created based on user prompt"
+      },
+      errors: []
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.error(`[DASH_COMP_REQ:FILTER] Error creating filter: ${errorMsg}`);
+    userPromptErrorLogger.logError("DASH_COMP_REQ:FILTER", error instanceof Error ? error : new Error(errorMsg), {
+      prompt,
+      existingComponentsCount: existingComponents.length
+    });
     errors.push(errorMsg);
     return { success: false, errors };
   }
 }
-var processDashCompRequest = async (data, components, _sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, tools) => {
+
+// src/dashComp/index.ts
+var processDashCompRequest = async (data, components, _sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, tools, dashCompModels) => {
   const errors = [];
   logger.debug("[DASH_COMP_REQ] Parsing incoming message data");
   const parseResult = DashCompRequestMessageSchema.safeParse(data);
@@ -10296,15 +10673,25 @@ var processDashCompRequest = async (data, components, _sendMessage, anthropicApi
   const dashCompRequest = parseResult.data;
   const { id, payload } = dashCompRequest;
   const prompt = payload.prompt;
+  const reqType = payload.req_type || "create";
+  const existingComponents = payload.existingComponents || [];
   const wsId = dashCompRequest.from.id || "unknown";
+  const promptContext = `DASH_COMP[${reqType}]: ${prompt?.substring(0, 50)}${(prompt?.length || 0) > 50 ? "..." : ""}`;
+  llmUsageLogger.resetLogFile(promptContext);
   if (!prompt) {
     errors.push("Prompt is required");
   }
+  if (reqType === "filter" && existingComponents.length === 0) {
+    errors.push("Filter request requires existingComponents");
+  }
   if (errors.length > 0) {
     return { success: false, errors, id, wsId };
   }
-  logger.info(`[DASH_COMP_REQ] Processing request for prompt: "${prompt.substring(0, 50)}..."`);
+  logger.info(`[DASH_COMP_REQ] Processing ${reqType} request for prompt: "${prompt.substring(0, 50)}..."`);
   logger.info(`[DASH_COMP_REQ] Available: ${components?.length || 0} components, ${tools?.length || 0} tools`);
+  if (existingComponents.length > 0) {
+    logger.info(`[DASH_COMP_REQ] Existing components in dashboard: ${existingComponents.length}`);
+  }
   if (!components || components.length === 0) {
     logger.warn("[DASH_COMP_REQ] No components available");
     return {
@@ -10314,17 +10701,35 @@ var processDashCompRequest = async (data, components, _sendMessage, anthropicApi
       wsId
     };
   }
-  const llmResponse = await pickComponentWithLLM(
-    prompt,
-    components,
-    anthropicApiKey,
-    groqApiKey,
-    geminiApiKey,
-    openaiApiKey,
-    llmProviders,
-    collections,
-    tools
-  );
+  let llmResponse;
+  if (reqType === "filter") {
+    llmResponse = await createFilterWithLLM(
+      prompt,
+      components,
+      existingComponents,
+      anthropicApiKey,
+      groqApiKey,
+      geminiApiKey,
+      openaiApiKey,
+      llmProviders,
+      tools,
+      dashCompModels
+    );
+  } else {
+    llmResponse = await pickComponentWithLLM(
+      prompt,
+      components,
+      anthropicApiKey,
+      groqApiKey,
+      geminiApiKey,
+      openaiApiKey,
+      llmProviders,
+      collections,
+      tools,
+      dashCompModels
+    );
+  }
+  llmUsageLogger.logSessionSummary(`DASH_COMP[${reqType}]: ${prompt?.substring(0, 30)}`);
   return {
     success: llmResponse.success,
     data: llmResponse.data,
@@ -10333,7 +10738,7 @@ var processDashCompRequest = async (data, components, _sendMessage, anthropicApi
     wsId
   };
 };
-async function handleDashCompRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, tools) {
+async function handleDashCompRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, tools, dashCompModels) {
   const response = await processDashCompRequest(
     data,
     components,
@@ -10344,7 +10749,8 @@ async function handleDashCompRequest(data, components, sendMessage, anthropicApi
     openaiApiKey,
     llmProviders,
     collections,
-    tools
+    tools,
+    dashCompModels
   );
   sendDashCompResponse(
     response.id || data.id,
@@ -10356,22 +10762,7 @@ async function handleDashCompRequest(data, components, sendMessage, anthropicApi
     sendMessage,
     response.wsId || data.from?.id
   );
-}
-function sendDashCompResponse(id, res, sendMessage, clientId) {
-  const response = {
-    id,
-    type: "DASH_COMP_RES",
-    from: { type: "data-agent" },
-    to: {
-      type: "runtime",
-      id: clientId
-    },
-    payload: {
-      ...res
-    }
-  };
-  sendMessage(response);
-  logger.info(`[DASH_COMP_REQ] Response sent to client ${clientId}`);
+  logger.info(`[DASH_COMP_REQ] Response sent to client ${response.wsId || data.from?.id}`);
 }
 
 // src/auth/user-manager.ts
@@ -11219,7 +11610,6 @@ var SuperatomSDK = class {
     }
     this.apiKey = config.apiKey;
     this.projectId = config.projectId;
-    this.userId = config.userId || "anonymous";
     this.type = config.type || "data-agent";
     this.bundleDir = config.bundleDir;
     this.url = config.url || process.env.SA_WEBSOCKET_URL || DEFAULT_WS_URL;
@@ -11321,7 +11711,6 @@ var SuperatomSDK = class {
           url.searchParams.set("apiKey", this.apiKey);
         }
         url.searchParams.set("projectId", this.projectId);
-        url.searchParams.set("userId", this.userId);
         url.searchParams.set("type", this.type);
         logger.info(`Connecting to WebSocket: ${url.toString()}`);
         this.ws = createWebSocket(url.toString());
@@ -11382,7 +11771,7 @@ var SuperatomSDK = class {
           });
           break;
         case "USER_PROMPT_REQ":
-          handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders, this.collections, this.tools, this.userId).catch((error) => {
+          handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders, this.collections, this.tools).catch((error) => {
             logger.error("Failed to handle user prompt request:", error);
           });
           break;
@@ -11392,7 +11781,7 @@ var SuperatomSDK = class {
           });
           break;
         case "USER_PROMPT_SUGGESTIONS_REQ":
-          handleUserPromptSuggestions(parsed, this.components, (msg) => this.send(msg), this.collections, this.userId).catch((error) => {
+          handleUserPromptSuggestions(parsed, this.components, (msg) => this.send(msg), this.collections).catch((error) => {
             logger.error("Failed to handle user prompt suggestions request:", error);
           });
           break;