@flutchai/flutch-sdk 0.1.9 → 0.1.10

package/dist/index.cjs

@@ -3900,7 +3900,6 @@ var AttachmentType = /* @__PURE__ */ ((AttachmentType2) => {
 var StreamChannel = /* @__PURE__ */ ((StreamChannel2) => {
   StreamChannel2["TEXT"] = "text";
   StreamChannel2["PROCESSING"] = "processing";
-  StreamChannel2["TOOLS"] = "tools";
   return StreamChannel2;
 })(StreamChannel || {});
 
@@ -4443,15 +4442,15 @@ exports.EventProcessor = class EventProcessor {
    */
   createAccumulator() {
     return {
-      streamedText: "",
-      reasoningChains: [],
-      generation: null,
-      llmCalls: [],
+      channels: /* @__PURE__ */ new Map([
+        ["text" /* TEXT */, { contentChain: [], currentBlock: null }],
+        ["processing" /* PROCESSING */, { contentChain: [], currentBlock: null }]
+      ]),
+      attachments: [],
+      metadata: {},
       traceEvents: [],
       traceStartedAt: null,
-      traceCompletedAt: null,
-      currentReasoningSteps: [],
-      currentToolUse: null
+      traceCompletedAt: null
     };
   }
   /**
@@ -4479,10 +4478,88 @@ exports.EventProcessor = class EventProcessor {
     }
     return [];
   }
+  /**
+   * Send delta to UI (unified format)
+   */
+  sendDelta(channel, delta, onPartial) {
+    if (!onPartial) return;
+    onPartial(
+      JSON.stringify({
+        channel,
+        delta
+      })
+    );
+  }
+  /**
+   * Process content stream blocks (universal for all channels)
+   */
+  processContentStream(acc, channel, blocks, onPartial) {
+    const state = acc.channels.get(channel);
+    for (const block of blocks) {
+      if (block.type === "tool_use" || block.type === "tool_call") {
+        if (state.currentBlock) {
+          state.contentChain.push(state.currentBlock);
+        }
+        state.currentBlock = {
+          index: state.contentChain.length,
+          type: "tool_use",
+          name: block.name,
+          id: block.id,
+          input: block.input || "",
+          output: ""
+        };
+        this.sendDelta(
+          channel,
+          {
+            type: "step_started",
+            step: state.currentBlock
+          },
+          onPartial
+        );
+      } else if (block.type === "input_json_delta") {
+        if (state.currentBlock && state.currentBlock.type === "tool_use") {
+          const chunk = block.input || "";
+          state.currentBlock.input += chunk;
+          this.sendDelta(
+            channel,
+            {
+              type: "tool_input_chunk",
+              stepId: state.currentBlock.id,
+              chunk
+            },
+            onPartial
+          );
+        }
+      } else if (block.type === "text") {
+        const textChunk = block.text || "";
+        if (state.currentBlock && state.currentBlock.type === "text") {
+          state.currentBlock.text = (state.currentBlock.text || "") + textChunk;
+        } else {
+          if (state.currentBlock) {
+            state.contentChain.push(state.currentBlock);
+          }
+          state.currentBlock = {
+            index: state.contentChain.length,
+            type: "text",
+            text: textChunk
+          };
+        }
+        this.sendDelta(
+          channel,
+          {
+            type: "text_chunk",
+            text: textChunk
+          },
+          onPartial
+        );
+      }
+    }
+  }
   /**
    * 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)
+   * @deprecated This method is for legacy fallback only
    */
   mapReasoningSteps(rawSteps) {
     const steps = [];
@@ -4531,60 +4608,10 @@ exports.EventProcessor = class EventProcessor {
    */
   processEvent(acc, event, onPartial) {
     this.captureTraceEvent(acc, event);
-    if (event.event === "on_chat_model_stream" && event.metadata?.stream_channel === "text" /* TEXT */ && event.data?.chunk?.content) {
-      const chunk = event.data.chunk.content;
-      const blocks = this.normalizeContentBlocks(chunk);
-      if (blocks.length > 0 && onPartial) {
-        onPartial(JSON.stringify({ text: blocks }));
-      }
-      const textOnly = blocks.filter((block) => block?.type === "text").map((block) => block.text || "").join("");
-      if (textOnly) {
-        acc.streamedText += textOnly;
-      }
-      return;
-    }
-    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);
-      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
-                }
-              })
-            );
-          }
-        }
-      }
+    if (event.event === "on_chat_model_stream" && event.data?.chunk?.content) {
+      const channel = event.metadata?.stream_channel ?? "text" /* TEXT */;
+      const blocks = this.normalizeContentBlocks(event.data.chunk.content);
+      this.processContentStream(acc, channel, blocks, onPartial);
       return;
     }
     if (event.event === "on_tool_start") {
@@ -4597,11 +4624,27 @@ exports.EventProcessor = class EventProcessor {
       return;
     }
     if (event.event === "on_tool_end") {
-      this.logger.log("\u2705 Tool execution completed", {
-        toolName: event.name,
-        output: typeof event.data?.output === "string" ? event.data.output.substring(0, 200) + (event.data.output.length > 200 ? "..." : "") : event.data?.output,
-        runId: event.run_id
-      });
+      const channel = event.metadata?.stream_channel ?? "text" /* TEXT */;
+      const state = acc.channels.get(channel);
+      if (state?.currentBlock && state.currentBlock.type === "tool_use") {
+        const output = event.data?.output;
+        const outputString = typeof output === "string" ? output : JSON.stringify(output, null, 2);
+        state.currentBlock.output = outputString;
+        this.sendDelta(
+          channel,
+          {
+            type: "tool_output_chunk",
+            stepId: state.currentBlock.id,
+            chunk: outputString
+          },
+          onPartial
+        );
+        this.logger.log("\u2705 Tool execution completed", {
+          toolName: event.name,
+          outputPreview: outputString.substring(0, 200) + (outputString.length > 200 ? "..." : ""),
+          runId: event.run_id
+        });
+      }
       return;
     }
     if (event.event === "on_tool_error") {
@@ -4613,133 +4656,48 @@ exports.EventProcessor = class EventProcessor {
       return;
     }
     if (event.event === "on_chat_model_end") {
-      const output = event.data?.output;
-      const usageMetadata = output?.usage_metadata || output?.usageMetadata;
-      const modelId = event.metadata?.modelId;
-      if (usageMetadata && modelId) {
-        const llmCall = {
-          modelId,
-          promptTokens: usageMetadata.input_tokens || 0,
-          completionTokens: usageMetadata.output_tokens || 0,
-          totalTokens: usageMetadata.total_tokens || 0,
-          timestamp: Date.now(),
-          nodeName: event.metadata?.langgraph_node || event.name
-        };
-        acc.llmCalls.push(llmCall);
-        this.logger.log("\u2705 LLM call recorded", {
-          modelId,
-          tokens: llmCall.totalTokens,
-          nodeName: llmCall.nodeName,
-          totalRecorded: acc.llmCalls.length
-        });
-      } else {
-        this.logger.warn(
-          "\u26A0\uFE0F Missing usage metadata or modelId in on_chat_model_end",
-          {
-            hasUsageMetadata: !!usageMetadata,
-            hasModelId: !!modelId,
-            eventName: event.name,
-            metadataKeys: event.metadata ? Object.keys(event.metadata) : [],
-            outputKeys: output ? Object.keys(output) : []
-          }
-        );
-      }
-      if (event.metadata?.stream_channel === "processing" /* PROCESSING */) {
-        if (acc.currentToolUse) {
-          acc.currentReasoningSteps.push(acc.currentToolUse);
-          acc.currentToolUse = null;
-        }
-        if (acc.currentReasoningSteps.length > 0) {
-          acc.reasoningChains.push({
-            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"
-                  }
-                })
-              );
-            }
-          }
-        }
-      }
+      this.logger.debug("\u2705 LLM call completed", {
+        nodeName: event.metadata?.langgraph_node || event.name,
+        channel: event.metadata?.stream_channel
+      });
       return;
     }
