@superatomai/sdk-node 0.0.32 → 0.0.34

package/dist/index.js

@@ -1033,6 +1033,143 @@ If adaptation is not possible or would fundamentally change the component:
 4. **Preserve structure**: Keep the same number and type of components
 
 5. **Return complete JSON** with all adapted properties for all components`
+      },
+      "dash-comp-picker": {
+        system: `You are a component selection expert that picks the best dashboard component and generates complete props based on user requests.
+
+## Your Task
+
+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
+
+## Component Selection Rules
+
+1. **Match by Intent**: Understand what the user wants to display/achieve
+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
+
+## 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)
+- CRUD operations on database tables
+
+### Use EXTERNAL TOOL when:
+- User mentions specific external systems (ERP, CRM, email, calendar, etc.)
+- Data not available in database schema
+- Actions that require external integrations (send email, create calendar event, sync with ERP)
+- Tool description matches the user's request
+
+## Props Generation Rules
+
+**CRITICAL**: Look at each component's "Props Structure" in the available components list. Generate ALL props that the component expects.
+
+### For Data Viewing Components (charts, tables, KPIs):
+
+**Option A: Database Query** (when data is in database)
+\`\`\`json
+{
+  "query": {
+    "sql": "SELECT column1, column2 FROM table WHERE condition = $param LIMIT 32",
+    "params": { "param": "value" }
+  }
+}
+\`\`\`
+
+**Option B: External Tool** (when data is from ERP/external system)
+\`\`\`json
+{
+  "externalTool": {
+    "toolId": "tool_id_from_list",
+    "toolName": "Tool Display Name",
+    "action": "get",
+    "params": {
+      "param1": "value1",
+      "param2": "value2"
+    }
+  }
+}
+\`\`\`
+
+### For Data Modification Components (forms):
+
+**Option A: Database Mutation**
+\`\`\`json
+{
+  "query": {
+    "sql": "INSERT INTO table (col1, col2) VALUES ($col1, $col2)",
+    "params": {}
+  },
+  "fields": [
+    { "name": "col1", "type": "text", "required": true },
+    { "name": "col2", "type": "number", "required": false }
+  ]
+}
+\`\`\`
+
+**Option B: External Tool Mutation**
+\`\`\`json
+{
+  "externalTool": {
+    "toolId": "tool_id_from_list",
+    "toolName": "Tool Display Name",
+    "action": "create|update|delete",
+    "params": {
+      "param1": "value_or_placeholder"
+    }
+  },
+  "fields": [
+    { "name": "param1", "type": "text", "required": true }
+  ]
+}
+\`\`\`
+
+### Database Query Rules
+{{DATABASE_RULES}}
+
+## Output Format
+
+You MUST respond with ONLY a valid JSON object (no markdown, no code blocks):
+
+{
+  "componentId": "id_from_available_list",
+  "componentName": "name_of_component",
+  "componentType": "type_of_component",
+  "dataSourceType": "database" | "external_tool",
+  "operationType": "view" | "create" | "update" | "delete",
+  "reasoning": "Why this component was selected and why this data source",
+  "props": {
+    // Generate ALL props based on the component's Props Structure
+    // Include either "query" OR "externalTool" based on data source
+    // Include all other required props (title, description, config, fields, etc.)
+  }
+}
+
+**CRITICAL:**
+- Return ONLY valid JSON (no markdown code blocks, no text before/after)
+- \`componentId\` MUST match an ID from the available components list
+- \`dataSourceType\` indicates whether data comes from database or external tool
+- \`operationType\` indicates the type of 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
+
+---
+
+## CONTEXT (for this specific request)
+
+### Database Schema
+{{SCHEMA_DOC}}
+
+### Available External Tools
+{{AVAILABLE_TOOLS}}
+
+### Available Components
+{{AVAILABLE_COMPONENTS}}`,
+        user: `{{USER_PROMPT}}`
       }
     };
   }
@@ -1564,6 +1701,13 @@ var UIElementSchema = import_zod.z.lazy(
     }).optional()
   })
 );
+var PageSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string(),
+  order: import_zod.z.number(),
+  icon: import_zod.z.string().optional(),
+  render: UIElementSchema
+});
 var UIComponentSchema = import_zod.z.object({
   id: import_zod.z.string(),
   name: import_zod.z.string().optional(),
@@ -1583,7 +1727,9 @@ var UIComponentSchema = import_zod.z.object({
     })
   ).optional(),
   data: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(),
-  render: UIElementSchema,
+  render: UIElementSchema.optional(),
+  pages: import_zod.z.array(PageSchema).optional(),
+  defaultPageId: import_zod.z.string().optional(),
   query: QuerySpecSchema.optional()
 });
 var DSLRendererPropsSchema = import_zod.z.object({
@@ -2049,6 +2195,19 @@ var KbNodesRequestMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("KB_NODES"),
   payload: KbNodesRequestPayloadSchema
 });
