@superatomai/sdk-node 0.0.77 → 0.0.79

package/dist/index.mjs

@@ -345,7 +345,8 @@ var UserQueryFiltersSchema = z3.object({
   username: z3.string().optional(),
   email: z3.string().optional(),
   role: z3.string().optional(),
-  fullname: z3.string().optional()
+  fullname: z3.string().optional(),
+  id: z3.number().optional()
 });
 var UsersRequestPayloadSchema = z3.object({
   operation: z3.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
@@ -695,6 +696,67 @@ var DashCompRequestMessageSchema = z3.object({
   type: z3.literal("DASH_COMP_REQ"),
   payload: DashCompRequestPayloadSchema
 });
+var SchemaColumnStatisticsSchema = z3.object({
+  distinct: z3.number().optional(),
+  min: z3.number().optional(),
+  max: z3.number().optional()
+});
+var SchemaColumnSchema = z3.object({
+  name: z3.string(),
+  type: z3.string(),
+  nativeType: z3.string(),
+  nullable: z3.boolean(),
+  description: z3.string(),
+  statistics: SchemaColumnStatisticsSchema.optional(),
+  cardinality: z3.enum(["unique", "high", "medium", "low"]).optional(),
+  sampleValues: z3.array(z3.string()).optional()
+});
+var SchemaTableSchema = z3.object({
+  name: z3.string(),
+  fullName: z3.string(),
+  rowCount: z3.number(),
+  description: z3.string(),
+  columns: z3.array(SchemaColumnSchema)
+});
+var SchemaRelationshipSchema = z3.object({
+  from: z3.string(),
+  to: z3.string(),
+  type: z3.string(),
+  keys: z3.array(z3.string())
+});
+var DatabaseSchemaSchema = z3.object({
+  database: z3.string(),
+  databaseType: z3.string().optional(),
+  schema: z3.string(),
+  description: z3.string(),
+  tables: z3.array(SchemaTableSchema),
+  relationships: z3.array(SchemaRelationshipSchema).optional()
+});
+var SchemaRequestPayloadSchema = z3.object({
+  /** If true, returns the formatted documentation string in addition to raw JSON */
+  formatted: z3.boolean().optional()
+});
+var SchemaRequestMessageSchema = z3.object({
+  id: z3.string(),
+  from: MessageParticipantSchema,
+  type: z3.literal("SCHEMA_REQ"),
+  payload: SchemaRequestPayloadSchema
+});
+var SchemaResponsePayloadSchema = z3.object({
+  success: z3.boolean(),
+  error: z3.string().optional(),
+  data: z3.object({
+    schema: DatabaseSchemaSchema,
+    /** Formatted schema documentation (only if formatted: true was requested) */
+    formatted: z3.string().optional()
+  }).optional()
+});
+var SchemaResponseMessageSchema = z3.object({
+  id: z3.string(),
+  from: MessageParticipantSchema,
+  type: z3.literal("SCHEMA_RES"),
+  payload: SchemaResponsePayloadSchema
+});
 
 // src/utils/logger.ts
 import fs from "fs";
@@ -3479,6 +3541,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
@@ -6476,6 +6539,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;
@@ -12166,6 +12230,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";
@@ -12212,7 +12277,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);
@@ -12268,7 +12333,8 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
         outputSchema: tool.outputSchema
       });
       logger.info(`[DASH_COMP_REQ] Tool ${tool.name} executed successfully`);
-      return JSON.stringify(result2, null, 2);
+      const resultJson = JSON.stringify(result2, null, 2);
+      return resultJson + "\n\n[REMINDER: The above is tool output for verification. You MUST still respond with ONLY the JSON component selection object. Do NOT summarize or describe these results.]";
     };
     const result = await LLM.streamWithTools(
       {
@@ -12286,16 +12352,59 @@ async function pickComponentWithLLM(prompt, components, anthropicApiKey, groqApi
       5
       // max iterations
     );
-    const jsonMatch = result.match(/\{[\s\S]*\}/);
-    const parsedResult = jsonMatch ? JSON.parse(jsonMatch[0]) : null;
+    let jsonMatch = result.match(/\{[\s\S]*\}/);
+    let parsedResult = jsonMatch ? (() => {
+      try {
+        return JSON.parse(jsonMatch[0]);
+      } catch {
+        return null;
+      }
+    })() : null;
+    const isValidComponent = parsedResult && parsedResult.componentId && parsedResult.props;
+    if (!isValidComponent && executedTools.length > 0) {
+      const toolDataSummary = executedTools.map(
+        (t) => `Tool "${t.name}" was called with params ${JSON.stringify(t.params)} and returned:
+${JSON.stringify(t.result, null, 2).substring(0, 5e3)}`
+      ).join("\n\n");
+      const retryUserPrompt = `Original user request: ${prompt}
+
+The following tool was already called and returned data:
+${toolDataSummary}
+
+Using this data, select the appropriate component and respond with ONLY the JSON component selection object. No explanation, no markdown, just JSON.`;
+      const retryResult = await LLM.text(
+        {
+          sys: prompts.system,
+          user: retryUserPrompt
+        },
+        {
+          model,
+          maxTokens: 4096,
+          temperature: 0.1,
+          apiKey
+        }
+      );
+      jsonMatch = retryResult.match(/\{[\s\S]*\}/);
+      parsedResult = jsonMatch ? (() => {
+        try {
+          return JSON.parse(jsonMatch[0]);
+        } catch {
+          return null;
+        }
+      })() : null;
+    }
     if (!parsedResult) {
       errors.push("Failed to parse LLM response as JSON");
+      errors.push(`LLM Response: ${result}`);
+      logger.error(`[DASH_COMP_REQ] Failed to parse JSON from LLM response`);
       return { success: false, errors };
     }
-    logger.debug("[DASH_COMP_REQ] LLM response received");
+    logger.info(`[DASH_COMP_REQ] Parsed component: ${parsedResult.componentName} (${parsedResult.componentId})`);
     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}`);
+      logger.error(`[DASH_COMP_REQ] Invalid structure - missing componentId: ${!parsedResult.componentId}, missing props: ${!parsedResult.props}`);
       userPromptErrorLogger.logError("DASH_COMP_REQ", "Invalid LLM response structure", {
         prompt,
         result: parsedResult,
@@ -12306,6 +12415,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,
@@ -12313,14 +12423,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`);
     }
@@ -12430,12 +12598,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,
@@ -12578,6 +12748,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
 import fs7 from "fs";
 import path6 from "path";
@@ -13826,6 +14054,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) {