@superatomai/sdk-node 0.0.12 → 0.0.13

package/dist/index.mjs

@@ -3708,14 +3708,14 @@ var BaseLLM = class {
    * Takes a text response with component suggestions (c1:type format) and matches with available components
    * Also generates title, description, and intelligent follow-up questions (actions) based on the analysis
    * All components are placed in a default MultiComponentContainer layout
-   * @param textResponse - The text response containing component suggestions
+   * @param analysisContent - The text response containing component suggestions
    * @param components - List of available components
    * @param apiKey - Optional API key
    * @param logCollector - Optional log collector
    * @param componentStreamCallback - Optional callback to stream primary KPI component as soon as it's identified
    * @returns Object containing matched components, layout title/description, and follow-up actions
    */
-  async matchComponentsFromTextResponse(textResponse, components, apiKey, logCollector) {
+  async matchComponentsFromAnalysis(analysisContent, components, apiKey, logCollector, componentStreamCallback) {
     try {
       logger.debug(`[${this.getProviderName()}] Starting component matching from text response`);
       let availableComponentsText = "No components available";
@@ -3732,14 +3732,94 @@ var BaseLLM = class {
         }).join("\n\n");
       }
       const schemaDoc = schema.generateSchemaDocumentation();
+      logger.file("\n=============================\nText analysis response:", analysisContent);
       const prompts = await promptLoader.loadPrompts("match-text-components", {
-        TEXT_RESPONSE: textResponse,
+        ANALYSIS_CONTENT: analysisContent,
         AVAILABLE_COMPONENTS: availableComponentsText,
         SCHEMA_DOC: schemaDoc
       });
       logger.debug(`[${this.getProviderName()}] Loaded match-text-components prompts`);
       logger.file("\n=============================\nmatch text components system prompt:", prompts.system);
       logCollector?.info("Matching components from text response...");
+      let fullResponseText = "";
+      let answerComponentExtracted = false;
+      const answerCallback = componentStreamCallback;
+      const partialCallback = answerCallback ? (chunk) => {
+        fullResponseText += chunk;
+        if (!answerComponentExtracted && answerCallback) {
+          const hasAnswerComponentMatch = fullResponseText.match(/"hasAnswerComponent"\s*:\s*(true|false)/);
+          if (!hasAnswerComponentMatch || hasAnswerComponentMatch[1] !== "true") {
+            return;
+          }
+          const answerComponentStartMatch = fullResponseText.match(/"answerComponent"\s*:\s*\{/);
+          if (!answerComponentStartMatch) {
+            return;
+          }
+          const startPos = answerComponentStartMatch.index + answerComponentStartMatch[0].length - 1;
+          let braceDepth = 0;
+          let inString = false;
+          let escapeNext = false;
+          let endPos = -1;
+          for (let i = startPos; i < fullResponseText.length; i++) {
+            const char = fullResponseText[i];
+            if (escapeNext) {
+              escapeNext = false;
+              continue;
+            }
+            if (char === "\\") {
+              escapeNext = true;
+              continue;
+            }
+            if (char === '"') {
+              inString = !inString;
+              continue;
+            }
+            if (!inString) {
+              if (char === "{") {
+                braceDepth++;
+              } else if (char === "}") {
+                braceDepth--;
+                if (braceDepth === 0) {
+                  endPos = i + 1;
+                  break;
+                }
+              }
+            }
+          }
+          if (endPos > startPos) {
+            const answerComponentString = fullResponseText.substring(startPos, endPos);
+            try {
+              const answerComponentData = JSON.parse(answerComponentString);
+              if (answerComponentData && answerComponentData.componentId) {
+                const originalComponent = components.find((c) => c.id === answerComponentData.componentId);
+                if (originalComponent) {
+                  const answerComponent = {
+                    ...originalComponent,
+                    props: {
+                      ...originalComponent.props,
+                      ...answerComponentData.props
+                    }
+                  };
+                  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}`);
+                  if (answerComponentData.props?.query) {
+                    logCollector?.logQuery(
+                      "Answer component query",
+                      answerComponentData.props.query,
+                      { componentName: answerComponent.name, componentType: answerComponent.type, reasoning: answerComponentData.reasoning }
+                    );
+                  }
+                  answerCallback(answerComponent);
+                  answerComponentExtracted = true;
+                }
+              }
+            } catch (e) {
+              logger.debug(`[${this.getProviderName()}] Partial answerComponent parse failed, waiting for more data...`);
+            }
+          }
+        }
+      } : void 0;
       const result = await LLM.stream(
         {
           sys: prompts.system,
@@ -3749,23 +3829,54 @@ var BaseLLM = class {
           model: this.model,
           maxTokens: 3e3,
           temperature: 0.2,
-          apiKey: this.getApiKey(apiKey)
+          apiKey: this.getApiKey(apiKey),
+          partial: partialCallback
         },
         true
         // Parse as JSON
       );
       logger.debug(`[${this.getProviderName()}] Component matching response parsed successfully`);
+      const componentSuggestionPattern = /c\d+:(\w+)\s*:\s*(.+)/g;
+      const suggestedComponents = [];
+      let match;
+      while ((match = componentSuggestionPattern.exec(analysisContent)) !== null) {
+        suggestedComponents.push({
+          type: match[1],
+          reasoning: match[2].trim()
+        });
+      }
       const matchedComponents = result.matchedComponents || [];
       const layoutTitle = result.layoutTitle || "Dashboard";
       const layoutDescription = result.layoutDescription || "Multi-component dashboard";
+      logger.info(`[${this.getProviderName()}] \u{1F4CA} Component Suggestions from Text Analysis: ${suggestedComponents.length}`);
+      suggestedComponents.forEach((comp, idx) => {
+        logger.info(`[${this.getProviderName()}]   c${idx + 1}: ${comp.type} - ${comp.reasoning}`);
+      });
+      logger.info(`[${this.getProviderName()}] \u{1F4E6} Matched Components from LLM: ${matchedComponents.length}`);
+      matchedComponents.forEach((comp, idx) => {
+        logger.info(`[${this.getProviderName()}]   ${idx + 1}. ${comp.componentType} (${comp.componentName}) - ${comp.originalSuggestion || "N/A"}`);
+      });
+      if (suggestedComponents.length !== matchedComponents.length) {
+        logger.warn(`[${this.getProviderName()}] \u26A0\uFE0F MISMATCH: Text suggested ${suggestedComponents.length} components, but LLM matched ${matchedComponents.length}`);
+      }
+      logger.file("\n=============================\nFull LLM response:", JSON.stringify(result, null, 2));
       const rawActions = result.actions || [];
       const actions = convertQuestionsToActions(rawActions);
       logger.info(`[${this.getProviderName()}] Matched ${matchedComponents.length} components from text response`);
       logger.info(`[${this.getProviderName()}] Layout title: "${layoutTitle}"`);
       logger.info(`[${this.getProviderName()}] Layout description: "${layoutDescription}"`);
       logger.info(`[${this.getProviderName()}] Generated ${actions.length} follow-up actions`);
+      if (suggestedComponents.length > 0) {
+        logCollector?.info(`\u{1F4DD} Text Analysis suggested ${suggestedComponents.length} dashboard components:`);
+        suggestedComponents.forEach((comp, idx) => {
+          logCollector?.info(`  c${idx + 1}: ${comp.type} - ${comp.reasoning}`);
+        });
+      }
       if (matchedComponents.length > 0) {
-        logCollector?.info(`Matched ${matchedComponents.length} components for visualization`);
+        logCollector?.info(`\u{1F4E6} Matched ${matchedComponents.length} components for dashboard`);
+        if (suggestedComponents.length !== matchedComponents.length) {
+          logCollector?.warn(`\u26A0\uFE0F Component count mismatch: Suggested ${suggestedComponents.length}, but matched ${matchedComponents.length}`);
+        }
         logCollector?.info(`Dashboard: "${layoutTitle}"`);
         matchedComponents.forEach((comp, idx) => {
           logCollector?.info(`  ${idx + 1}. ${comp.componentName} (${comp.componentType}): ${comp.reasoning}`);
@@ -4240,11 +4351,17 @@ ${errorMsg}
       let actions = [];
       if (components && components.length > 0) {
         logger.info(`[${this.getProviderName()}] Matching components from text response...`);
-        const matchResult = await this.matchComponentsFromTextResponse(
+        const componentStreamCallback = wrappedStreamCallback ? (component) => {
+          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;
+        const matchResult = await this.matchComponentsFromAnalysis(
           textResponse,
           components,
           apiKey,
-          logCollector
+          logCollector,
+          componentStreamCallback
         );
         matchedComponents = matchResult.components;
         layoutTitle = matchResult.layoutTitle;
@@ -5119,7 +5236,6 @@ function sendDataResponse4(id, res, sendMessage, clientId) {
       ...res
     }
   };
-  logger.info("sending user prompt response", response);
   sendMessage(response);
 }