@flutchai/flutch-sdk 0.1.6 → 0.1.8

package/dist/index.cjs

@@ -3076,9 +3076,6 @@ var _AbstractGraphBuilder = class _AbstractGraphBuilder {
     if (this.manifest?.companySlug && this.manifest?.name) {
       return `${this.manifest.companySlug}.${this.manifest.name}::${this.version}`;
     }
-    console.log(
-      `DEBUG graphType: manifest=${!!this.manifest}, companySlug=${this.manifest?.companySlug}, name=${this.manifest?.name}, version=${this.version}`
-    );
     return `unknown::${this.version}`;
   }
   /**
@@ -3410,6 +3407,9 @@ exports.UniversalGraphService = class UniversalGraphService {
     this.engine = engine;
     this.endpointRegistry = endpointRegistry;
     this.logger.log("UniversalGraphService initialized");
+    if (!this.engine) {
+      this.logger.error("GRAPH_ENGINE is not properly injected!");
+    }
   }
   logger = new common.Logger(exports.UniversalGraphService.name);
   /**
@@ -4405,11 +4405,11 @@ function sanitizeTraceError(error, options) {
     raw: sanitizeTraceData(error, 0, /* @__PURE__ */ new WeakSet(), options)
   };
 }
-var GraphEngineType = /* @__PURE__ */ ((GraphEngineType2) => {
-  GraphEngineType2["LANGGRAPH"] = "langgraph";
-  GraphEngineType2["LANGFLOW"] = "langflow";
-  GraphEngineType2["FLOWISE"] = "flowise";
-  return GraphEngineType2;
+var GraphEngineType = /* @__PURE__ */ ((GraphEngineType3) => {
+  GraphEngineType3["LANGGRAPH"] = "langgraph";
+  GraphEngineType3["LANGFLOW"] = "langflow";
+  GraphEngineType3["FLOWISE"] = "flowise";
+  return GraphEngineType3;
 })(GraphEngineType || {});
 exports.GraphEngineFactory = class GraphEngineFactory {
   constructor(langgraph) {
@@ -4448,7 +4448,9 @@ exports.EventProcessor = class EventProcessor {
       llmCalls: [],
       traceEvents: [],
       traceStartedAt: null,
-      traceCompletedAt: null
+      traceCompletedAt: null,
+      currentReasoningSteps: [],
+      currentToolUse: null
     };
   }
   /**
@@ -4476,6 +4478,51 @@ exports.EventProcessor = class EventProcessor {
     }
     return [];
   }
+  /**
+   * Groups tool_use and input_json_delta into proper structure
+   * tool_use.input → output (tool execution result)
+   * input_json_delta.input → output (tool execution result, accumulated)
+   */
+  mapReasoningSteps(rawSteps) {
+    const steps = [];
+    let currentToolUse = null;
+    for (const raw of rawSteps) {
+      if (raw.type === "tool_use" || raw.type === "tool_call") {
+        if (currentToolUse) {
+          steps.push(currentToolUse);
+        }
+        currentToolUse = {
+          index: raw.index || 0,
+          type: "tool_use",
+          name: raw.name,
+          id: raw.id,
+          input: "",
+          // Parameters (IN) - filled separately or empty
+          output: raw.input || ""
+          // Result (OUT) - comes in tool_use.input
+        };
+      } else if (raw.type === "input_json_delta") {
+        if (currentToolUse) {
+          currentToolUse.output = (currentToolUse.output || "") + (raw.input || "");
+        }
+      } else {
+        if (currentToolUse) {
+          steps.push(currentToolUse);
+          currentToolUse = null;
+        }
+        steps.push({
+          index: raw.index || 0,
+          type: raw.type,
+          text: raw.text || "",
+          metadata: raw.metadata
+        });
+      }
+    }
+    if (currentToolUse) {
+      steps.push(currentToolUse);
+    }
+    return steps;
+  }
   /**
    * Process a LangGraph stream event
    * Mutates accumulator to collect data from different channels
@@ -4498,8 +4545,44 @@ exports.EventProcessor = class EventProcessor {
     if (event.event === "on_chat_model_stream" && event.metadata?.stream_channel === "processing" /* PROCESSING */ && event.data?.chunk?.content) {
       const chunk = event.data.chunk.content;
       const blocks = this.normalizeContentBlocks(chunk);
-      if (blocks.length > 0 && onPartial) {
-        onPartial(JSON.stringify({ processing: blocks }));
+      for (const block of blocks) {
+        if (block.type === "tool_use" || block.type === "tool_call") {
+          if (acc.currentToolUse) {
+            acc.currentReasoningSteps.push(acc.currentToolUse);
+          }
+          acc.currentToolUse = {
+            index: acc.currentReasoningSteps.length,
+            type: "tool_use",
+            name: block.name,
+            id: block.id,
+            input: block.input || "",
+            output: ""
+          };
+          if (onPartial) {
+            onPartial(
+              JSON.stringify({
+                processing_delta: {
+                  type: "step_started",
+                  step: acc.currentToolUse
+                }
+              })
+            );
+          }
+        } else if (block.type === "input_json_delta") {
+          if (acc.currentToolUse && onPartial) {
+            const chunk2 = block.input || "";
+            acc.currentToolUse.output += chunk2;
+            onPartial(
+              JSON.stringify({
+                processing_delta: {
+                  type: "output_chunk",
+                  stepId: acc.currentToolUse.id,
+                  chunk: chunk2
+                }
+              })
+            );
+          }
+        }
       }
       return;
     }
@@ -4536,29 +4619,59 @@ exports.EventProcessor = class EventProcessor {
         );
       }
       if (event.metadata?.stream_channel === "processing" /* PROCESSING */) {
-        const stepsRaw = output?.content || // AIMessageChunk object (direct)
-        output?.kwargs?.content || // Serialized LangChain format
-        event.data?.chunk?.content || // Older version
-        [];
-        let steps;
-        if (Array.isArray(stepsRaw)) {
-          steps = stepsRaw;
-        } else if (typeof stepsRaw === "string" && stepsRaw.trim().length > 0) {
-          steps = [
-            {
-              index: 0,
-              type: "text",
-              text: stepsRaw.trim()
-            }
-          ];
-        } else {
-          steps = [];
+        if (acc.currentToolUse) {
+          acc.currentReasoningSteps.push(acc.currentToolUse);
+          acc.currentToolUse = null;
         }
-        if (steps.length > 0) {
+        if (acc.currentReasoningSteps.length > 0) {
           acc.reasoningChains.push({
-            steps,
+            steps: acc.currentReasoningSteps,
             isComplete: true
           });
+          if (onPartial) {
+            onPartial(
+              JSON.stringify({
+                processing_delta: {
+                  type: "chain_completed"
+                }
+              })
+            );
+          }
+          acc.currentReasoningSteps = [];
+        } else {
+          const stepsRaw = output?.content || // AIMessageChunk object (direct)
+          output?.kwargs?.content || // Serialized LangChain format
+          event.data?.chunk?.content || // Older version
+          [];
+          let steps;
+          if (Array.isArray(stepsRaw)) {
+            steps = this.mapReasoningSteps(stepsRaw);
+          } else if (typeof stepsRaw === "string" && stepsRaw.trim().length > 0) {
+            steps = [
+              {
+                index: 0,
+                type: "text",
+                text: stepsRaw.trim()
+              }
+            ];
+          } else {
+            steps = [];
+          }
+          if (steps.length > 0) {
+            acc.reasoningChains.push({
+              steps,
+              isComplete: true
+            });
+            if (onPartial) {
+              onPartial(
+                JSON.stringify({
+                  processing_delta: {
+                    type: "chain_completed"
+                  }
+                })
+              );
+            }
+          }
         }
       }
       return;
@@ -4742,6 +4855,9 @@ exports.LangGraphEngine = class LangGraphEngine {
   constructor(eventProcessor, configService) {
     this.eventProcessor = eventProcessor;
     this.configService = configService;
+    if (!eventProcessor) {
+      this.logger.error("EventProcessor is undefined/null!");
+    }
   }
   logger = new common.Logger(exports.LangGraphEngine.name);
   /**
@@ -4844,8 +4960,8 @@ exports.LangGraphEngine = class LangGraphEngine {
    */
   async sendMetricsWebhook(payload) {
     try {
-      const backendUrl = this.configService.get("API_URL") || "http://amelie-service";
-      const internalToken = this.configService.get("INTERNAL_API_TOKEN");
+      const backendUrl = this.configService?.get("API_URL") || "http://amelie-service";
+      const internalToken = this.configService?.get("INTERNAL_API_TOKEN");
       if (!internalToken) {
         this.logger.warn(
           "[METRICS-WEBHOOK] INTERNAL_API_TOKEN not configured, skipping webhook"
@@ -4884,8 +5000,8 @@ exports.LangGraphEngine = class LangGraphEngine {
   }
   async sendTraceEventsBatch(payload) {
     try {
-      const backendUrl = this.configService.get("API_URL") || "http://amelie-service";
-      const internalToken = this.configService.get("INTERNAL_API_TOKEN");
+      const backendUrl = this.configService?.get("API_URL") || "http://amelie-service";
+      const internalToken = this.configService?.get("INTERNAL_API_TOKEN");
       if (!internalToken) {
         this.logger.warn(
           "[TRACE-EVENTS-BATCH] INTERNAL_API_TOKEN not configured, skipping batch webhook"
@@ -4967,7 +5083,8 @@ exports.LangGraphEngine = class LangGraphEngine {
   }
 };
 exports.LangGraphEngine = __decorateClass([
-  common.Injectable()
+  common.Injectable(),
+  __decorateParam(1, common.Optional())
 ], exports.LangGraphEngine);
 
 // src/core/universal-graph.module.ts
@@ -5043,9 +5160,16 @@ exports.UniversalGraphModule = class UniversalGraphModule {
       // Discovery services from @nestjs/core
       core.MetadataScanner,
       // Event processor for stream handling
-      exports.EventProcessor,
+      {
+        provide: exports.EventProcessor,
+        useFactory: () => new exports.EventProcessor()
+      },
       // Graph engines
-      exports.LangGraphEngine,
+      {
+        provide: exports.LangGraphEngine,
+        useFactory: (eventProcessor) => new exports.LangGraphEngine(eventProcessor, void 0),
+        inject: [exports.EventProcessor]
+      },
       exports.BuilderRegistryService,
       exports.GraphEngineFactory,
       exports.VersionedGraphService,
@@ -5151,12 +5275,8 @@ exports.UniversalGraphModule = class UniversalGraphModule {
       },
       {
         provide: "GRAPH_ENGINE",
-        useFactory: (factory) => {
-          return factory.getEngine(
-            options.engineType || "langgraph" /* LANGGRAPH */
-          );
-        },
-        inject: [exports.GraphEngineFactory]
+        useFactory: (langGraphEngine) => langGraphEngine,
+        inject: [exports.LangGraphEngine]
       },
       {
         provide: "GRAPH_BUILDERS",