@superatomai/sdk-node 0.0.76 → 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
@@ -4297,13 +4359,13 @@ var PRICING = {
   "gpt-4-turbo": { input: 10, output: 30 },
   "gpt-4": { input: 30, output: 60 },
   "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
-  // Google Gemini (December 2025)
+  // Google Gemini (January 2026)
   "gemini-3-pro-preview": { input: 2, output: 12 },
   // New Gemini 3
   "gemini-3-flash-preview": { input: 0.5, output: 3 },
   // For prompts ≤200K tokens, 2x for >200K
-  "gemini-2.5-flash": { input: 0.15, output: 0.6 },
-  // Standard mode (thinking disabled: $0.60, thinking enabled: $3.50)
+  "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+  // Paid tier: $0.30 input (text/image/video), $2.50 output (includes thinking)
   "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
   "gemini-2.0-flash": { input: 0.1, output: 0.4 },
   "gemini-2.0-flash-lite": { input: 0.075, output: 0.3 },
@@ -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;
@@ -7272,8 +7335,15 @@ Please try rephrasing your request or contact support.
         }
         await streamDelay();
       }
+      const cappedToolInput = { ...toolInput };
+      if (cappedToolInput.limit !== void 0 && cappedToolInput.limit > MAX_COMPONENT_QUERY_LIMIT) {
+        logger.info(`[${providerName}] Capping external tool limit from ${cappedToolInput.limit} to ${MAX_COMPONENT_QUERY_LIMIT}`);
+        cappedToolInput.limit = MAX_COMPONENT_QUERY_LIMIT;
+      } else if (cappedToolInput.limit === void 0) {
+        cappedToolInput.limit = MAX_COMPONENT_QUERY_LIMIT;
+      }
       const result = await withProgressHeartbeat(
-        () => externalTool.fn(toolInput),
+        () => externalTool.fn(cappedToolInput),
         `Running ${externalTool.name}`,
         streamBuffer
       );
@@ -7287,7 +7357,7 @@ Please try rephrasing your request or contact support.
         this.executedToolsList.push({
           id: externalTool.id,
           name: externalTool.name,
-          params: toolInput,
+          params: cappedToolInput,
           result: {
             _totalRecords: formattedForTracking.summary.totalRecords,
             _recordsShown: formattedForTracking.summary.recordsShown,
@@ -8162,8 +8232,12 @@ ${executedToolsText}`);
         if (deferredTools.length > 0) {
           logger.info(`[${this.getProviderName()}] Passing ${deferredTools.length} deferred tools for Form generation`);
         }
+        const sanitizedTextResponse = textResponse.replace(
+          /<DataTable>[\s\S]*?<\/DataTable>/g,
+          "<DataTable>[Data preview removed - for table components, REUSE the exact SQL query shown above (the one that returned these results). Do NOT write a new query or embed data in props.]</DataTable>"
+        );
         const matchResult = await this.matchComponentsFromAnalysis(
-          textResponse,
+          sanitizedTextResponse,
           components,
           userPrompt,
           apiKey,
@@ -12212,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";
@@ -12258,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);
@@ -12336,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,
@@ -12352,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,
@@ -12359,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`);
     }
@@ -12476,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,
@@ -12624,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"));
@@ -13872,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) {