@superatomai/sdk-node 0.0.42 → 0.0.44

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,142 @@ 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
+2. **Update existing components** with dynamic title/description interpolation if needed
+3. **Preserve all existing props** - the filter system handles param merging at runtime
+
+## How The Filter System Works
+
+1. Filter component has a \`filters\` array with preset options, each containing \`label\`, \`value\`, and \`params\`
+2. When user selects a filter option, those \`params\` are broadcast to all listening components
+3. Components automatically merge filter params with their existing params (filter values override defaults)
+4. Component titles/descriptions can use \`{%filterKeyLabel%}\` syntax for dynamic text
+
+## Filter Component Structure
+
+The filter uses DynamicFilterDropdown with:
+- **filterKey**: Identifier for label interpolation (e.g., "period", "name", "category")
+- **filters**: Array of options with label, value, params, and optionally isDefault
+- **defaultValue**: The value of the initially selected option
+
+## Dynamic Title/Description Interpolation
+
+Use \`{%filterKeyLabel%}\` syntax for dynamic text:
+- filterKey "period" \u2192 use \`{%periodLabel%}\` in titles/descriptions
+- filterKey "name" \u2192 use \`{%nameLabel%}\` in titles/descriptions
+- Example: \`"{%periodLabel%} Revenue"\` becomes "Q3 2025 Revenue" when user selects "Q3 2025"
+
+**CRITICAL Template Syntax:**
+- Use \`{%keyLabel%}\` format (percent signs, key + "Label" suffix)
+- Do NOT use \`{{...}}\` or \`$...\` syntax - these don't work
+
+## Updating Existing Components
+
+**IMPORTANT - Parameter Handling:**
+- Do NOT change existing parameter values to placeholders
+- Keep all existing/default parameter values as they are
+- The filter system MERGES params at runtime: filter params override component defaults
+
+**What to modify in existing components:**
+- Modify \`title\` for \`{%filterKeyLabel%}\` interpolation (only if title exists)
+- Modify \`description\` for interpolation (only if description exists)
+- Modify other props only if specifically needed for the filter to function
+- Copy ALL other props exactly as provided
+
+### Database Query Rules
+{{DATABASE_RULES}}
+
+## Output Format
+
+You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
+
+{
+  "filterComponent": {
+    "id": "filter-<descriptive-id>",
+    "name": "DynamicFilterDropdown",
+    "type": "FilterDropdown",
+    "props": {
+      "title": "<Filter display title>",
+      "filterKey": "<key_for_interpolation>",
+      "defaultValue": "<default_option_value>",
+      "filters": [
+        {
+          "label": "<Display label for option>",
+          "value": "<unique_option_value>",
+          "params": { "<param_key>": "<actual_value>", "...": "..." },
+          "isDefault": true
+        }
+      ]
+    }
+  },
+  "updatedComponents": [
+    {
+      "id": "<existing_component_id>",
+      "name": "<existing_component_name>",
+      "type": "<existing_type>",
+      "props": {
+        "...all existing props preserved...",
+        "title": "{%<filterKey>Label%} <rest of title>",
+        "description": "<updated if needed>"
+      }
+    }
+  ],
+  "filterBindings": {
+    "<param_key>": "Describes which filter param this binds to"
+  },
+  "reasoning": "Explanation of filter choice and what params it provides"
+}
+
+**CRITICAL RULES:**
+1. Return ONLY valid JSON (no markdown code blocks)
+2. **COPY ALL existing props** - modify title/description for interpolation only if they exist
+3. **DO NOT change parameter values** - keep existing defaults, filter merges at runtime
+4. Use \`{%filterKeyLabel%}\` for dynamic text (NOT \`{{...}}\` or \`$...\`)
+5. Filter \`params\` must have ACTUAL values (real dates, strings), not placeholders
+6. Each filter option needs: label, value, params (and optionally isDefault)
 
-### Database Schema
+## 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 +2040,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 +2055,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)
 });
@@ -2007,6 +2145,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 +2346,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(),
@@ -7353,7 +7497,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);
@@ -7367,6 +7511,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 ? "..." : ""}`;
@@ -7539,8 +7684,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,
     {
@@ -7572,11 +7717,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) {
@@ -10216,40 +10361,108 @@ function sendResponse8(id, res, sendMessage, clientId) {
   sendMessage(response);
 }
 
-// src/handlers/dash-comp-request.ts
+// src/dashComp/index.ts
 init_logger();
-init_prompt_loader();
+
+// 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"
 };
-async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, _collections, tools, dashCompModels) {
-  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/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();
@@ -10261,38 +10474,14 @@ 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;
-    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;
-      logger.info(`[DASH_COMP_REQ] Using configured model: ${model}`);
-    } 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;
-        }
-      }
-    }
+    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 };
@@ -10323,13 +10512,13 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
       });
       return { success: false, errors };
     }
-    const originalComponent = components.find((c) => c.id === result.componentId);
+    const originalComponent = components.find((c) => c.name === result.componentName);
     if (!originalComponent) {
-      errors.push(`Component ${result.componentId} not found in available components`);
+      errors.push(`Component ${result.componentName} not found in available components`);
       userPromptErrorLogger.logError("DASH_COMP_REQ", "Component not found", {
         prompt,
-        componentId: result.componentId,
-        availableComponentIds: components.map((c) => c.id)
+        componentName: result.componentName,
+        availableComponentNames: components.map((c) => c.name)
       });
       return { success: false, errors };
     }
@@ -10352,7 +10541,8 @@ 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: []
     };
@@ -10368,6 +10558,84 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
     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 };
+  }
+}
+
+// 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");
@@ -10382,17 +10650,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: ${prompt?.substring(0, 50)}${(prompt?.length || 0) > 50 ? "..." : ""}`;
+  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 {
@@ -10402,19 +10678,35 @@ var processDashCompRequest = async (data, components, _sendMessage, anthropicApi
       wsId
     };
   }
-  const llmResponse = await pickComponentWithLLM(
-    prompt,
-    components,
-    anthropicApiKey,
-    groqApiKey,
-    geminiApiKey,
-    openaiApiKey,
-    llmProviders,
-    collections,
-    tools,
-    dashCompModels
-  );
-  llmUsageLogger.logSessionSummary(`DASH_COMP: ${prompt?.substring(0, 30)}`);
+  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,
@@ -10447,22 +10739,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
@@ -11310,7 +11587,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;
@@ -11412,7 +11688,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());
@@ -11473,7 +11748,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;
@@ -11483,7 +11758,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;