@superatomai/sdk-node 0.0.63 → 0.0.64

package/dist/index.mjs

@@ -6321,11 +6321,11 @@ Fixed SQL query:`;
         logger.info(`[${this.getProviderName()}] Passing ${deferredTools.length} deferred tools to component matching`);
         deferredToolsText = "The following external tools need user input via a Form component.\n**IMPORTANT: Use these EXACT values when generating Form externalTool prop.**\n\n" + deferredTools.map((tool, idx) => {
           return `${idx + 1}. **${tool.name}**
-   toolId: "${tool.id}" (USE THIS EXACT VALUE - do not modify!)
-   toolName: "${tool.name}"
-   parameters: ${JSON.stringify(tool.params || {})}
-   requiredFields:
-${JSON.stringify(tool.requiredFields || [], null, 2)}`;
+							toolId: "${tool.id}" (USE THIS EXACT VALUE - do not modify!)
+							toolName: "${tool.name}"
+							parameters: ${JSON.stringify(tool.params || {})}
+							requiredFields:
+							${JSON.stringify(tool.requiredFields || [], null, 2)}`;
         }).join("\n\n");
       }
       let executedToolsText = "No external tools were executed for data fetching.";
@@ -6341,8 +6341,8 @@ ${JSON.stringify(tool.requiredFields || [], null, 2)}`;
             const numericFields = fields.filter((f) => f.type === "number").map((f) => f.name);
             const stringFields = fields.filter((f) => f.type === "string").map((f) => f.name);
             fieldNamesList = `
-   \u{1F4CA} NUMERIC FIELDS (use for yAxisKey, valueKey, aggregationField): ${numericFields.join(", ") || "none"}
-   \u{1F4DD} STRING FIELDS (use for xAxisKey, groupBy, nameKey): ${stringFields.join(", ") || "none"}`;
+							\u{1F4CA} NUMERIC FIELDS (use for yAxisKey, valueKey, aggregationField): ${numericFields.join(", ") || "none"}
+							\u{1F4DD} STRING FIELDS (use for xAxisKey, groupBy, nameKey): ${stringFields.join(", ") || "none"}`;
             const fieldsText = fields.map(
               (f) => `     "${f.name}" (${f.type}): ${f.description}`
             ).join("\n");
@@ -6351,11 +6351,11 @@ ${JSON.stringify(tool.requiredFields || [], null, 2)}`;
 ${fieldsText}`;
           }
           return `${idx + 1}. **${tool.name}**
-   toolId: "${tool.id}"
-   toolName: "${tool.name}"
-   parameters: ${JSON.stringify(tool.params || {})}
-   recordCount: ${recordCount} rows returned
-   outputSchema: ${outputSchemaText}${fieldNamesList}`;
+							toolId: "${tool.id}"
+							toolName: "${tool.name}"
+							parameters: ${JSON.stringify(tool.params || {})}
+							recordCount: ${recordCount} rows returned
+							outputSchema: ${outputSchemaText}${fieldNamesList}`;
         }).join("\n\n");
       }
       const schemaDoc = schema.generateSchemaDocumentation();
@@ -6406,6 +6406,7 @@ ${executedToolsText}`);
       logCollector?.info("Matching components from text response...");
       let fullResponseText = "";
       let answerComponentExtracted = false;
+      let validatedAnswerComponent = null;
       const answerCallback = componentStreamCallback;
       const partialCallback = answerCallback ? (chunk) => {
         fullResponseText += chunk;
@@ -6464,8 +6465,8 @@ ${executedToolsText}`);
                     }
                   };
                   const streamTime = (/* @__PURE__ */ new Date()).toISOString();
-                  logger.info(`[${this.getProviderName()}] \u2713 [${streamTime}] Answer component detected in stream: ${answerComponent.name} (${answerComponent.type}) - STREAMING TO FRONTEND NOW`);
-                  logCollector?.info(`\u2713 Answer component: ${answerComponent.name} (${answerComponent.type}) - streaming to frontend at ${streamTime}`);
+                  logger.info(`[${this.getProviderName()}] \u2713 [${streamTime}] Answer component detected in stream: ${answerComponent.name} (${answerComponent.type})`);
+                  logCollector?.info(`\u2713 Answer component: ${answerComponent.name} (${answerComponent.type}) - detected at ${streamTime}`);
                   if (answerComponentData.props?.query) {
                     logCollector?.logQuery(
                       "Answer component query",
@@ -6473,7 +6474,79 @@ ${executedToolsText}`);
                       { componentName: answerComponent.name, componentType: answerComponent.type, reasoning: answerComponentData.reasoning }
                     );
                   }
