@flutchai/flutch-sdk 0.1.6 → 0.1.8

package/dist/index.d.cts

@@ -211,9 +211,13 @@ type CitationValue = {
 
 interface IReasoningStep {
     index: number;
-    type: "text" | "tool_call" | "tool_result" | "thinking" | "tool_use";
+    type: "text" | "tool_use";
     text?: string;
     metadata?: Record<string, any>;
+    name?: string;
+    id?: string;
+    input?: string;
+    output?: string;
 }
 interface IReasoningChain {
     steps: IReasoningStep[];
@@ -1120,11 +1124,14 @@ interface StreamAccumulator {
     traceEvents: IGraphTraceEvent[];
     traceStartedAt: number | null;
     traceCompletedAt: number | null;
+    currentReasoningSteps: IReasoningStep[];
+    currentToolUse: IReasoningStep | null;
 }
 declare class EventProcessor {
     private readonly logger;
     createAccumulator(): StreamAccumulator;
     private normalizeContentBlocks;
+    private mapReasoningSteps;
     processEvent(acc: StreamAccumulator, event: any, onPartial?: (chunk: string) => void): void;
     getResult(acc: StreamAccumulator): {
         content: IStoredMessageContent;
@@ -1155,9 +1162,9 @@ declare class EventProcessor {
 
 declare class LangGraphEngine implements IGraphEngine {
     private readonly eventProcessor;
-    private readonly configService;
+    private readonly configService?;
     private readonly logger;
-    constructor(eventProcessor: EventProcessor, configService: ConfigService);
+    constructor(eventProcessor: EventProcessor, configService?: ConfigService);
     invokeGraph(graph: any, config: any, signal?: AbortSignal): Promise<any>;
     streamGraph(graph: any, config: any, onPartial: (chunk: string) => void, signal?: AbortSignal): Promise<any>;
     private sendMetricsWebhook;

package/dist/index.d.ts

@@ -211,9 +211,13 @@ type CitationValue = {
 
 interface IReasoningStep {
     index: number;
-    type: "text" | "tool_call" | "tool_result" | "thinking" | "tool_use";
+    type: "text" | "tool_use";
     text?: string;
     metadata?: Record<string, any>;
+    name?: string;
+    id?: string;
+    input?: string;
+    output?: string;
 }
 interface IReasoningChain {
     steps: IReasoningStep[];
@@ -1120,11 +1124,14 @@ interface StreamAccumulator {
     traceEvents: IGraphTraceEvent[];
     traceStartedAt: number | null;
     traceCompletedAt: number | null;
+    currentReasoningSteps: IReasoningStep[];
+    currentToolUse: IReasoningStep | null;
 }
 declare class EventProcessor {
     private readonly logger;
     createAccumulator(): StreamAccumulator;
     private normalizeContentBlocks;
+    private mapReasoningSteps;
     processEvent(acc: StreamAccumulator, event: any, onPartial?: (chunk: string) => void): void;
     getResult(acc: StreamAccumulator): {
         content: IStoredMessageContent;
@@ -1155,9 +1162,9 @@ declare class EventProcessor {
 
 declare class LangGraphEngine implements IGraphEngine {
     private readonly eventProcessor;
-    private readonly configService;
+    private readonly configService?;
     private readonly logger;
-    constructor(eventProcessor: EventProcessor, configService: ConfigService);
+    constructor(eventProcessor: EventProcessor, configService?: ConfigService);
     invokeGraph(graph: any, config: any, signal?: AbortSignal): Promise<any>;
     streamGraph(graph: any, config: any, onPartial: (chunk: string) => void, signal?: AbortSignal): Promise<any>;
     private sendMetricsWebhook;

package/dist/index.js

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { Injectable, Post, UseGuards, Req, Controller, Inject, Get, Body, Res, Param, Logger, Module, UnauthorizedException, Optional, Headers, NotFoundException, InternalServerErrorException, ForbiddenException, ValidationPipe, HttpException, HttpStatus } from '@nestjs/common';
+import { Injectable, Post, UseGuards, Req, Controller, Inject, Get, Body, Res, Param, Logger, Optional, Module, UnauthorizedException, Headers, NotFoundException, InternalServerErrorException, ForbiddenException, ValidationPipe, HttpException, HttpStatus } from '@nestjs/common';
 import { ApiOperation, ApiResponse, ApiTags, ApiParam, DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 import * as fs from 'fs';
 import * as path2 from 'path';
@@ -3047,9 +3047,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}`;
   }
   /**
@@ -3381,6 +3378,9 @@ var UniversalGraphService = class {
     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 Logger(UniversalGraphService.name);
   /**
@@ -4376,11 +4376,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 || {});
 var GraphEngineFactory = class {
   constructor(langgraph) {
@@ -4419,7 +4419,9 @@ var EventProcessor = class {
       llmCalls: [],
       traceEvents: [],
       traceStartedAt: null,
-      traceCompletedAt: null
+      traceCompletedAt: null,
+      currentReasoningSteps: [],
+      currentToolUse: null
     };
   }
   /**
@@ -4447,6 +4449,51 @@ var EventProcessor = class {
     }
     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
@@ -4469,8 +4516,44 @@ var EventProcessor = class {
     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;
     }
@@ -4507,29 +4590,59 @@ var EventProcessor = class {
         );
       }
       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;
@@ -4713,6 +4826,9 @@ var LangGraphEngine = class {
   constructor(eventProcessor, configService) {
     this.eventProcessor = eventProcessor;
     this.configService = configService;
+    if (!eventProcessor) {
+      this.logger.error("EventProcessor is undefined/null!");
+    }
   }
   logger = new Logger(LangGraphEngine.name);
   /**
@@ -4815,8 +4931,8 @@ var LangGraphEngine = class {
    */
   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"
@@ -4855,8 +4971,8 @@ var LangGraphEngine = class {
   }
   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"
@@ -4938,7 +5054,8 @@ var LangGraphEngine = class {
   }
 };
 LangGraphEngine = __decorateClass([
-  Injectable()
+  Injectable(),
+  __decorateParam(1, Optional())
 ], LangGraphEngine);
 
 // src/core/universal-graph.module.ts
@@ -5014,9 +5131,16 @@ var UniversalGraphModule = class {
       // Discovery services from @nestjs/core
       MetadataScanner,
       // Event processor for stream handling
-      EventProcessor,
+      {
+        provide: EventProcessor,
+        useFactory: () => new EventProcessor()
+      },
       // Graph engines
-      LangGraphEngine,
+      {
+        provide: LangGraphEngine,
+        useFactory: (eventProcessor) => new LangGraphEngine(eventProcessor, void 0),
+        inject: [EventProcessor]
+      },
       BuilderRegistryService,
       GraphEngineFactory,
       VersionedGraphService,
@@ -5122,12 +5246,8 @@ var UniversalGraphModule = class {
       },
       {
         provide: "GRAPH_ENGINE",
-        useFactory: (factory) => {
-          return factory.getEngine(
-            options.engineType || "langgraph" /* LANGGRAPH */
-          );
-        },
-        inject: [GraphEngineFactory]
+        useFactory: (langGraphEngine) => langGraphEngine,
+        inject: [LangGraphEngine]
       },
       {
         provide: "GRAPH_BUILDERS",