+var DashCompRequestPayloadSchema = import_zod3.z.object({
+  prompt: import_zod3.z.string(),
+  SA_RUNTIME: import_zod3.z.object({
+    threadId: import_zod3.z.string().optional(),
+    uiBlockId: import_zod3.z.string().optional()
+  }).optional()
+});
+var DashCompRequestMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  from: MessageParticipantSchema,
+  type: import_zod3.z.literal("DASH_COMP_REQ"),
+  payload: DashCompRequestPayloadSchema
+});
 
 // src/index.ts
 init_logger();
@@ -5596,7 +5755,7 @@ var AnthropicLLM = class extends BaseLLM {
     super(config);
   }
   getDefaultModel() {
-    return "anthropic/claude-haiku-4-5-20251001";
+    return "anthropic/claude-sonnet-4-5-20250929";
   }
   getDefaultApiKey() {
     return process.env.ANTHROPIC_API_KEY;
@@ -8974,6 +9133,219 @@ function sendResponse8(id, res, sendMessage, clientId) {
   sendMessage(response);
 }
 
+// src/handlers/dash-comp-request.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}
+   Name: ${comp.name}
+   Type: ${comp.type}
+   Description: ${comp.description || "No description"}
+   Keywords: ${keywords}
+   Props Structure: ${propsPreview}`;
+    }).join("\n\n");
+  }
+  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}
+   Name: ${tool.name}
+   Description: ${tool.description}
+   Parameters: { ${paramsStr} }`;
+    }).join("\n\n");
+  }
+  try {
+    const schemaDoc = schema.generateSchemaDocumentation();
+    const databaseRules = await promptLoader.loadDatabaseRules();
+    const prompts = await promptLoader.loadPrompts("dash-comp-picker", {
+      USER_PROMPT: prompt,
+      AVAILABLE_COMPONENTS: availableComponentsText,
+      SCHEMA_DOC: schemaDoc || "No database schema available",
+      DATABASE_RULES: databaseRules,
+      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) {
+      errors.push("No API key available for any LLM provider");
+      return { success: false, errors };
+    }
+    logger.info(`[DASH_COMP_REQ] Using model: ${model}`);
+    const result = await LLM.stream(
+      {
+        sys: prompts.system,
+        user: prompts.user
+      },
+      {
+        model,
+        maxTokens: 3e3,
+        temperature: 0.2,
+        apiKey
+      },
+      true
+      // Parse as JSON
+    );
+    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) {
+      errors.push("Invalid LLM response: missing componentId or 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`);
+      return { success: false, errors };
+    }
+    const finalComponent = {
+      ...originalComponent,
+      props: {
+        ...originalComponent.props,
+        ...result.props
+      }
+    };
+    logger.info(`[DASH_COMP_REQ] Successfully picked component: ${finalComponent.name} (${finalComponent.type})`);
+    if (result.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}`);
+    }
+    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"
+      },
+      errors: []
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.error(`[DASH_COMP_REQ] Error picking component: ${errorMsg}`);
+    errors.push(errorMsg);
+    return { success: false, errors };
+  }
+}
+var processDashCompRequest = async (data, components, _sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, tools) => {
+  const errors = [];
+  logger.debug("[DASH_COMP_REQ] Parsing incoming message data");
+  const parseResult = DashCompRequestMessageSchema.safeParse(data);
+  if (!parseResult.success) {
+    const zodError = parseResult.error;
+    zodError.errors.forEach((err) => {
+      errors.push(`${err.path.join(".")}: ${err.message}`);
+    });
+    return { success: false, errors };
+  }
+  const dashCompRequest = parseResult.data;
+  const { id, payload } = dashCompRequest;
+  const prompt = payload.prompt;
+  const wsId = dashCompRequest.from.id || "unknown";
+  if (!prompt) {
+    errors.push("Prompt is required");
+  }
+  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] Available: ${components?.length || 0} components, ${tools?.length || 0} tools`);
+  if (!components || components.length === 0) {
+    logger.warn("[DASH_COMP_REQ] No components available");
+    return {
+      success: false,
+      errors: ["No components available. Please ensure components are loaded."],
+      id,
+      wsId
+    };
+  }
+  const llmResponse = await pickComponentWithLLM(
+    prompt,
+    components,
+    anthropicApiKey,
+    groqApiKey,
+    geminiApiKey,
+    openaiApiKey,
+    llmProviders,
+    collections,
+    tools
+  );
+  return {
+    success: llmResponse.success,
+    data: llmResponse.data,
+    errors: llmResponse.errors,
+    id,
+    wsId
+  };
+};
+async function handleDashCompRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, tools) {
+  const response = await processDashCompRequest(
+    data,
+    components,
+    sendMessage,
+    anthropicApiKey,
+    groqApiKey,
+    geminiApiKey,
+    openaiApiKey,
+    llmProviders,
+    collections,
+    tools
+  );
+  sendDashCompResponse(
+    response.id || data.id,
+    {
+      success: response.success,
+      errors: response.errors,
+      data: response.data
+    },
+    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}`);
+}
+
 // src/auth/user-manager.ts
 var import_fs4 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
@@ -10029,6 +10401,11 @@ var SuperatomSDK = class {
             logger.error("Failed to handle KB nodes 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);
+          });
+          break;
         default:
           const handler = this.messageTypeHandlers.get(message.type);
           if (handler) {