-                  answerCallback(answerComponent);
+                  const answerQuery = answerComponent.props?.query;
+                  logger.info(`[${this.getProviderName()}] Answer component detected: ${answerComponent.name} (${answerComponent.type}), hasQuery: ${!!answerQuery}, hasDbExecute: ${!!collections?.["database"]?.["execute"]}`);
+                  if (answerQuery && collections?.["database"]?.["execute"]) {
+                    (async () => {
+                      const MAX_RETRIES = 3;
+                      let attempts = 0;
+                      let validated = false;
+                      let currentQuery = answerQuery;
+                      let currentQueryStr = typeof answerQuery === "string" ? answerQuery : answerQuery?.sql || "";
+                      let lastError = "";
+                      logger.info(`[${this.getProviderName()}] Validating answer component query before streaming...`);
+                      while (attempts < MAX_RETRIES && !validated) {
+                        attempts++;
+                        try {
+                          const cacheKey = this.getQueryCacheKey(currentQuery);
+                          if (cacheKey) {
+                            logger.debug(`[${this.getProviderName()}] Answer component query validation attempt ${attempts}/${MAX_RETRIES}`);
+                            const result2 = await collections["database"]["execute"]({ sql: cacheKey });
+                            queryCache.set(cacheKey, result2);
+                            validated = true;
+                            if (currentQuery !== answerQuery) {
+                              answerComponent.props.query = currentQuery;
+                            }
+                            validatedAnswerComponent = {
+                              componentId: answerComponentData.componentId,
+                              validatedQuery: currentQuery
+                            };
+                            logger.info(`[${this.getProviderName()}] \u2713 Answer component query validated (attempt ${attempts}) - STREAMING TO FRONTEND NOW`);
+                            logCollector?.info(`\u2713 Answer component query validated - streaming to frontend`);
+                            logger.info(`[${this.getProviderName()}] Calling answerCallback for: ${answerComponent.name}`);
+                            answerCallback(answerComponent);
+                            logger.info(`[${this.getProviderName()}] answerCallback completed for: ${answerComponent.name}`);
+                          }
+                        } catch (validationError) {
+                          lastError = validationError instanceof Error ? validationError.message : String(validationError);
+                          logger.warn(`[${this.getProviderName()}] Answer component query validation failed (attempt ${attempts}/${MAX_RETRIES}): ${lastError}`);
+                          if (attempts < MAX_RETRIES) {
+                            try {
+                              logger.info(`[${this.getProviderName()}] Requesting LLM to fix answer component query...`);
+                              const fixedQueryStr = await this.requestQueryFix(
+                                currentQueryStr,
+                                lastError,
+                                {
+                                  name: answerComponent.name,
+                                  type: answerComponent.type,
+                                  title: answerComponent.props?.title
+                                },
+                                apiKey
+                              );
+                              if (typeof currentQuery === "string") {
+                                currentQuery = fixedQueryStr;
+                              } else {
+                                currentQuery = { ...currentQuery, sql: fixedQueryStr };
+                              }
+                              currentQueryStr = fixedQueryStr;
+                              logger.info(`[${this.getProviderName()}] LLM provided fixed query for answer component, retrying...`);
+                            } catch (fixError) {
+                              const fixErrorMsg = fixError instanceof Error ? fixError.message : String(fixError);
+                              logger.error(`[${this.getProviderName()}] Failed to get LLM query fix for answer component: ${fixErrorMsg}`);
+                              break;
+                            }
+                          }
+                        }
+                      }
+                      if (!validated) {
+                        logger.warn(`[${this.getProviderName()}] Answer component query validation failed after ${attempts} attempts - skipping early stream`);
+                        logCollector?.warn(`Answer component query validation failed: ${lastError} - will be handled in batch validation`);
+                      }
+                    })();
+                  } else {
+                    logger.info(`[${this.getProviderName()}] Answer component has no query - STREAMING TO FRONTEND NOW`);
+                    answerCallback(answerComponent);
+                  }
                   answerComponentExtracted = true;
                 }
               }
@@ -6527,6 +6600,10 @@ ${executedToolsText}`);
           return null;
         }
         let cleanedProps = { ...mc.props };
+        if (validatedAnswerComponent && mc.componentId === validatedAnswerComponent.componentId) {
+          logger.info(`[${this.getProviderName()}] Using pre-validated query for answer component: ${mc.componentId}`);
+          cleanedProps.query = validatedAnswerComponent.validatedQuery;
+        }
         if (cleanedProps.externalTool) {
           const toolId = cleanedProps.externalTool.toolId;
           const validToolIds = (executedTools || []).map((t) => t.id);
@@ -7572,11 +7649,14 @@ ${errorMsg}
         logger.info(`[${this.getProviderName()}] Generated ${actions.length} follow-up actions for general question`);
       } else if (components && components.length > 0) {
         logger.info(`[${this.getProviderName()}] Matching components from text response...`);
+        logger.info(`[${this.getProviderName()}] componentStreamCallback setup: wrappedStreamCallback=${!!wrappedStreamCallback}, category=${category}`);
         const componentStreamCallback = wrappedStreamCallback && category !== "data_modification" ? (component) => {
+          logger.info(`[${this.getProviderName()}] componentStreamCallback INVOKED for: ${component.name} (${component.type})`);
           const answerMarker = `__ANSWER_COMPONENT_START__${JSON.stringify(component)}__ANSWER_COMPONENT_END__`;
           wrappedStreamCallback(answerMarker);
           logger.info(`[${this.getProviderName()}] Streamed answer component to frontend: ${component.name} (${component.type})`);
         } : void 0;
+        logger.info(`[${this.getProviderName()}] componentStreamCallback created: ${!!componentStreamCallback}`);
         const deferredTools = externalTools?.filter((t) => {
           if (t.executionType === "deferred" && !t.userProvidedData) return true;
           if (category === "data_modification" && !t.userProvidedData) {