@superatomai/sdk-node 0.0.49 → 0.0.52

package/dist/index.js

@@ -5720,26 +5720,27 @@ ${JSON.stringify(tool.requiredFields || [], null, 2)}`;
       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) => {
-          let resultPreview = "No result data";
-          if (tool.result) {
-            const resultStr = typeof tool.result === "string" ? tool.result : JSON.stringify(tool.result, null, 2);
-            resultPreview = resultStr.length > 2e3 ? resultStr.substring(0, 2e3) + "\n... (truncated)" : resultStr;
-          }
           let outputSchemaText = "Not available";
+          let recordCount = "unknown";
           if (tool.outputSchema) {
             const fields = tool.outputSchema.fields || [];
-            const recordCount = tool.result?._recordCount || (Array.isArray(tool.result) ? tool.result.length : "unknown");
-            outputSchemaText = `Returns ARRAY of ${recordCount} records. ${tool.outputSchema.description}
-   Fields in EACH ROW (these are per-row values, NOT aggregates):
-${fields.map((f) => `     - ${f.name} (${f.type}): ${f.description}`).join("\n")}
-   NOTE: For aggregate values (SUM, COUNT, AVG across all rows), write SQL query instead.`;
+            recordCount = tool.result?._recordCount || (Array.isArray(tool.result) ? tool.result.length : "unknown");
+            const fieldsText = fields.map(
+              (f) => `     - name: "${f.name}"  \u2190 USE THIS EXACT VALUE in config
+       type: ${f.type}
+       description: ${f.description}`
+            ).join("\n");
+            outputSchemaText = `${tool.outputSchema.description}
+   Fields (use the "name" value in your config):
+${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)
+   recordCount: ${recordCount} rows returned
    outputSchema: ${outputSchemaText}
-   result preview: ${resultPreview}`;
+   \u26A0\uFE0F DO NOT embed this tool's data in SQL - use externalTool prop OR query database tables`;
         }).join("\n\n");
       }
       const schemaDoc = schema.generateSchemaDocumentation();
@@ -5880,11 +5881,111 @@ ${fields.map((f) => `     - ${f.name} (${f.type}): ${f.description}`).join("\n")
           logger.warn(`[${this.getProviderName()}] Component ${mc.componentId} not found in available components`);
           return null;
         }
+        let cleanedProps = { ...mc.props };
+        if (cleanedProps.externalTool) {
+          const toolId = cleanedProps.externalTool.toolId;
+          const validToolIds = (executedTools || []).map((t) => t.id);
+          const isValidTool = toolId && typeof toolId === "string" && validToolIds.includes(toolId);
+          if (!isValidTool) {
+            logger.warn(`[${this.getProviderName()}] externalTool.toolId "${toolId}" not found in executed tools [${validToolIds.join(", ")}], setting to null`);
+            cleanedProps.externalTool = null;
+          } else {
+            const executedTool = executedTools?.find((t) => t.id === toolId);
+            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) => {
+                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 });
+                  }
+                }
+                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;
+                  }
+                }
+                return null;
+              };
+              const configFieldsToValidate = [
+                "xAxisKey",
+                "yAxisKey",
+                "valueKey",
+                "nameKey",
+                "labelKey",
+                "groupBy",
+                "aggregationField",
+                "seriesKey",
+                "sizeKey",
+                "xAggregationField",
+                "yAggregationField"
+              ];
+              for (const configKey of configFieldsToValidate) {
+                const fieldValue = cleanedProps.config[configKey];
+                if (fieldValue && typeof fieldValue === "string") {
+                  if (!validFieldNames.includes(fieldValue)) {
+                    const correctedField = findMatchingField(fieldValue);
+                    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(", ")}]`);
+                    }
+                  }
+                }
+              }
+              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);
+                    if (correctedField) {
+                      logger.warn(`[${this.getProviderName()}] Correcting series.dataKey: "${s.dataKey}" \u2192 "${correctedField}"`);
+                      return { ...s, dataKey: correctedField };
+                    }
+                  }
+                  return s;
+                });
+              }
+            }
+          }
+        }
+        if (cleanedProps.query) {
+          const queryStr = typeof cleanedProps.query === "string" ? cleanedProps.query : cleanedProps.query?.sql || "";
+          if (queryStr.includes("OPENJSON") || queryStr.includes("JSON_VALUE")) {
+            logger.warn(`[${this.getProviderName()}] Query contains OPENJSON/JSON_VALUE (invalid - cannot parse tool result), setting query to null`);
+            cleanedProps.query = null;
+          }
+        }
+        if (cleanedProps.query && cleanedProps.externalTool) {
+          logger.info(`[${this.getProviderName()}] Both query and externalTool exist, keeping both - frontend will decide`);
+        }
         return {
           ...originalComponent,
           props: {
             ...originalComponent.props,
-            ...mc.props
+            ...cleanedProps
           }
         };
       }).filter(Boolean);