-    if (event.event === "on_chain_end" && event.metadata?.stream_channel === "text" /* TEXT */) {
-      const output = event.data.output;
-      let generation = null;
-      if (output?.answer?.text) {
-        generation = {
-          text: output.answer.text,
-          attachments: output.answer.attachments || [],
-          metadata: output.answer.metadata || {}
-        };
-      } else if (output?.generation?.text) {
-        generation = {
-          text: output.generation.text,
-          attachments: output.generation.attachments || [],
-          metadata: output.generation.metadata || {}
-        };
-      } else if (output?.generation?.content) {
-        generation = {
-          text: output.generation.content,
-          attachments: [],
-          metadata: {}
-        };
-      } else if (output?.text) {
-        generation = {
-          text: output.text,
-          attachments: output.attachments || [],
-          metadata: output.metadata || {}
-        };
+    if (event.event === "on_chain_end") {
+      const channel = event.metadata?.stream_channel ?? "text" /* TEXT */;
+      if (channel === "text" /* TEXT */) {
+        const output = event.data.output;
+        if (output?.answer) {
+          acc.attachments = output.answer.attachments || [];
+          acc.metadata = output.answer.metadata || {};
+        } else if (output?.generation) {
+          acc.attachments = output.generation.attachments || [];
+          acc.metadata = output.generation.metadata || {};
+        } else if (output) {
+          acc.attachments = output.attachments || [];
+          acc.metadata = output.metadata || {};
+        }
       }
-      acc.generation = generation;
       return;
     }
   }
   /**
    * Build final result from accumulator
-   * Uses generation if available, otherwise falls back to streamed text
-   * Returns content and trace events (metrics should be extracted from trace on backend)
+   * Returns unified content chains from all channels
    */
   getResult(acc) {
+    const allChains = [];
+    for (const [channel, state] of acc.channels.entries()) {
+      if (state.currentBlock) {
+        state.contentChain.push(state.currentBlock);
+      }
+      if (state.contentChain.length > 0) {
+        allChains.push({
+          channel,
+          steps: state.contentChain,
+          isComplete: true
+        });
+      }
+    }
     const startedAt = acc.traceStartedAt ?? Date.now();
     const completedAt = acc.traceCompletedAt ?? startedAt;
     const trace = acc.traceEvents.length > 0 ? {
@@ -4747,26 +4705,19 @@ exports.EventProcessor = class EventProcessor {
       startedAt,
       completedAt,
       durationMs: Math.max(0, completedAt - startedAt),
-      totalEvents: acc.traceEvents.length,
-      totalModelCalls: acc.llmCalls.length
+      totalEvents: acc.traceEvents.length
     } : null;
-    if (trace) {
-      this.logger.log("\u{1F4CA} [EventProcessor] Final trace assembled", {
-        totalEvents: trace.totalEvents,
-        eventsArrayLength: trace.events.length,
-        firstEventType: trace.events[0]?.type,
-        lastEventType: trace.events[trace.events.length - 1]?.type,
-        firstEventSample: trace.events[0] ? JSON.stringify(trace.events[0]).substring(0, 150) : null,
-        allEventsNull: trace.events.every((e) => e === null),
-        someEventsNull: trace.events.some((e) => e === null)
-      });
-    }
+    this.logger.log("\u{1F4CA} [EventProcessor] Final result assembled", {
+      totalChains: allChains.length,
+      textChains: allChains.filter((c) => c.channel === "text").length,
+      processingChains: allChains.filter((c) => c.channel === "processing").length,
+      totalSteps: allChains.reduce((sum, c) => sum + c.steps.length, 0)
+    });
     return {
       content: {
-        text: acc.generation?.text || acc.streamedText || "",
-        attachments: acc.generation?.attachments || [],
-        metadata: acc.generation?.metadata || {},
-        reasoningChains: acc.reasoningChains.length > 0 ? acc.reasoningChains : void 0
+        contentChains: allChains.length > 0 ? allChains : void 0,
+        attachments: acc.attachments,
+        metadata: acc.metadata
       },
       trace
     };
@@ -4887,8 +4838,7 @@ exports.LangGraphEngine = class LangGraphEngine {
         hasContent: !!content,
         hasContext: !!config.configurable?.context,
         hasTrace: !!trace,
-        traceEvents: trace?.events?.length || 0,
-        totalModelCalls: trace?.totalModelCalls || 0
+        traceEvents: trace?.events?.length || 0
       });
       if (trace && trace.events.length > 0 && config.configurable?.context) {
         const context = config.configurable.context;
@@ -4906,7 +4856,6 @@ exports.LangGraphEngine = class LangGraphEngine {
           companyId: context.companyId || "unknown",
           events: trace.events,
           totalEvents: trace.totalEvents,
-          totalModelCalls: trace.totalModelCalls,
           startedAt: trace.startedAt,
           completedAt: trace.completedAt,
           durationMs: trace.durationMs
@@ -4989,7 +4938,6 @@ exports.LangGraphEngine = class LangGraphEngine {
         agentId: payload.agentId,
         companyId: payload.companyId,
         totalEvents: payload.totalEvents,
-        totalModelCalls: payload.totalModelCalls,
         startedAt: payload.startedAt,
         completedAt: payload.completedAt,
         durationMs: payload.durationMs,