@superatomai/sdk-node 0.0.52 → 0.0.54

package/dist/index.js

@@ -31,13 +31,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/utils/logger.ts
-var import_fs, PREFIX, LOGSTREAM, LOG_LEVEL_PRIORITY, MESSAGE_LEVEL_PRIORITY, Logger, logger;
+var import_fs, PREFIX, LOG_FILE_PATH, LOGSTREAM, LOG_LEVEL_PRIORITY, MESSAGE_LEVEL_PRIORITY, Logger, logger;
 var init_logger = __esm({
   "src/utils/logger.ts"() {
     "use strict";
     import_fs = __toESM(require("fs"));
     PREFIX = "[SuperatomSDK]";
-    LOGSTREAM = import_fs.default.createWriteStream("superatom-sdk.log", { flags: "a" });
+    LOG_FILE_PATH = "superatom-sdk.log";
+    LOGSTREAM = import_fs.default.createWriteStream(LOG_FILE_PATH, { flags: "a" });
     LOG_LEVEL_PRIORITY = {
       errors: 0,
       warnings: 1,
@@ -121,9 +122,58 @@ var init_logger = __esm({
           console.log(PREFIX, "[DEBUG]", ...args);
         }
       }
+      /**
+       * Write to log file
+       */
       file(...args) {
         LOGSTREAM.write(args.join(" ") + "\n");
       }
+      /**
+       * Clear the log file (call at start of new user request)
+       */
+      clearFile() {
+        LOGSTREAM.end();
+        LOGSTREAM = import_fs.default.createWriteStream(LOG_FILE_PATH, { flags: "w" });
+        LOGSTREAM.write(`
+${"=".repeat(80)}
+`);
+        LOGSTREAM.write(`NEW REQUEST - ${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+        LOGSTREAM.write(`${"=".repeat(80)}
+
+`);
+      }
+      /**
+       * Log LLM method prompts with clear labeling
+       */
+      logLLMPrompt(methodName, promptType, content) {
+        const header = `
+${"#".repeat(80)}
+[LLM METHOD: ${methodName}] - ${promptType.toUpperCase()} PROMPT
+${"#".repeat(80)}
+`;
+        LOGSTREAM.write(header);
+        let contentStr;
+        if (typeof content === "string") {
+          contentStr = content;
+        } else if (Array.isArray(content)) {
+          contentStr = content.map((item) => {
+            if (typeof item === "string") return item;
+            if (item.text) return item.text;
+            if (item.content) return typeof item.content === "string" ? item.content : JSON.stringify(item.content, null, 2);
+            return JSON.stringify(item, null, 2);
+          }).join("\n\n");
+        } else if (typeof content === "object") {
+          contentStr = JSON.stringify(content, null, 2);
+        } else {
+          contentStr = String(content);
+        }
+        LOGSTREAM.write(contentStr);
+        LOGSTREAM.write(`
+${"#".repeat(80)}
+
+`);
+      }
     };
     logger = new Logger();
   }
@@ -1041,8 +1091,20 @@ If adaptation is not possible or would fundamentally change the component:
 
 Analyze the user's request and:
 1. **Select the most appropriate component** from the available components list
-2. **Determine the data source**: Database query OR External tool (ERP)
-3. **Generate complete props** for the selected component including the data retrieval/modification method
+2. **Determine the data source**: Database query OR External tool
+3. **Generate complete props** for the selected component
+
+## Available External Tools
+
+The following external tools are available:
+
+{{AVAILABLE_TOOLS}}
+
+When a tool is needed to complete the user's request:
+1. **Analyze the request** to determine which tool is needed
+2. **Extract parameters** from the user's question
+3. **Execute the tool** by calling it with the extracted parameters
+4. **Use the results** to configure the component (field names for axes, columns, etc.)
 
 ## Component Selection Rules
 
@@ -1198,7 +1260,20 @@ You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 
 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
+3. **Set default values in component externalTool.params** that match the filter's default option
+4. **Preserve all existing props** - the filter system handles param merging at runtime
+
+## Available External Tools
+
+The following external tools are available:
+
+{{AVAILABLE_TOOLS}}
+
+When a tool is needed to complete the user's request:
+1. **Analyze the request** to determine which tool is needed
+2. **Extract parameters** from the user's question
+3. **Execute the tool** by calling it with the extracted parameters
+4. **Use the results** to configure the filter and components properly
 
 ## How The Filter System Works
 
@@ -1228,16 +1303,20 @@ Use \`{%filterKeyLabel%}\` syntax for dynamic text:
 ## 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
+- Component's \`externalTool.params\` should have DEFAULT values matching the filter's default option
+- This ensures the component shows correct data on initial load before user changes the filter
 
 **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
+- Set \`externalTool.params\` default values to match filter's default option params
 - Copy ALL other props exactly as provided
 
+**Example - Setting default params:**
+If filter has default option with params: \`{ startDate: "2025-01-01", endDate: "2025-01-31" }\`
+Then component's externalTool should have: \`{ params: { startDate: "2025-01-01", endDate: "2025-01-31" } }\`
+
 ### Database Query Rules
 {{DATABASE_RULES}}
 
@@ -1285,10 +1364,11 @@ You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
 **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
+3. **Set externalTool.params defaults** to match the filter's default option params
 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)
+7. Component default params MUST match filter default - this ensures correct initial data load
 
 ## Database Schema
 {{SCHEMA_DOC}}
@@ -2359,6 +2439,57 @@ var KbNodesRequestMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("KB_NODES"),
   payload: KbNodesRequestPayloadSchema
 });
+var MenusQueryFiltersSchema = import_zod3.z.object({
+  parentId: import_zod3.z.number().nullable().optional(),
+  isActive: import_zod3.z.boolean().optional()
+});
+var MenusRequestPayloadSchema = import_zod3.z.object({
+  operation: import_zod3.z.enum([
+    "create",
+    "update",
+    "delete",
+    "getAll",
+    "getOne",
+    "getRootMenus",
+    "getChildMenus",
+    "getHierarchy",
+    "query",
+    "reorder"
+  ]),
+  data: import_zod3.z.object({
+    id: import_zod3.z.number().optional(),
+    name: import_zod3.z.string().optional(),
+    componentName: import_zod3.z.string().optional(),
+    icon: import_zod3.z.string().optional(),
+    userMessage: import_zod3.z.string().optional(),
+    parentId: import_zod3.z.number().nullable().optional(),
+    sortOrder: import_zod3.z.number().optional(),
+    props: import_zod3.z.record(import_zod3.z.unknown()).optional(),
+    isActive: import_zod3.z.boolean().optional(),
+    // Query operation fields
+    filters: MenusQueryFiltersSchema.optional(),
+    limit: import_zod3.z.number().optional(),
+    sort: import_zod3.z.enum(["ASC", "DESC"]).optional(),
+    // Reorder operation fields
+    items: import_zod3.z.array(import_zod3.z.object({
+      id: import_zod3.z.number(),
+      sortOrder: import_zod3.z.number()
+    })).optional()
+  }).optional()
+});
+var MenusRequestMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  from: MessageParticipantSchema,
+  type: import_zod3.z.literal("MENUS"),
+  payload: MenusRequestPayloadSchema
+});
+var MenusResponsePayloadSchema = import_zod3.z.object({
+  success: import_zod3.z.boolean(),
+  error: import_zod3.z.string().optional(),
+  data: import_zod3.z.any().optional(),
+  count: import_zod3.z.number().optional(),
+  message: import_zod3.z.string().optional()
+});
 var DashCompRequestPayloadSchema = import_zod3.z.object({
   prompt: import_zod3.z.string(),
   userId: import_zod3.z.string().optional(),
@@ -5719,35 +5850,35 @@ ${JSON.stringify(tool.requiredFields || [], null, 2)}`;
       let executedToolsText = "No external tools were executed for data fetching.";
       if (executedTools && executedTools.length > 0) {
         logger.info(`[${this.getProviderName()}] Passing ${executedTools.length} executed tools to component matching`);
-        executedToolsText = "The following external tools were executed to fetch data.\n**IMPORTANT: For components displaying this data, use externalTool prop instead of query.**\n**IMPORTANT: Use the outputSchema fields to set correct config keys (xAxisKey, yAxisKey, valueKey, nameKey, etc.)**\n**IMPORTANT: Use the result data to populate deferred tool parameters when applicable.**\n\n" + executedTools.map((tool, idx) => {
+        executedToolsText = "The following external tools were executed to fetch data.\n**IMPORTANT: For components displaying this data, use externalTool prop instead of query.**\n**IMPORTANT: Use ONLY the field names listed in outputSchema for config keys.**\n\n" + executedTools.map((tool, idx) => {
           let outputSchemaText = "Not available";
+          let fieldNamesList = "";
           let recordCount = "unknown";
           if (tool.outputSchema) {
             const fields = tool.outputSchema.fields || [];
             recordCount = tool.result?._recordCount || (Array.isArray(tool.result) ? tool.result.length : "unknown");
+            const numericFields = fields.filter((f) => f.type === "number").map((f) => f.name);
+            const stringFields = fields.filter((f) => f.type === "string").map((f) => f.name);
+            fieldNamesList = `
+   \u{1F4CA} NUMERIC FIELDS (use for yAxisKey, valueKey, aggregationField): ${numericFields.join(", ") || "none"}
+   \u{1F4DD} STRING FIELDS (use for xAxisKey, groupBy, nameKey): ${stringFields.join(", ") || "none"}`;
             const fieldsText = fields.map(
-              (f) => `     - name: "${f.name}"  \u2190 USE THIS EXACT VALUE in config
-       type: ${f.type}
-       description: ${f.description}`
+              (f) => `     "${f.name}" (${f.type}): ${f.description}`
             ).join("\n");
             outputSchemaText = `${tool.outputSchema.description}
-   Fields (use the "name" value in your config):
+   Fields:
 ${fieldsText}`;
           }
           return `${idx + 1}. **${tool.name}**
-   toolId: "${tool.id}" (USE THIS EXACT VALUE for externalTool.toolId)
-   toolName: "${tool.name}" (USE THIS EXACT VALUE for externalTool.toolName)
-   parameters: ${JSON.stringify(tool.params || {})} (USE THESE for externalTool.parameters)
+   toolId: "${tool.id}"
+   toolName: "${tool.name}"
+   parameters: ${JSON.stringify(tool.params || {})}
    recordCount: ${recordCount} rows returned
-   outputSchema: ${outputSchemaText}
-   \u26A0\uFE0F DO NOT embed this tool's data in SQL - use externalTool prop OR query database tables`;
+   outputSchema: ${outputSchemaText}${fieldNamesList}`;
         }).join("\n\n");
       }
       const schemaDoc = schema.generateSchemaDocumentation();
       const databaseRules = await promptLoader.loadDatabaseRules();
-      logger.file("\n=============================\nText analysis response:", analysisContent);
-      logger.file("\n=============================\nDeferred tools:", deferredToolsText);
-      logger.file("\n=============================\nExecuted tools:", executedToolsText);
       const prompts = await promptLoader.loadPrompts("match-text-components", {
         ANALYSIS_CONTENT: analysisContent,
         AVAILABLE_COMPONENTS: availableComponentsText,
@@ -5757,7 +5888,13 @@ ${fieldsText}`;
         EXECUTED_TOOLS: executedToolsText
       });
       logger.debug(`[${this.getProviderName()}] Loaded match-text-components prompts`);
-      logger.file("\n=============================\nmatch text components system prompt:", prompts.system);
+      const systemPromptStr = Array.isArray(prompts.system) ? prompts.system.join("\n") : prompts.system;
+      logger.logLLMPrompt("matchComponentsFromAnalysis", "system", systemPromptStr);
+      logger.logLLMPrompt("matchComponentsFromAnalysis", "user", `Text Analysis:
+${analysisContent}
+
+Executed Tools:
+${executedToolsText}`);
       logCollector?.info("Matching components from text response...");
       let fullResponseText = "";
       let answerComponentExtracted = false;
@@ -5894,40 +6031,41 @@ ${fieldsText}`;
             if (executedTool?.outputSchema?.fields && cleanedProps.config) {
               const validFieldNames = executedTool.outputSchema.fields.map((f) => f.name);
               const validFieldNamesLower = validFieldNames.map((n) => n.toLowerCase());
-              const findMatchingField = (fieldName) => {
+              const findMatchingField = (fieldName, configKey) => {
                 if (!fieldName) return null;
                 const lowerField = fieldName.toLowerCase();
                 const exactIdx = validFieldNamesLower.indexOf(lowerField);
                 if (exactIdx !== -1) return validFieldNames[exactIdx];
-                const partialMatches = [];
-                for (let i = 0; i < validFieldNames.length; i++) {
-                  const validName = validFieldNames[i];
-                  const validLower = validFieldNamesLower[i];
-                  if (validLower.endsWith(lowerField)) {
-                    const score = lowerField.length / validLower.length;
-                    partialMatches.push({ name: validName, score });
-                    continue;
-                  }
-                  if (lowerField.endsWith(validLower)) {
-                    const score = validLower.length / lowerField.length;
-                    partialMatches.push({ name: validName, score });
-                    continue;
-                  }
-                  if (validLower.endsWith(lowerField) || lowerField.length <= 5 && validLower.includes(lowerField)) {
-                    const score = lowerField.length <= 5 ? 0.3 : 0.5;
-                    partialMatches.push({ name: validName, score });
+                const containsMatches = validFieldNames.filter(
+                  (_, i) => validFieldNamesLower[i].includes(lowerField) || lowerField.includes(validFieldNamesLower[i])
+                );
+                if (containsMatches.length === 1) return containsMatches[0];
+                const fieldTypes = executedTool.outputSchema.fields.reduce((acc, f) => {
+                  acc[f.name] = f.type;
+                  return acc;
+                }, {});
+                const numericConfigKeys = ["yAxisKey", "valueKey", "aggregationField", "sizeKey"];
+                const stringConfigKeys = ["xAxisKey", "nameKey", "labelKey", "groupBy"];
+                if (numericConfigKeys.includes(configKey)) {
+                  const numericFields = validFieldNames.filter((f) => fieldTypes[f] === "number");
+                  const match = numericFields.find((f) => f.toLowerCase().includes(lowerField) || lowerField.includes(f.toLowerCase()));
+                  if (match) return match;
+                  if (numericFields.length > 0) {
+                    logger.warn(`[${this.getProviderName()}] No match for "${fieldName}", using first numeric field: ${numericFields[0]}`);
+                    return numericFields[0];
                   }
                 }
-                if (partialMatches.length > 0) {
-                  partialMatches.sort((a, b) => b.score - a.score);
-                  if (partialMatches.length === 1 || partialMatches[0].score > partialMatches[1].score + 0.1) {
-                    return partialMatches[0].name;
-                  } else {
-                    logger.warn(`[${this.getProviderName()}] Ambiguous field match for "${fieldName}": ${partialMatches.map((m) => m.name).join(", ")}`);
-                    return null;
+                if (stringConfigKeys.includes(configKey)) {
+                  const stringFields = validFieldNames.filter((f) => fieldTypes[f] === "string");
+                  const match = stringFields.find((f) => f.toLowerCase().includes(lowerField) || lowerField.includes(f.toLowerCase()));
+                  if (match) return match;
+                  if (stringFields.length > 0) {
+                    logger.warn(`[${this.getProviderName()}] No match for "${fieldName}", using first string field: ${stringFields[0]}`);
+                    return stringFields[0];
                   }
                 }
-                return null;
+                logger.warn(`[${this.getProviderName()}] No match for "${fieldName}", using first field: ${validFieldNames[0]}`);
+                return validFieldNames[0];
               };
               const configFieldsToValidate = [
                 "xAxisKey",
@@ -5946,12 +6084,10 @@ ${fieldsText}`;
                 const fieldValue = cleanedProps.config[configKey];
                 if (fieldValue && typeof fieldValue === "string") {
                   if (!validFieldNames.includes(fieldValue)) {
-                    const correctedField = findMatchingField(fieldValue);
+                    const correctedField = findMatchingField(fieldValue, configKey);
                     if (correctedField) {
                       logger.warn(`[${this.getProviderName()}] Correcting config.${configKey}: "${fieldValue}" \u2192 "${correctedField}"`);
                       cleanedProps.config[configKey] = correctedField;
-                    } else {
-                      logger.warn(`[${this.getProviderName()}] config.${configKey}="${fieldValue}" not found in outputSchema [${validFieldNames.join(", ")}]`);
                     }
                   }
                 }
@@ -5959,7 +6095,7 @@ ${fieldsText}`;
               if (Array.isArray(cleanedProps.config.series)) {
                 cleanedProps.config.series = cleanedProps.config.series.map((s) => {
                   if (s.dataKey && typeof s.dataKey === "string" && !validFieldNames.includes(s.dataKey)) {
-                    const correctedField = findMatchingField(s.dataKey);
+                    const correctedField = findMatchingField(s.dataKey, "yAxisKey");
                     if (correctedField) {
                       logger.warn(`[${this.getProviderName()}] Correcting series.dataKey: "${s.dataKey}" \u2192 "${correctedField}"`);
                       return { ...s, dataKey: correctedField };
@@ -6026,6 +6162,10 @@ ${fieldsText}`;
         AVAILABLE_TOOLS: availableToolsDoc,
         SCHEMA_DOC: schemaDoc || "No database schema available"
       });
+      const systemPrompt = Array.isArray(prompts.system) ? prompts.system.join("\n") : prompts.system;
+      const userPromptText = Array.isArray(prompts.user) ? prompts.user.join("\n") : prompts.user;
+      logger.logLLMPrompt("classifyQuestionCategory", "system", systemPrompt);
+      logger.logLLMPrompt("classifyQuestionCategory", "user", userPromptText);
       const result = await LLM.stream(
         {
           sys: prompts.system,
@@ -6213,7 +6353,6 @@ ${fieldsText}`;
         collections,
         topK: 1
       });
-      logger.file("\n=============================\nknowledge base context:", knowledgeBaseContext);
       const prompts = await promptLoader.loadPrompts("text-response", {
         USER_PROMPT: userPrompt,
         CONVERSATION_HISTORY: conversationHistory || "No previous conversation",
@@ -6222,8 +6361,10 @@ ${fieldsText}`;
         KNOWLEDGE_BASE_CONTEXT: knowledgeBaseContext || "No additional knowledge base context available.",
         AVAILABLE_EXTERNAL_TOOLS: availableToolsDoc
       });
-      logger.file("\n=============================\nsystem prompt:", prompts.system);
-      logger.file("\n=============================\nuser prompt:", prompts.user);
+      const sysPrompt = Array.isArray(prompts.system) ? prompts.system.join("\n") : prompts.system;
+      const usrPrompt = Array.isArray(prompts.user) ? prompts.user.join("\n") : prompts.user;
+      logger.logLLMPrompt("generateTextResponse", "system", sysPrompt);
+      logger.logLLMPrompt("generateTextResponse", "user", usrPrompt);
       logger.debug(`[${this.getProviderName()}] Loaded text-response prompts with schema`);
       logger.debug(`[${this.getProviderName()}] System prompt length: ${prompts.system.length}, User prompt length: ${prompts.user.length}`);
       logCollector?.info("Generating text response with query execution capability...");
@@ -6609,7 +6750,6 @@ ${errorMsg}
           data: {
             text: textResponse,
             // Include the streamed text showing all attempts
-            matchedComponents: [],
             actions: [],
             method: `${this.getProviderName()}-text-response-max-attempts`
           }
@@ -6707,7 +6847,6 @@ ${errorMsg}
         success: true,
         data: {
           text: textResponse,
-          matchedComponents,
           component: container_componet,
           actions,
           method: `${this.getProviderName()}-text-response`
@@ -6731,7 +6870,6 @@ ${errorMsg}
         errors,
         data: {
           text: "I apologize, but I encountered an error while processing your question. Please try rephrasing or ask something else.",
-          matchedComponents: [],
           actions: [],
           method: `${this.getProviderName()}-text-response-error`
         }
@@ -6755,6 +6893,8 @@ ${errorMsg}
     const startTime = Date.now();
     logger.info(`[${this.getProviderName()}] handleUserRequest called for user prompt: ${userPrompt}`);
     logCollector?.info(`Starting request processing with mode: ${responseMode}`);
+    logger.clearFile();
+    logger.logLLMPrompt("handleUserRequest", "user", `User Prompt: ${userPrompt}`);
     try {
       logger.info(`[${this.getProviderName()}] Step 1: Searching previous conversations...`);
       logCollector?.info("Step 1: Searching for similar previous conversations...");
@@ -6762,8 +6902,8 @@ ${errorMsg}
         userPrompt,
         collections,
         userId,
-        similarityThreshold: 0.75
-        // 75% threshold
+        similarityThreshold: 0.8
+        // 80% threshold
       });
       if (conversationMatch) {
         logger.info(`[${this.getProviderName()}] \u2713 Found matching conversation with ${(conversationMatch.similarity * 100).toFixed(2)}% similarity`);
@@ -6788,7 +6928,6 @@ ${errorMsg}
               data: {
                 text: cachedTextResponse,
                 component: null,
-                matchedComponents: [],
                 actions: conversationMatch.uiBlock?.actions || [],
                 reasoning: `Exact match from previous general conversation`,
                 method: `${this.getProviderName()}-semantic-match-general`,
@@ -6816,7 +6955,6 @@ ${errorMsg}
               data: {
                 text: cachedTextResponse,
                 component,
-                matchedComponents: component?.props?.config?.components || [],
                 actions: cachedActions,
                 reasoning: `Exact match from previous conversation (${(conversationMatch.similarity * 100).toFixed(2)}% similarity)`,
                 method: `${this.getProviderName()}-semantic-match-exact`,
@@ -6852,7 +6990,6 @@ ${errorMsg}
               data: {
                 text: textResponseToUse,
                 component: adaptResult.adaptedComponent,
-                matchedComponents: adaptResult.adaptedComponent?.props?.config?.components || [],
                 actions: cachedActions,
                 reasoning: `Adapted from previous conversation: ${originalPrompt}`,
                 method: `${this.getProviderName()}-semantic-match`,
@@ -6903,6 +7040,8 @@ ${errorMsg}
             executionReason: t.executionReason || "",
             requiredFields: t.requiredFields || [],
             userProvidedData: t.userProvidedData || null,
+            // CRITICAL: Include outputSchema from real tool for component config generation
+            outputSchema: realTool?.outputSchema,
             fn: (() => {
               if (realTool) {
                 logger.info(`[${this.getProviderName()}] Using real tool implementation for ${t.type}`);
@@ -10459,6 +10598,331 @@ function sendResponse8(id, res, sendMessage, clientId) {
   sendMessage(response);
 }
 
+// src/handlers/menus.ts
+init_logger();
+async function handleMenusRequest(data, collections, sendMessage) {
+  const executeCollection = async (collection, op, params) => {
+    const handler = collections[collection]?.[op];
+    if (!handler) {
+      throw new Error(`Collection operation ${collection}.${op} not found`);
+    }
+    return await handler(params);
+  };
+  try {
+    const request = MenusRequestMessageSchema.parse(data);
+    const { id, payload, from } = request;
+    const { operation, data: requestData } = payload;
+    const menuId = requestData?.id;
+    const name = requestData?.name;
+    const componentName = requestData?.componentName;
+    const icon = requestData?.icon;
+    const userMessage = requestData?.userMessage;
+    const parentId = requestData?.parentId;
+    const sortOrder = requestData?.sortOrder;
+    const props = requestData?.props;
+    const isActive = requestData?.isActive;
+    const filters = requestData?.filters;
+    const limit = requestData?.limit;
+    const sort = requestData?.sort;
+    const items = requestData?.items;
+    switch (operation) {
+      case "create":
+        await handleCreate7(id, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, from.id);
+        break;
+      case "update":
+        await handleUpdate7(id, menuId, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, from.id);
+        break;
+      case "delete":
+        await handleDelete7(id, menuId, executeCollection, sendMessage, from.id);
+        break;
+      case "getAll":
+        await handleGetAll7(id, executeCollection, sendMessage, from.id);
+        break;
+      case "getOne":
+        await handleGetOne7(id, menuId, executeCollection, sendMessage, from.id);
+        break;
+      case "getRootMenus":
+        await handleGetRootMenus(id, executeCollection, sendMessage, from.id);
+        break;
+      case "getChildMenus":
+        await handleGetChildMenus(id, parentId, executeCollection, sendMessage, from.id);
+        break;
+      case "getHierarchy":
+        await handleGetHierarchy(id, executeCollection, sendMessage, from.id);
+        break;
+      case "query":
+        await handleQuery6(id, filters, limit, sort, executeCollection, sendMessage, from.id);
+        break;
+      case "reorder":
+        await handleReorder(id, items, executeCollection, sendMessage, from.id);
+        break;
+      default:
+        sendResponse9(id, {
+          success: false,
+          error: `Unknown operation: ${operation}`
+        }, sendMessage, from.id);
+    }
+  } catch (error) {
+    logger.error("Failed to handle menus request:", error);
+    sendResponse9(null, {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error occurred"
+    }, sendMessage);
+  }
+}
+async function handleCreate7(id, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, clientId) {
+  if (!name) {
+    sendResponse9(id, {
+      success: false,
+      error: "name is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (!componentName) {
+    sendResponse9(id, {
+      success: false,
+      error: "componentName is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("menus", "create", {
+      name,
+      componentName,
+      icon,
+      userMessage,
+      parentId,
+      sortOrder,
+      props,
+      isActive
+    });
+    sendResponse9(id, {
+      success: true,
+      data: result.data,
+      message: "Menu created successfully"
+    }, sendMessage, clientId);
+    logger.info(`Menu created: ID ${result.data?.id}`);
+  } catch (error) {
+    sendResponse9(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to create menu"
+    }, sendMessage, clientId);
+  }
+}
+async function handleUpdate7(id, menuId, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, clientId) {
+  if (!menuId) {
+    sendResponse9(id, {
+      success: false,
+      error: "Menu ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("menus", "update", {
+      id: menuId,
+      name,
+      componentName,
+      icon,
+      userMessage,
+      parentId,
+      sortOrder,
+      props,
+      isActive
+    });
+    sendResponse9(id, {
+      success: true,
+      data: result.data,
+      message: "Menu updated successfully"
+    }, sendMessage, clientId);
+    logger.info(`Menu updated: ID ${menuId}`);
+  } catch (error) {
+    sendResponse9(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update menu"
+    }, sendMessage, clientId);
+  }
+}
+async function handleDelete7(id, menuId, executeCollection, sendMessage, clientId) {
+  if (!menuId) {
+    sendResponse9(id, {
+      success: false,
+      error: "Menu ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("menus", "delete", { id: menuId });
+    sendResponse9(id, {
+      success: true,
+      data: result.data,
+      message: "Menu deleted successfully"
+    }, sendMessage, clientId);
+    logger.info(`Menu deleted: ID ${menuId}`);
+  } catch (error) {
+    sendResponse9(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to delete menu"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetAll7(id, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("menus", "getAll", {});
+    sendResponse9(id, {
+      success: true,
+      data: result.data,
+      count: result.count,
+      message: `Retrieved ${result.count} menus`
+    }, sendMessage, clientId);
+    logger.info(`Retrieved all menus (count: ${result.count})`);
+  } catch (error) {
+    sendResponse9(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get menus"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetOne7(id, menuId, executeCollection, sendMessage, clientId) {
+  if (!menuId) {
+    sendResponse9(id, {
+      success: false,
+      error: "Menu ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("menus", "getOne", { id: menuId });
+    sendResponse9(id, {
+      success: true,
+      data: result.data,
+      message: `Retrieved menu ID ${menuId}`
+    }, sendMessage, clientId);
+    logger.info(`Retrieved menu: ID ${menuId}`);
+  } catch (error) {
+    sendResponse9(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get menu"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetRootMenus(id, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("menus", "getRootMenus", {});
+    sendResponse9(id, {
+      success: true,
+      data: result.data,
+      count: result.count,
+      message: `Retrieved ${result.count} root menus`
+    }, sendMessage, clientId);
+    logger.info(`Retrieved root menus (count: ${result.count})`);
+  } catch (error) {
+    sendResponse9(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get root menus"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetChildMenus(id, parentId, executeCollection, sendMessage, clientId) {
+  if (parentId === void 0 || parentId === null) {
+    sendResponse9(id, {
+      success: false,
+      error: "parentId is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("menus", "getChildMenus", { parentId });
+    sendResponse9(id, {
+      success: true,
+      data: result.data,
+      count: result.count,
+      message: `Retrieved ${result.count} child menus for parent ${parentId}`
+    }, sendMessage, clientId);
+    logger.info(`Retrieved child menus for parent ${parentId} (count: ${result.count})`);
+  } catch (error) {
+    sendResponse9(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get child menus"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetHierarchy(id, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("menus", "getHierarchy", {});
+    sendResponse9(id, {
+      success: true,
+      data: result.data,
+      count: result.count,
+      message: `Retrieved menus hierarchy with ${result.count} root items`
+    }, sendMessage, clientId);
+    logger.info(`Retrieved menus hierarchy (root count: ${result.count})`);
+  } catch (error) {
+    sendResponse9(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get menus hierarchy"
+    }, sendMessage, clientId);
+  }
+}
+async function handleQuery6(id, filters, limit, sort, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("menus", "query", {
+      filters: filters || {},
+      limit,
+      sort
+    });
+    sendResponse9(id, {
+      success: true,
+      data: result.data,
+      count: result.count,
+      message: `Query returned ${result.count} menus`
+    }, sendMessage, clientId);
+    logger.info(`Query returned ${result.count} menus`);
+  } catch (error) {
+    sendResponse9(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to query menus"
+    }, sendMessage, clientId);
+  }
+}
+async function handleReorder(id, items, executeCollection, sendMessage, clientId) {
+  if (!items || !Array.isArray(items) || items.length === 0) {
+    sendResponse9(id, {
+      success: false,
+      error: "items array is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("menus", "reorder", { items });
+    sendResponse9(id, {
+      success: true,
+      data: result.data,
+      message: `Reordered ${items.length} menus successfully`
+    }, sendMessage, clientId);
+    logger.info(`Reordered ${items.length} menus`);
+  } catch (error) {
+    sendResponse9(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to reorder menus"
+    }, sendMessage, clientId);
+  }
+}
+function sendResponse9(id, res, sendMessage, clientId) {
+  const response = {
+    id: id || "unknown",
+    type: "MENUS_RES",
+    from: { type: "data-agent" },
+    to: {
+      type: "admin",
+      id: clientId
+    },
+    payload: {
+      ...res
+    }
+  };
+  sendMessage(response);
+}
+
 // src/dashComp/index.ts
 init_logger();
 
@@ -10585,37 +11049,74 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
       return { success: false, errors };
     }
     logger.info(`[DASH_COMP_REQ] Using model: ${model}`);
-    const result = await LLM.stream(
+    const executedTools = [];
+    const llmTools = (tools || []).map((tool) => ({
+      name: tool.id,
+      description: tool.description,
+      input_schema: {
+        type: "object",
+        properties: Object.fromEntries(
+          Object.entries(tool.params || {}).map(([key, val]) => [key, { type: typeof val === "string" && ["string", "number", "boolean", "integer"].includes(val.toLowerCase()) ? val.toLowerCase() : "string", description: `${key} parameter` }])
+        ),
+        additionalProperties: false
+      }
+    }));
+    const toolHandler = async (toolName, toolInput) => {
+      const tool = tools?.find((t) => t.id === toolName);
+      if (!tool) {
+        throw new Error(`Unknown tool: ${toolName}`);
+      }
+      logger.info(`[DASH_COMP_REQ] Executing external tool: ${tool.name} (${tool.id})`);
+      const result2 = await tool.fn(toolInput);
+      executedTools.push({
+        id: tool.id,
+        name: tool.name,
+        params: toolInput,
+        result: result2,
+        outputSchema: tool.outputSchema
+      });
+      logger.info(`[DASH_COMP_REQ] Tool ${tool.name} executed successfully`);
+      return JSON.stringify(result2, null, 2);
+    };
+    const result = await LLM.streamWithTools(
       {
         sys: prompts.system,
         user: prompts.user
       },
+      llmTools,
+      toolHandler,
       {
         model,
         maxTokens: 8192,
         temperature: 0.2,
         apiKey
       },
-      true
-      // Parse as JSON
+      5
+      // max iterations
     );
+    const jsonMatch = result.match(/\{[\s\S]*\}/);
+    const parsedResult = jsonMatch ? JSON.parse(jsonMatch[0]) : null;
+    if (!parsedResult) {
+      errors.push("Failed to parse LLM response as JSON");
+      return { success: false, errors };
+    }
     logger.debug("[DASH_COMP_REQ] LLM response received");
-    logger.file("[DASH_COMP_REQ] LLM response:", JSON.stringify(result, null, 2));
-    if (!result.componentId || !result.props) {
+    logger.file("[DASH_COMP_REQ] LLM response:", JSON.stringify(parsedResult, null, 2));
+    if (!parsedResult.componentId || !parsedResult.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 }
+        result: parsedResult,
+        missingFields: { componentId: !parsedResult.componentId, props: !parsedResult.props }
       });
       return { success: false, errors };
     }
-    const originalComponent = components.find((c) => c.name === result.componentName);
+    const originalComponent = components.find((c) => c.name === parsedResult.componentName);
     if (!originalComponent) {
-      errors.push(`Component ${result.componentName} not found in available components`);
+      errors.push(`Component ${parsedResult.componentName} not found in available components`);
       userPromptErrorLogger.logError("DASH_COMP_REQ", "Component not found", {
         prompt,
-        componentName: result.componentName,
+        componentName: parsedResult.componentName,
         availableComponentNames: components.map((c) => c.name)
       });
       return { success: false, errors };
@@ -10624,23 +11125,27 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
       ...originalComponent,
       props: {
         ...originalComponent.props,
-        ...result.props
+        ...parsedResult.props
       }
     };
     logger.info(`[DASH_COMP_REQ] Successfully picked component: ${finalComponent.name} (${finalComponent.type})`);
-    if (result.props.query) {
+    if (parsedResult.props.query) {
       logger.info(`[DASH_COMP_REQ] Data source: Database query`);
     }
-    if (result.props.externalTool) {
-      logger.info(`[DASH_COMP_REQ] Data source: External tool - ${result.props.externalTool.toolName}`);
+    if (parsedResult.props.externalTool) {
+      logger.info(`[DASH_COMP_REQ] Data source: External tool - ${parsedResult.props.externalTool.toolName}`);
+    }
+    if (executedTools.length > 0) {
+      logger.info(`[DASH_COMP_REQ] Executed ${executedTools.length} external tool(s): ${executedTools.map((t) => t.name).join(", ")}`);
     }
     return {
       success: true,
       data: {
         component: finalComponent,
-        reasoning: result.reasoning || "Component selected based on user prompt",
-        dataSource: result.props.query ? "database" : result.props.externalTool ? "external_tool" : "none",
-        isUpdate: result.isUpdate || false
+        reasoning: parsedResult.reasoning || "Component selected based on user prompt",
+        dataSource: parsedResult.props.query ? "database" : parsedResult.props.externalTool ? "external_tool" : "none",
+        isUpdate: parsedResult.isUpdate || false,
+        executedTools: executedTools.length > 0 ? executedTools : void 0
       },
       errors: []
     };
@@ -10693,11 +11198,49 @@ async function createFilterWithLLM(prompt, components, existingComponents, anthr
       return { success: false, errors };
     }
     logger.info(`[DASH_COMP_REQ:FILTER] Using model: ${model}`);
-    const result = await LLM.stream(
+    const executedTools = [];
+    const llmTools = (tools || []).map((tool) => ({
+      name: tool.id,
+      description: tool.description,
+      input_schema: {
+        type: "object",
+        properties: Object.fromEntries(
+          Object.entries(tool.params || {}).map(([key, val]) => [key, { type: typeof val === "string" && ["string", "number", "boolean", "integer"].includes(val.toLowerCase()) ? val.toLowerCase() : "string", description: `${key} parameter` }])
+        ),
+        additionalProperties: false
+      }
+    }));
+    const toolHandler = async (toolName, toolInput) => {
+      const tool = tools?.find((t) => t.id === toolName);
+      if (!tool) {
+        throw new Error(`Unknown tool: ${toolName}`);
+      }
+      logger.info(`[DASH_COMP_REQ:FILTER] Executing external tool: ${tool.name} (${tool.id})`);
+      const result2 = await tool.fn(toolInput);
+      executedTools.push({
+        id: tool.id,
+        name: tool.name,
+        params: toolInput,
+        result: result2,
+        outputSchema: tool.outputSchema
+      });
+      logger.info(`[DASH_COMP_REQ:FILTER] Tool ${tool.name} executed successfully`);
+      return JSON.stringify(result2, null, 2);
+    };
+    const rawResult = await LLM.streamWithTools(
       { sys: prompts.system, user: prompts.user },
+      llmTools,
+      toolHandler,
       { model, maxTokens: 16384, temperature: 0.2, apiKey },
-      true
+      5
+      // max iterations
     );
+    const jsonMatch = rawResult.match(/\{[\s\S]*\}/);
+    const result = jsonMatch ? JSON.parse(jsonMatch[0]) : null;
+    if (!result) {
+      errors.push("Failed to parse LLM response as JSON");
+      return { success: false, errors };
+    }
     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) {
@@ -10711,13 +11254,17 @@ async function createFilterWithLLM(prompt, components, existingComponents, anthr
     }
     logger.info(`[DASH_COMP_REQ:FILTER] Successfully created filter: ${result.filterComponent.componentType}`);
     logger.info(`[DASH_COMP_REQ:FILTER] Updated ${result.updatedComponents?.length || 0} components`);
+    if (executedTools.length > 0) {
+      logger.info(`[DASH_COMP_REQ:FILTER] Executed ${executedTools.length} external tool(s): ${executedTools.map((t) => t.name).join(", ")}`);
+    }
     return {
       success: true,
       data: {
         filterComponent: result.filterComponent,
         updatedComponents: result.updatedComponents || [],
         filterBindings: result.filterBindings || {},
-        reasoning: result.reasoning || "Filter created based on user prompt"
+        reasoning: result.reasoning || "Filter created based on user prompt",
+        executedTools: executedTools.length > 0 ? executedTools : void 0
       },
       errors: []
     };
@@ -11895,6 +12442,11 @@ var SuperatomSDK = class {
             logger.error("Failed to handle KB nodes request:", error);
           });
           break;
+        case "MENUS":
+          handleMenusRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
+            logger.error("Failed to handle menus request:", error);
+          });
+          break;
         case "DASH_COMP_REQ":
           handleDashCompRequest(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 dash comp request:", error);