@superatomai/sdk-node 0.0.77 → 0.0.78

package/dist/index.js

@@ -752,6 +752,67 @@ var DashCompRequestMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("DASH_COMP_REQ"),
   payload: DashCompRequestPayloadSchema
 });
+var SchemaColumnStatisticsSchema = import_zod3.z.object({
+  distinct: import_zod3.z.number().optional(),
+  min: import_zod3.z.number().optional(),
+  max: import_zod3.z.number().optional()
+});
+var SchemaColumnSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  type: import_zod3.z.string(),
+  nativeType: import_zod3.z.string(),
+  nullable: import_zod3.z.boolean(),
+  description: import_zod3.z.string(),
+  statistics: SchemaColumnStatisticsSchema.optional(),
+  cardinality: import_zod3.z.enum(["unique", "high", "medium", "low"]).optional(),
+  sampleValues: import_zod3.z.array(import_zod3.z.string()).optional()
+});
+var SchemaTableSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  fullName: import_zod3.z.string(),
+  rowCount: import_zod3.z.number(),
+  description: import_zod3.z.string(),
+  columns: import_zod3.z.array(SchemaColumnSchema)
+});
+var SchemaRelationshipSchema = import_zod3.z.object({
+  from: import_zod3.z.string(),
+  to: import_zod3.z.string(),
+  type: import_zod3.z.string(),
+  keys: import_zod3.z.array(import_zod3.z.string())
+});
+var DatabaseSchemaSchema = import_zod3.z.object({
+  database: import_zod3.z.string(),
+  databaseType: import_zod3.z.string().optional(),
+  schema: import_zod3.z.string(),
+  description: import_zod3.z.string(),
+  tables: import_zod3.z.array(SchemaTableSchema),
+  relationships: import_zod3.z.array(SchemaRelationshipSchema).optional()
+});
+var SchemaRequestPayloadSchema = import_zod3.z.object({
+  /** If true, returns the formatted documentation string in addition to raw JSON */
+  formatted: import_zod3.z.boolean().optional()
+});
+var SchemaRequestMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  from: MessageParticipantSchema,
+  type: import_zod3.z.literal("SCHEMA_REQ"),
+  payload: SchemaRequestPayloadSchema
+});
+var SchemaResponsePayloadSchema = import_zod3.z.object({
+  success: import_zod3.z.boolean(),
+  error: import_zod3.z.string().optional(),
+  data: import_zod3.z.object({
+    schema: DatabaseSchemaSchema,
+    /** Formatted schema documentation (only if formatted: true was requested) */
+    formatted: import_zod3.z.string().optional()
+  }).optional()
+});
+var SchemaResponseMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  from: MessageParticipantSchema,
+  type: import_zod3.z.literal("SCHEMA_RES"),
+  payload: SchemaResponsePayloadSchema
+});
 
 // src/utils/logger.ts
 var import_fs = __toESM(require("fs"));
