@manny-est/node-red-flowpilot 0.5.0 → 0.5.1

package/lib/core/modes.js

@@ -144,62 +144,131 @@
         if (isChat) { pushHistory("user", prompt + note); }
         if (!promptOverride) { $promptBox.val(""); }
 
-        var ap = activeProvider();
-        var isAgentLoop = isChat && ap && ap.supportsTools;
-
-        setBusy(true);
-        showPending(isAgentLoop);
-        var payload = {
-            prompt: prompt,
-            context: context,
-            history: historyPayload.messages,
-            historyTruncated: historyPayload.truncated,
-            conversationId: conversationId
-        };
-
-        function handleSendResult(data) {
-            hidePending();
-            var message = data.message || JSON.stringify(data, null, 2);
-            // Test Provider also reports tool-calling support, used by
-            // the agentic path.
-            if (data.capability && data.capability.label) {
-                message += "\n\n" + data.capability.label;
+        function dispatch() {
+            var ap = activeProvider();
+            var isAgentLoop = isChat && ap && ap.supportsTools;
+
+            setBusy(true);
+            showPending(isAgentLoop);
+            var payload = {
+                prompt: prompt,
+                context: context,
+                history: historyPayload.messages,
+                historyTruncated: historyPayload.truncated,
+                conversationId: conversationId
+            };
+
+            function handleSendResult(data) {
+                hidePending();
+                // Render a collapsed thinking block for non-streaming reasoning models
+                // (the streaming path handles this live in sendChatStream instead).
+                if (data.reasoningContent) {
+                    var $box = el("#fp-messages");
+                    var approxTokens = Math.round(data.reasoningContent.length / 4);
+                    var $thinking = $("<details>").addClass("fp-thinking");
+                    var $summary = $("<summary>").appendTo($thinking);
+                    $("<span>").text("Thinking").appendTo($summary);
+                    $("<span>").addClass("fp-thinking-tokens").text(approxTokens + " tokens").appendTo($summary);
+                    $("<div>").addClass("fp-thinking-body").text(data.reasoningContent).appendTo($thinking);
+                    $box.append($thinking);
+                }
+                var message = data.message || JSON.stringify(data, null, 2);
+                // Test Provider also reports tool-calling support, used by
+                // the agentic path. Mirror the probe results into currentSettings
+                // so the auto-preflight condition (probedModel !== model) has a
+                // baseline to compare against without requiring a page reload.
+                if (data.capability && data.capability.label) {
+                    message += "\n\n" + data.capability.label;
+                }
+                if (endpoint === "test" && data.capability && data.capability.probedModel) {
+                    var testAp = activeProvider();
+                    if (testAp && currentSettings && Array.isArray(currentSettings.providers)) {
+                        currentSettings.providers = currentSettings.providers.map(function(p) {
+                            return p.id === testAp.id ? Object.assign({}, p, {
+                                supportsTools: data.capability.supportsTools,
+                                isReasoningModel: data.capability.isReasoningModel,
+                                probedModel: data.capability.probedModel
+                            }) : p;
+                        });
+                    }
+                }
+                if (endpoint === "test") {
+                    message += "\n\nAll set — try `/help` for the full briefing and shortcut list.";
+                }
+                addMessage("assistant", message);
+                if (isChat) {
+                    pushHistory("assistant", data.message || "");
+                    renderActionChip(data.suggestedAction);
+                    renderClarifyingQuestion(data.questionOptions);
+                }
+                setBusy(false);
+                updateSelectionStatus();
             }
-            if (endpoint === "test") {
-                message += "\n\nAll set — try `/help` for the full briefing and shortcut list.";
+
+            function handleSendError(msg) {
+                hidePending();
+                if (isChat) { popDanglingUserHistory(); }
+                addMessage("error", msg);
+                setBusy(false);
             }
-            addMessage("assistant", message);
-            if (isChat) {
-                pushHistory("assistant", data.message || "");
-                renderActionChip(data.suggestedAction);
-                renderClarifyingQuestion(data.questionOptions);
+
+            // When the active provider supports tool/function calling,
+            // the chat turn is offered the Tier-1 read tools and run through the
+            // bounded agent loop instead of a single request.
+            if (isAgentLoop) {
+                runAgentChat(payload, handleSendResult, handleSendError);
+                return;
             }
-            setBusy(false);
-            updateSelectionStatus();
-        }
 
-        function handleSendError(msg) {
-            hidePending();
-            if (isChat) { popDanglingUserHistory(); }
-            addMessage("error", msg);
-            setBusy(false);
-        }
+            if (isChat && currentSettings.streamingEnabled) {
+                payload.stream = true;
+                sendChatStream(payload);
+                return;
+            }
 
-        // When the active provider supports tool/function calling,
-        // the chat turn is offered the Tier-1 read tools and run through the
-        // bounded agent loop instead of a single request.
-        if (isAgentLoop) {
-            runAgentChat(payload, handleSendResult, handleSendError);
-            return;
+            ajaxJson("POST", "flowpilot/" + endpoint, payload, handleSendResult, handleSendError);
         }
 
-        if (isChat && currentSettings.streamingEnabled) {
-            payload.stream = true;
-            sendChatStream(payload);
+        // Silent preflight: if the model changed since the last probe, save and
+        // re-probe before routing — stale supportsTools silently misroutes chat
+        // (agent-loop path vs streaming/non-streaming).
+        // Compare against the LIVE DOM value so unsaved edits trigger correctly;
+        // save first so the backend probes the right model.
+        var ap = activeProvider();
+        var liveModel = (el("#fp-model").length ? el("#fp-model").val() : null) || (ap && ap.model) || "";
+        if (isChat && ap && ap.probedModel && liveModel && liveModel !== ap.probedModel) {
+            setBusy(true);
+            showPending(false);
+            setAgentNarration("Pre-flight…");
+            saveSettings(function() {
+                var ap2 = activeProvider();
+                ajaxJson("POST", "flowpilot/probe", {}, function(result) {
+                    if (currentSettings && Array.isArray(currentSettings.providers)) {
+                        var targetId = (ap2 || ap).id;
+                        currentSettings.providers = currentSettings.providers.map(function(p) {
+                            return p.id === targetId ? Object.assign({}, p, {
+                                supportsTools: result.supportsTools,
+                                isReasoningModel: result.isReasoningModel,
+                                probedModel: result.probedModel
+                            }) : p;
+                        });
+                    }
+                    hidePending();
+                    var caps = [];
+                    if (result.supportsTools) { caps.push("Tools ✓"); } else { caps.push("Tools ✗"); }
+                    if (result.isReasoningModel) { caps.push("Reasoning ✓"); }
+                    addMessage("notice", "Pre-flight: " + (result.probedModel || liveModel) + " · " + caps.join(" · "));
+                    dispatch();
+                }, function() {
+                    hidePending();
+                    addMessage("notice", "Pre-flight failed — continuing with cached capabilities.");
+                    dispatch();
+                });
+            });
             return;
         }
 
-        ajaxJson("POST", "flowpilot/" + endpoint, payload, handleSendResult, handleSendError);
+        dispatch();
     }
 
     // ---------------------------------------------------------------------
@@ -348,25 +417,53 @@
         // wait until real content starts arriving.
         var $msg = null;
         var $text = null;
+        var _chatRec = null;
+
+        // Reasoning block (shown for reasoning models that emit reasoning_content).
+        var $thinking = null;
+        var $thinkingBody = null;
+        var $thinkingTokens = null;
+        var reasoningBuf = "";
 
         var fullText = "";
         var finalData = null;
 
+        function ensureThinkingBlock() {
+            if ($thinking) { return; }
+            hidePending();
+            $thinking = $("<details>").addClass("fp-thinking").attr("open", "");
+            var $summary = $("<summary>").appendTo($thinking);
+            $("<span>").text("Thinking").appendTo($summary);
+            $thinkingTokens = $("<span>").addClass("fp-thinking-tokens").appendTo($summary);
+            $thinkingBody = $("<div>").addClass("fp-thinking-body").appendTo($thinking);
+            $box.append($thinking);
+            scrollMessagesToBottom();
+        }
+
         function ensureBubble() {
             if ($text) { return; }
             hidePending();
-            addMessage("assistant", "");
+            // Collapse the thinking block the moment real content starts flowing.
+            if ($thinking) { $thinking.prop("open", false); }
+            _chatRec = addMessage("assistant", "");
             $msg = $box.find(".fp-message").last();
             $text = $msg.find("div").last();
         }
 
         function finish() {
             hidePending();
+            // Stamp approximate token count on the thinking block once we're done.
+            if ($thinking && reasoningBuf) {
+                var approxTokens = Math.round(reasoningBuf.length / 4);
+                $thinkingTokens.text(approxTokens + " tokens");
+            }
             if (!fullText) {
                 if ($msg && $msg.length) { $msg.remove(); }
+                if (_chatRec) { messageRecords.splice(messageRecords.indexOf(_chatRec), 1); _chatRec = null; }
                 popDanglingUserHistory();
                 addMessage("error", "No response received from the provider.");
             } else {
+                if (_chatRec) { _chatRec.text = fullText; _chatRec.streamingComplete = true; }
                 pushHistory("assistant", fullText);
                 if (finalData) {
                     renderActionChip(finalData.suggestedAction);
@@ -392,14 +489,10 @@
         }
 
         // Shared SSE-line parser: handles `data: {"delta":"..."}` /
-        // `data: {"final":{...}}` / `data: {"error":"..."}` / `data: [DONE]`
-        // lines, appending deltas to fullText and rendering them. Used by
-        // both the streaming pump() loop (called per-chunk with the trailing
-        // partial line held back) and the non-getReader fallback (#12,
-        // called once with the full body split into lines), so neither path
-        // can drift or show raw SSE text. The backend withholds any trailing
-        // <<<FLOWPILOT_DATA>>> block from `delta`s entirely and relays its
-        // parsed suggestedAction/questionOptions as a single `final` event.
+        // `data: {"reasoningDelta":"..."}` / `data: {"final":{...}}` /
+        // `data: {"error":"..."}` / `data: [DONE]` lines. Used by both the
+        // streaming pump() loop and the non-getReader fallback so neither path
+        // can drift or show raw SSE text.
         function processSseLines(lines) {
             lines.forEach(function (line) {
                 line = line.trim();
@@ -409,10 +502,17 @@
                 var evt;
                 try { evt = JSON.parse(dataStr); } catch (e) { return; }
                 if (evt.error) { throw new Error(evt.error); }
-                if (evt.delta) {
+                if (evt.reasoningDelta) {
+                    reasoningBuf += evt.reasoningDelta;
+                    ensureThinkingBlock();
+                    $thinkingBody.text(reasoningBuf);
+                    $thinkingBody[0].scrollTop = $thinkingBody[0].scrollHeight;
+                    scrollMessagesToBottom();
+                } else if (evt.delta) {
                     fullText += evt.delta;
                     ensureBubble();
                     $text.html(renderMarkdown(fullText));
+                    if (_chatRec) { _chatRec.text = fullText; }
                     scrollMessagesToBottom();
                 } else if (evt.final) {
                     finalData = evt.final;
@@ -580,6 +680,7 @@
         }
 
         $box.append($row);
+        addRecord("chip", { chipType: "suggestedAction", suggestedAction: suggestedAction });
         scrollMessagesToBottom();
     }
 
@@ -667,6 +768,7 @@
             .appendTo($row);
 
         $box.append($row).append($otherRow);
+        addRecord("question", { options: options });
         scrollMessagesToBottom();
     }
 
@@ -1304,6 +1406,7 @@
             .appendTo($row);
 
         $box.append($row);
+        addRecord("question", { options: ["Continue → AI review", "Stop loop"], loopCheckpoint: true });
         scrollMessagesToBottom();
     }
 
@@ -1334,7 +1437,7 @@
     // handleBuildReviewResult's addModifyReview callback (rather than left
     // as an inline closure) so the EXACT same logic can run whether the
     // Apply click happened in the main window or was relayed from the
-    // pop-out — see the "applyBuildFix" handler in initMainWindow.
+    // pop-out — see the applyByRecordId handler in initMainWindow (Phase 10 0B).
     function applyBuildLoopFix(nodeDiffs, removeNodesArg, idMap, capReached) {
         applyModifications(nodeDiffs, removeNodesArg, null, idMap);
         if (!activeBuildLoop) { return; }
@@ -1403,10 +1506,30 @@
                 .appendTo($actions);
         }
 
+        // Replace any prior buildStep snapshot — only the latest waypoint matters.
+        messageRecords = messageRecords.filter(function (r) { return r.kind !== "buildStep"; });
+        addRecord("buildStep", {
+            waypoint: loop.waypoint,
+            iteration: loop.iteration,
+            maxIterations: loop.maxIterations,
+            goal: loop.goal,
+            nodeIds: Array.isArray(loop.nodeIds) ? loop.nodeIds.slice() : []
+        });
+
         $box.append($msg);
         scrollMessagesToBottom();
     }
 
+    function rerenderBuildStepRecord(rec) {
+        renderLoopStepper({
+            waypoint: rec.waypoint || "done",
+            iteration: rec.iteration || 1,
+            maxIterations: rec.maxIterations || 5,
+            goal: rec.goal || "",
+            nodeIds: Array.isArray(rec.nodeIds) ? rec.nodeIds : []
+        });
+    }
+
     // Called once the first build proposal is actually imported (not on a
     // clarifying question or prose-only reply — see handleBuildResult). goal
     // is the original prompt text, kept verbatim so the review step can

package/lib/provider-openai-compatible.js

@@ -194,7 +194,66 @@ async function chat(settings, messages, options) {
 // `data: [DONE]`). Calls onDelta(text) for each content fragment as it
 // arrives and resolves with { content } containing the full concatenated
 // text once the stream ends. Used for chat streaming only.
-function postStream(urlString, headers, body, timeoutMs, onDelta) {
+// Splits a streaming content string on <think>...</think> tags so that
+// reasoning text is routed to onReasoning and the actual response text to
+// onContent. Handles tags that arrive split across multiple chunks via a
+// small lookahead buffer. Handles both:
+//   - SGLang/Nemotron style: delta.reasoning_content (separate field)
+//   - llama.cpp/LocalAI style: <think>...</think> embedded in delta.content
+// The two paths converge at onReasoningDelta in postStream — callers see
+// one uniform reasoning callback regardless of provider format.
+function createThinkTagSplitter(onContent, onReasoning) {
+  let phase = "seek"; // "seek" | "think" | "content"
+  let buf = "";
+  const OPEN = "<think>";
+  const CLOSE = "</think>";
+
+  function push(text) {
+    buf += text;
+    while (buf.length > 0) {
+      if (phase === "seek") {
+        const idx = buf.indexOf(OPEN);
+        if (idx === -1) {
+          // No opening tag visible — emit everything except the last few bytes
+          // that might be a partial tag, buffer the rest.
+          const safe = buf.length > OPEN.length - 1 ? buf.length - (OPEN.length - 1) : 0;
+          if (safe > 0) { onContent(buf.slice(0, safe)); buf = buf.slice(safe); }
+          break;
+        }
+        if (idx > 0) { onContent(buf.slice(0, idx)); }
+        buf = buf.slice(idx + OPEN.length);
+        phase = "think";
+      } else if (phase === "think") {
+        const idx = buf.indexOf(CLOSE);
+        if (idx === -1) {
+          const safe = buf.length > CLOSE.length - 1 ? buf.length - (CLOSE.length - 1) : 0;
+          if (safe > 0) { onReasoning(buf.slice(0, safe)); buf = buf.slice(safe); }
+          break;
+        }
+        if (idx > 0) { onReasoning(buf.slice(0, idx)); }
+        buf = buf.slice(idx + CLOSE.length);
+        // Skip whitespace/newline immediately after </think>
+        const trimmed = buf.replace(/^\s+/, "");
+        buf = trimmed;
+        phase = "content";
+      } else {
+        onContent(buf);
+        buf = "";
+        break;
+      }
+    }
+  }
+
+  function finish() {
+    if (!buf) { return; }
+    if (phase === "think") { onReasoning(buf); } else { onContent(buf); }
+    buf = "";
+  }
+
+  return { push, finish };
+}
+
+function postStream(urlString, headers, body, timeoutMs, onDelta, onReasoningDelta) {
   return new Promise((resolve, reject) => {
     let url;
     try {
@@ -233,12 +292,22 @@ function postStream(urlString, headers, body, timeoutMs, onDelta) {
         return;
       }
 
-      let buf = "";
+      let sseBuf = "";
       let full = "";
+      // When onReasoningDelta is provided, intercept <think>...</think> from
+      // delta.content in addition to the dedicated delta.reasoning_content field
+      // (llama.cpp/LocalAI style vs SGLang/Nemotron style — both converge here).
+      const thinkSplitter = onReasoningDelta
+        ? createThinkTagSplitter(
+            function (c) { if (firstTokenAt === null) { firstTokenAt = Date.now(); } full += c; onDelta(c); },
+            onReasoningDelta
+          )
+        : null;
+
       res.on("data", (chunk) => {
-        buf += chunk;
-        const lines = buf.split("\n");
-        buf = lines.pop(); // keep the last (possibly partial) line for next time
+        sseBuf += chunk;
+        const lines = sseBuf.split("\n");
+        sseBuf = lines.pop(); // keep the last (possibly partial) line for next time
 
         lines.forEach((line) => {
           line = line.trim();
@@ -255,17 +324,29 @@ function postStream(urlString, headers, body, timeoutMs, onDelta) {
 
           if (evt && evt.usage) { usage = evt.usage; }
 
-          const delta = evt && evt.choices && evt.choices[0] && evt.choices[0].delta
-            ? evt.choices[0].delta.content
-            : "";
-          if (delta) {
-            if (firstTokenAt === null) { firstTokenAt = Date.now(); }
-            full += delta;
-            onDelta(delta);
+          const deltaObj = evt && evt.choices && evt.choices[0] && evt.choices[0].delta;
+          if (deltaObj) {
+            if (deltaObj.content) {
+              if (thinkSplitter) {
+                thinkSplitter.push(deltaObj.content);
+              } else {
+                if (firstTokenAt === null) { firstTokenAt = Date.now(); }
+                full += deltaObj.content;
+                onDelta(deltaObj.content);
+              }
+            }
+            // Separate reasoning_content field (SGLang/Nemotron style). Both
+            // paths run in parallel — they are mutually exclusive per provider
+            // (llama.cpp puts reasoning in delta.content via <think> tags;
+            // SGLang puts it in delta.reasoning_content with delta.content "").
+            if (deltaObj.reasoning_content && onReasoningDelta) {
+              onReasoningDelta(deltaObj.reasoning_content);
+            }
           }
         });
       });
       res.on("end", () => {
+        if (thinkSplitter) { thinkSplitter.finish(); }
         const endedAt = Date.now();
         resolve({
           content: full,
@@ -287,7 +368,7 @@ function postStream(urlString, headers, body, timeoutMs, onDelta) {
   });
 }
 
-async function chatStream(settings, messages, onDelta) {
+async function chatStream(settings, messages, onDelta, onReasoningDelta) {
   const baseUrl = String(settings.baseUrl || "").replace(/\/+$/, "");
   if (!baseUrl) throw new Error("Provider base URL is required.");
   if (!settings.model) throw new Error("Model is required.");
@@ -309,7 +390,7 @@ async function chatStream(settings, messages, onDelta) {
     temperature,
     stream: true,
     stream_options: { include_usage: true }
-  }, settings.requestTimeoutMs || 180000, onDelta);
+  }, settings.requestTimeoutMs || 180000, onDelta, onReasoningDelta);
 
   return {
     content: result.content || "",
@@ -377,4 +458,20 @@ async function probeTools(settings) {
   }
 }
 
-module.exports = { chat, chatStream, probeTools, listModels };
+// ---------------------------------------------------------------------
+// Checks whether the provider's response includes reasoning_content —
+// the separate chain-of-thought field emitted by reasoning models
+// (e.g. Nemotron, DeepSeek-R1, o1-style). Reuses the connectivity test
+// response already obtained by the /test route rather than making a
+// second round-trip: caller passes the raw response object.
+// Returns { isReasoningModel: boolean }.
+// ---------------------------------------------------------------------
+function detectReasoning(rawResponse) {
+  const message = rawResponse && rawResponse.choices && rawResponse.choices[0]
+    && rawResponse.choices[0].message;
+  const isReasoningModel = !!(message && message.reasoning_content != null
+    && message.reasoning_content !== "");
+  return { isReasoningModel };
+}
+
+module.exports = { chat, chatStream, probeTools, listModels, detectReasoning };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manny-est/node-red-flowpilot",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "FlowPilot for Node-RED - an AI-powered development assistant sidebar",
   "main": "flowpilot.js",
   "keywords": [
@@ -14,7 +14,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/manny-est/flowpilot.git"
+    "url": "git+https://github.com/manny-est/flowpilot.git"
   },
   "homepage": "https://github.com/manny-est/flowpilot#readme",
   "bugs": {