@flutchai/flutch-sdk 0.2.19 → 0.2.21

package/dist/index.cjs

@@ -4817,6 +4817,36 @@ exports.EventProcessor = class EventProcessor {
     }
     return [];
   }
+  /**
+   * Convert LangChain unified `tool_call_chunks` (Bedrock / OpenAI streaming
+   * format) into Anthropic-style blocks so the rest of the pipeline can stay
+   * uniform. The first chunk for a tool carries `name` (and usually `id`);
+   * subsequent chunks carry partial `args` strings that need to accumulate.
+   *
+   * NOTE: assumes tool calls arrive sequentially. Parallel tool calls with
+   * interleaved `args` chunks across different `index`es will misroute args
+   * to the most recently opened tool_use block.
+   */
+  toolCallChunksToBlocks(toolCallChunks) {
+    const blocks = [];
+    for (const tcc of toolCallChunks) {
+      if (tcc.name) {
+        blocks.push({
+          type: "tool_use",
+          id: tcc.id,
+          name: tcc.name,
+          input: ""
+        });
+      }
+      if (typeof tcc.args === "string" && tcc.args.length > 0) {
+        blocks.push({
+          type: "input_json_delta",
+          input: tcc.args
+        });
+      }
+    }
+    return blocks;
+  }
   /**
    * Extract attachments from various input formats
    * Handles both array format (IAttachment[]) and object format (Record<string, IGraphAttachment>)
@@ -4980,10 +5010,19 @@ exports.EventProcessor = class EventProcessor {
       }
       return;
     }
-    if (event.event === "on_chat_model_stream" && event.data?.chunk?.content) {
+    if (event.event === "on_chat_model_stream" && event.data?.chunk) {
       const channel = event.metadata?.stream_channel ?? "text" /* TEXT */;
-      const blocks = this.normalizeContentBlocks(event.data.chunk.content);
-      this.processContentStream(acc, channel, blocks, onPartial);
+      const chunk = event.data.chunk;
+      const blocks = [];
+      if (chunk.content) {
+        blocks.push(...this.normalizeContentBlocks(chunk.content));
+      }
+      if (Array.isArray(chunk.tool_call_chunks) && chunk.tool_call_chunks.length > 0) {
+        blocks.push(...this.toolCallChunksToBlocks(chunk.tool_call_chunks));
+      }
+      if (blocks.length > 0) {
+        this.processContentStream(acc, channel, blocks, onPartial);
+      }
       return;
     }
     if (event.event === "on_tool_start") {
@@ -4996,6 +5035,44 @@ exports.EventProcessor = class EventProcessor {
         if (idx !== -1) {
           const block = state.pendingToolBlocks.splice(idx, 1)[0];
           state.toolBlocksByRunId.set(event.run_id, block);
+        } else {
+          const toolInput = event.data?.input;
+          let inputString;
+          try {
+            inputString = typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput ?? {});
+          } catch {
+            inputString = "";
+          }
+          const synthesizedBlock = {
+            index: state.contentChain.length + (state.currentBlock ? 1 : 0),
+            type: "tool_use",
+            name: event.name,
+            id: event.run_id,
+            input: inputString,
+            output: ""
+          };
+          if (state.currentBlock) {
+            state.contentChain.push(state.currentBlock);
+            state.currentBlock = null;
+          }
+          state.contentChain.push(synthesizedBlock);
+          state.toolBlocksByRunId.set(event.run_id, synthesizedBlock);
+          this.sendDelta(
+            channel,
+            { type: "step_started", step: synthesizedBlock },
+            onPartial
+          );
+          if (inputString.length > 0) {
+            this.sendDelta(
+              channel,
+              {
+                type: "tool_input_chunk",
+                stepId: synthesizedBlock.id,
+                chunk: inputString
+              },
+              onPartial
+            );
+          }
         }
       }
       this.logger.log("\u{1F527} Tool execution started", {
@@ -5362,11 +5439,11 @@ exports.LangGraphEngine = class LangGraphEngine {
    * Extract trace from accumulator and send to backend webhook
    * Called in finally block to ensure trace is sent even on errors
    */
-  async sendTraceFromAccumulator(acc, config, error) {
+  async sendTraceFromAccumulator(acc, preparedPayload, error) {
     try {
       const { trace } = this.eventProcessor.getResult(acc);
-      if (trace && trace.events.length > 0 && config.configurable?.context) {
-        const context = config.configurable.context;
+      const context = preparedPayload.config?.configurable?.context || preparedPayload.configurable?.context;
+      if (trace && trace.events.length > 0 && context) {
         this.logger.debug("[TRACE-WEBHOOK] Sending trace events batch", {
           messageId: context.messageId,
           totalEvents: trace.totalEvents,
@@ -5393,8 +5470,8 @@ exports.LangGraphEngine = class LangGraphEngine {
         this.logger.debug("[TRACE-WEBHOOK] Skipping webhook", {
           hasTrace: !!trace,
           traceEvents: trace?.events?.length || 0,
-          hasContext: !!config.configurable?.context,
-          contextKeys: config.configurable?.context ? Object.keys(config.configurable.context) : [],
+          hasContext: !!context,
+          contextKeys: context ? Object.keys(context) : [],
           hadError: !!error
         });
       }