@@ -3536,6 +3597,7 @@ 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)
+-\`componentName\`: MUST be the EXACT \`name\` field from the Available Components list. Never use a title or description as componentName.
 - \`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
@@ -6533,6 +6595,7 @@ var STREAM_PREVIEW_MAX_CHARS = 200;
 var TOOL_TRACKING_MAX_ROWS = 5;
 var TOOL_TRACKING_MAX_CHARS = 200;
 var TOOL_TRACKING_SAMPLE_ROWS = 3;
+var DEFAULT_QUERY_LIMIT = 10;
 var MAX_COMPONENT_QUERY_LIMIT = 10;
 var EXACT_MATCH_SIMILARITY_THRESHOLD = 0.99;
 var DEFAULT_CONVERSATION_SIMILARITY_THRESHOLD = 0.8;
@@ -12223,6 +12286,7 @@ function formatComponentsForPrompt(components) {
   if (!components || components.length === 0) {
     return "No components available";
   }
+  components = components.filter((c) => c.name !== "MultiComponentContainer");
   return components.map((comp, idx) => {
     const keywords = comp.keywords ? comp.keywords.join(", ") : "";
     const propsPreview = comp.props ? JSON.stringify(comp.props, null, 2) : "No props";
@@ -12269,7 +12333,7 @@ function sendDashCompResponse(id, res, sendMessage, clientId) {
 }
 
 // src/dashComp/pick-component.ts
-async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, _collections, tools, dashCompModels) {
+async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, tools, dashCompModels) {
   const errors = [];
   const availableComponentsText = formatComponentsForPrompt(components);
   const availableToolsText = formatToolsForPrompt(tools);
@@ -12347,12 +12411,14 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
     const parsedResult = jsonMatch ? JSON.parse(jsonMatch[0]) : null;
     if (!parsedResult) {
       errors.push("Failed to parse LLM response as JSON");
+      errors.push(`LLM Response: ${result}`);
       return { success: false, errors };
     }
     logger.debug("[DASH_COMP_REQ] LLM response received");
     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");
+      errors.push(`LLM Response: ${result}`);
       userPromptErrorLogger.logError("DASH_COMP_REQ", "Invalid LLM response structure", {
         prompt,
         result: parsedResult,
@@ -12363,6 +12429,7 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
     const originalComponent = components.find((c) => c.name === parsedResult.componentName);
     if (!originalComponent) {
       errors.push(`Component ${parsedResult.componentName} not found in available components`);
+      errors.push(`LLM Response: ${result}`);
       userPromptErrorLogger.logError("DASH_COMP_REQ", "Component not found", {
         prompt,
         componentName: parsedResult.componentName,
@@ -12370,14 +12437,72 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
       });
       return { success: false, errors };
     }
-    const finalComponent = {
+    let finalComponent = {
       ...originalComponent,
       props: {
         ...originalComponent.props,
         ...parsedResult.props
       }
     };
+    if (finalComponent.props?.query) {
+      const query = finalComponent.props.query;
+      if (typeof query === "string") {
+        finalComponent.props.query = ensureQueryLimit(query, DEFAULT_QUERY_LIMIT, MAX_COMPONENT_QUERY_LIMIT);
+      } else if (query?.sql) {
+        finalComponent.props.query = {
+          ...query,
+          sql: ensureQueryLimit(query.sql, DEFAULT_QUERY_LIMIT, MAX_COMPONENT_QUERY_LIMIT)
+        };
+      }
+    }
     logger.info(`[DASH_COMP_REQ] Successfully picked component: ${finalComponent.name} (${finalComponent.type})`);
+    if (finalComponent.props?.query && collections?.["database"]?.["execute"]) {
+      logger.info(`[DASH_COMP_REQ] Validating query for component: ${finalComponent.name}`);
+      const queryService = new QueryExecutionService({
+        defaultLimit: DEFAULT_QUERY_LIMIT,
+        getModelForTask: () => model,
+        // Use the same model for query fixes
+        getApiKey: () => apiKey,
+        providerName: "DASH_COMP_REQ"
+      });
+      try {
+        const validationResult = await queryService.validateSingleQuery(
+          finalComponent,
+          collections,
+          apiKey
+        );
+        if (!validationResult.validated) {
+          logger.error(`[DASH_COMP_REQ] Query validation failed for component: ${finalComponent.name}`);
+          errors.push(`Query validation failed for component ${finalComponent.name}. The generated SQL query could not be executed.`);
+          return {
+            success: false,
+            errors,
+            data: {
+              reasoning: parsedResult.reasoning || "Component selected but query validation failed",
+              rawResponse: parsedResult
+            }
+          };
+        }
+        if (validationResult.component) {
+          finalComponent = validationResult.component;
+        }
+        logger.info(`[DASH_COMP_REQ] Query validated successfully for component: ${finalComponent.name}`);
+      } catch (validationError) {
+        const validationErrorMsg = validationError instanceof Error ? validationError.message : String(validationError);
+        logger.error(`[DASH_COMP_REQ] Query validation error: ${validationErrorMsg}`);
+        errors.push(`Query validation error: ${validationErrorMsg}`);
+        return {
+          success: false,
+          errors,
+          data: {
+            reasoning: parsedResult.reasoning || "Component selected but query validation encountered an error",
+            rawResponse: parsedResult
+          }
+        };
+      }
+    } else if (finalComponent.props?.query && !collections?.["database"]?.["execute"]) {
+      logger.warn(`[DASH_COMP_REQ] Skipping query validation - database execute function not available`);
+    }
     if (parsedResult.props.query) {
       logger.info(`[DASH_COMP_REQ] Data source: Database query`);
     }
@@ -12487,12 +12612,14 @@ async function createFilterWithLLM(prompt, components, existingComponents, anthr
     const result = jsonMatch ? JSON.parse(jsonMatch[0]) : null;
     if (!result) {
       errors.push("Failed to parse LLM response as JSON");
+      errors.push(`LLM Response: ${rawResult}`);
       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) {
       errors.push("Invalid LLM response: missing filterComponent");
+      errors.push(`LLM Response: ${rawResult}`);
       userPromptErrorLogger.logError("DASH_COMP_REQ:FILTER", "Invalid LLM response structure", {
         prompt,
         result,
@@ -12635,6 +12762,64 @@ async function handleDashCompRequest(data, components, sendMessage, anthropicApi
   logger.info(`[DASH_COMP_REQ] Response sent to client ${response.wsId || data.from?.id}`);
 }
 
+// src/handlers/schema-request.ts
+async function handleSchemaRequest(message, sendMessage) {
+  const startTime = Date.now();
+  try {
+    const payload = message.payload;
+    const formatted = payload?.formatted ?? false;
+    logger.info(`[SchemaRequest] Processing schema request (formatted: ${formatted})`);
+    const schemaData = schema.getSchema();
+    if (!schemaData) {
+      const response2 = {
+        id: message.id,
+        type: "SCHEMA_RES",
+        from: { type: "data-agent" },
+        to: message.from,
+        payload: {
+          success: false,
+          error: "Schema not found or failed to load"
+        }
+      };
+      sendMessage(response2);
+      return;
+    }
+    const responseData = {
+      schema: schemaData
+    };
+    if (formatted) {
+      responseData.formatted = schema.generateSchemaDocumentation();
+    }
+    const executionMs = Date.now() - startTime;
+    logger.info(`[SchemaRequest] Schema retrieved successfully in ${executionMs}ms`);
+    const response = {
+      id: message.id,
+      type: "SCHEMA_RES",
+      from: { type: "data-agent" },
+      to: message.from,
+      payload: {
+        success: true,
+        data: responseData
+      }
+    };
+    sendMessage(response);
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.error(`[SchemaRequest] Error: ${errorMsg}`);
+    const response = {
+      id: message.id,
+      type: "SCHEMA_RES",
+      from: { type: "data-agent" },
+      to: message.from,
+      payload: {
+        success: false,
+        error: errorMsg
+      }
+    };
+    sendMessage(response);
+  }
+}
+
 // src/auth/user-manager.ts
 var import_fs6 = __toESM(require("fs"));
 var import_path5 = __toESM(require("path"));
@@ -13883,6 +14068,11 @@ var SuperatomSDK = class {
             logger.error("Failed to handle dash comp request:", error);
           });
           break;
+        case "SCHEMA_REQ":
+          handleSchemaRequest(parsed, (msg) => this.send(msg)).catch((error) => {
+            logger.error("Failed to handle schema request:", error);
+          });
+          break;
         default:
           const handler = this.messageTypeHandlers.get(message.type);
           if (handler) {