@flutchai/flutch-sdk 0.7.10 → 0.7.12

package/dist/index.cjs

@@ -2133,11 +2133,28 @@ exports.GraphController = class _GraphController {
   }
   async generateAnswer(payload, res) {
     this.cancelOnDisconnect(res, payload.requestId);
+    let beating = false;
+    const stop = this.heartbeat(() => {
+      if (!beating) {
+        res.status(common.HttpStatus.CREATED).setHeader("Content-Type", "application/json");
+        beating = true;
+      }
+      res.write(" ");
+    });
     try {
-      return await this.graphService.generateAnswer(payload);
+      const result = await this.graphService.generateAnswer(payload);
+      stop();
+      if (beating) res.end(JSON.stringify(result));
+      else res.status(common.HttpStatus.CREATED).json(result);
     } catch (error) {
+      stop();
       this.logger.error(`Generation failed: ${error.message}`);
-      throw new common.HttpException(`Generation failed: ${error.message}`, common.HttpStatus.INTERNAL_SERVER_ERROR);
+      const failure = {
+        statusCode: common.HttpStatus.INTERNAL_SERVER_ERROR,
+        message: `Generation failed: ${error.message}`
+      };
+      if (beating) res.end(JSON.stringify(failure));
+      else res.status(common.HttpStatus.INTERNAL_SERVER_ERROR).json(failure);
     }
   }
   async streamAnswer(payload, res) {
@@ -2146,6 +2163,7 @@ exports.GraphController = class _GraphController {
     res.setHeader("Cache-Control", "no-cache");
     res.setHeader("Connection", "keep-alive");
     this.cancelOnDisconnect(res, payload.requestId);
+    const stop = this.heartbeat(() => res.write(": ping\n\n"));
     try {
       this.logger.debug(`[CONTROLLER] Starting streamAnswer for requestId: ${payload.requestId}`);
       const result = await this.graphService.streamAnswer(payload, (chunk) => {
@@ -2163,6 +2181,7 @@ exports.GraphController = class _GraphController {
         reasoningChainsCount: result.reasoningChains?.length || 0,
         resultKeys: Object.keys(result || {})
       });
+      stop();
       res.write(`event: final
 `);
       res.write(`data: ${JSON.stringify(result)}
@@ -2171,6 +2190,7 @@ exports.GraphController = class _GraphController {
       res.end();
       this.logger.debug(`[CONTROLLER] Stream completed successfully`);
     } catch (error) {
+      stop();
       this.logger.error(`[CONTROLLER] Streaming failed: ${error.message}`);
       this.logger.error(`[CONTROLLER] Error stack: ${error.stack}`);
       res.write(`event: error
@@ -2184,6 +2204,20 @@ exports.GraphController = class _GraphController {
     }
   }
   /**
+  * Calls `beat` every GRAPH_HEARTBEAT_MS (20 s by default, 0 turns it off)
+  * while a run goes on; returns the function that stops it. A caller drops a
+  * connection that stays silent past its idle limit — the backend's is
+  * GRAPH_SERVICE_TIMEOUT_MS — and a graph waiting on other agents is silent
+  * for minutes: a report pipeline was cut at 15 minutes, 21 seconds before
+  * its report was done (29.10.2026).
+  */
+  heartbeat(beat) {
+    const ms = Number(process.env.GRAPH_HEARTBEAT_MS ?? 2e4);
+    if (!(ms > 0)) return () => void 0;
+    const timer = setInterval(beat, ms);
+    return () => clearInterval(timer);
+  }
+  /**
   * A caller that hangs up before the answer is done — its own timeout, a
   * restart, a cancelled parent run — no longer waits for it, so the run is
   * cancelled: left going, it keeps calling models and tools nobody reads.
@@ -2269,9 +2303,7 @@ _ts_decorate8([
     description: "Answer generated"
   }),
   _ts_param4(0, common.Body()),
-  _ts_param4(1, common.Res({
-    passthrough: true
-  })),
+  _ts_param4(1, common.Res()),
   _ts_metadata6("design:type", Function),
   _ts_metadata6("design:paramtypes", [
     typeof IGraphRequestPayload === "undefined" ? Object : IGraphRequestPayload,
@@ -4806,6 +4838,20 @@ var StreamChannel = /* @__PURE__ */ (function(StreamChannel2) {
   return StreamChannel2;
 })({});
 
+// src/messages/thinking.ts
+var textOf = /* @__PURE__ */ __name((part) => typeof part === "string" ? part : part && typeof part.text === "string" ? String(part.text) : "", "textOf");
+var summaryTexts = /* @__PURE__ */ __name((summary) => Array.isArray(summary) ? summary.map(textOf) : [], "summaryTexts");
+function extractThinking(message) {
+  const blocks = Array.isArray(message.content) ? message.content : [];
+  const reasoning = message.additional_kwargs?.reasoning;
+  return [
+    ...blocks.filter((b) => b?.type === "thinking" && typeof b.thinking === "string").map((b) => String(b.thinking)),
+    ...blocks.filter((b) => b?.type === "reasoning").flatMap((b) => summaryTexts(b.summary)),
+    ...summaryTexts(reasoning?.summary)
+  ].map((t) => t.trim()).filter(Boolean).filter((t, i, all) => all.indexOf(t) === i).join("\n\n");
+}
+__name(extractThinking, "extractThinking");
+
 // src/tools/attachment-summary.ts
 var MAX_SAMPLE_ROWS = 5;
 var MAX_TEXT_PREVIEW_LENGTH = 500;
@@ -5156,6 +5202,45 @@ function sanitizeTraceError(error, options) {
   };
 }
 __name(sanitizeTraceError, "sanitizeTraceError");
+
+// src/engines/langgraph/stream-thinking.ts
+function splitThinking(blocks) {
+  const thoughts = [];
+  const rest = [];
+  for (const block of blocks) {
+    const part = block;
+    if (part?.type === "thinking" || part?.type === "reasoning") {
+      const text = part.type === "thinking" ? part.thinking : part.reasoning;
+      if (typeof text === "string" && text) thoughts.push({
+        text,
+        index: part.index
+      });
+      continue;
+    }
+    rest.push(block);
+  }
+  return {
+    thoughts,
+    rest
+  };
+}
+__name(splitThinking, "splitThinking");
+function thinkingTexts(state, runId, deltas) {
+  const out = [];
+  for (const delta of deltas) {
+    const another = runId !== state.runId || state.index !== void 0 && delta.index !== state.index;
+    out.push(state.shown && another ? `
+
+${delta.text}` : delta.text);
+    state.runId = runId;
+    state.index = delta.index;
+    state.shown = true;
+  }
+  return out;
+}
+__name(thinkingTexts, "thinkingTexts");
+
+// src/engines/langgraph/event-processor.utils.ts
 function _ts_decorate21(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -5463,7 +5548,21 @@ exports.EventProcessor = class _EventProcessor {
       const chunk = event.data.chunk;
       const blocks = [];
       if (chunk.content) {
-        blocks.push(...this.normalizeContentBlocks(chunk.content));
+        const { thoughts, rest } = splitThinking(this.normalizeContentBlocks(chunk.content));
+        blocks.push(...rest);
+        if (thoughts.length && event.metadata?.stream_thinking === true) {
+          acc.thinking ??= {
+            runId: null,
+            index: void 0,
+            shown: false
+          };
+          for (const text of thinkingTexts(acc.thinking, event.run_id ?? null, thoughts)) this.processContentStream(acc, StreamChannel.PROCESSING, [
+            {
+              type: "text",
+              text
+            }
+          ], onPartial);
+        }
       }
       const contentHasToolBlocks = blocks.some((block) => block?.type === "tool_use" || block?.type === "tool_call" || block?.type === "input_json_delta");
       if (!contentHasToolBlocks && Array.isArray(chunk.tool_call_chunks) && chunk.tool_call_chunks.length > 0) {
@@ -9275,6 +9374,7 @@ exports.decryptTokens = decryptTokens;
 exports.dispatchAttachments = dispatchAttachments;
 exports.encryptTokens = encryptTokens;
 exports.executeToolWithAttachments = executeToolWithAttachments;
+exports.extractThinking = extractThinking;
 exports.findCallbackMethod = findCallbackMethod;
 exports.findEndpointMethod = findEndpointMethod;
 exports.flutchFetch = flutchFetch;