@manny-est/node-red-flowpilot 0.6.1 → 0.6.2

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 All notable changes to FlowPilot are documented here.
 
+## [0.6.2] - 2026-09-22
+
+### Fixed
+- **Newer Anthropic models (Sonnet 5, Fable 5.1) didn't work at all —
+  every request failed with a 400 error.** ([#9](https://github.com/manny-est/flowpilot/issues/9))
+  Models released after Claude Opus 4.6 reject any `temperature` value
+  other than 1.0; FlowPilot's default of 0.2 meant every single chat,
+  generate, modify, document, and provider-capability-probe request
+  against a newer model failed outright with "temperature is deprecated
+  for this model." Older models (confirmed: `claude-sonnet-4-5`) were
+  unaffected. Fixed reactively — no model-name list to maintain: FlowPilot
+  now detects that exact error live, retries once with `temperature`
+  omitted, and remembers the model needs that treatment so it's a
+  one-time cost. Live-verified against Sonnet 5, Fable 5.1, and an older
+  model to confirm no regression there.
+- **A multi-section plan could silently lose most of its steps from the
+  todo checklist.** A model's own explanation can legitimately structure
+  a larger plan as several numbered sections under short labels (e.g. a
+  Dashboard 2.0 build broken into "Widgets to add:" / "Final steps:")
+  rather than one unbroken numbered list. The checklist parser stopped
+  reading at the first blank line, so only the first section's items
+  ever made it onto the checklist — a 5-step plan could show as a
+  1-item checklist, which read as "the numbering is wrong" but was
+  actually silent data loss. Now keeps reading across section breaks and
+  only stops at the real closing explanation paragraph.
+- **No way to clear a pinned node selection without losing your place.**
+  Once a mode (Generate/Modify/Document/Build) is armed with a
+  selection, that selection intentionally stays attached across
+  follow-up turns so you don't have to reselect every time — but there
+  was no way to just drop it if you no longer wanted those nodes
+  attached, short of fully re-arming the mode or clearing the whole
+  chat. The status line now shows a small ✕ next to a pinned selection
+  that clears just the pin, leaving the mode itself armed.
+
 ## [0.6.1] - 2026-09-02
 
 ### Fixed

package/lib/core/main.js

@@ -2482,9 +2482,25 @@
                 : armedExecuteAction === "document" ? "Document"
                 : armedExecuteAction === "modify" ? "Modify"
                 : armedExecuteAction === "build" ? "Build" : "Execute";
-            $status.text("Pinned: " + count + (count === 1 ? " node" : " nodes") +
-                         " for " + actionLabel + " — will be sent as context")
-                   .addClass("fp-has-selection");
+            // 0.6.2 hotfix (pinned nodes don't clear): a pin is coupled to
+            // armedExecuteAction by design (persists across follow-up turns
+            // in the same mode so the user doesn't need to reselect every
+            // time) — that part is intentional, not a bug. What was
+            // actually missing is any way to clear JUST the pin, short of
+            // re-arming/disarming the mode entirely or Clear Chat. Mirrors
+            // updateDebugStatus's own "attached context + a ✕ to drop it"
+            // pattern (main-window only, same as Modify/Build's other
+            // live-RED.*-state features) rather than a plain text label.
+            $status.empty().addClass("fp-has-selection");
+            $status.append(document.createTextNode("Pinned: " + count + (count === 1 ? " node" : " nodes") +
+                         " for " + actionLabel + " — will be sent as context "));
+            var $clearPin = $("<a>").attr("href", "#").text("✕").attr("title", "Clear pinned node context (stays in " + actionLabel + " mode)");
+            $clearPin.on("click", function (ev) {
+                ev.preventDefault();
+                pinnedSelectionIds = null;
+                updateSelectionStatus();
+            });
+            $status.append($clearPin);
         } else {
             $status.text(count + (count === 1 ? " node" : " nodes") + groupNote +
                          " selected — will be sent as context")

package/lib/core/modes.js

@@ -1675,21 +1675,46 @@
 
     // W4: parse a "Plan:" block from the model's explanation field.
     // Returns an array of { text, status } items, or [] if none found.
-    // Each numbered/bulleted line under "Plan:" up to the first blank line
-    // becomes one item. Status starts as "pending" for all items — the
-    // caller sets the first to "active" before rendering.
+    // Status starts as "pending" for all items — the caller sets the first
+    // to "active" before rendering.
+    //
+    // 0.6.2 hotfix (todo-list numbering bug): this used to stop at the
+    // FIRST blank line after "Plan:", on the assumption a plan is always
+    // one unbroken numbered block followed by closing prose. A real
+    // Dashboard 2.0 explanation can legitimately structure its plan as
+    // several numbered sections separated by short labels ("Widgets to
+    // add:", "Final steps:") — each its own blank-line-delimited block —
+    // and the old logic silently dropped every item after the first
+    // section (observed as "wrong numbering": a 5-item plan producing a
+    // 1-item checklist). Now scans every line after "Plan:" to the end of
+    // the explanation and keeps collecting numbered/bulleted lines across
+    // blank lines and short one-line section labels; it only stops at two
+    // CONSECUTIVE non-list, non-blank lines — a real prose paragraph, the
+    // closing explanation that follows every plan today. A single-line
+    // label between numbered sections never counts as that paragraph, so
+    // sections keep getting picked up; a genuine multi-line prose block
+    // still ends collection exactly as before.
     function parseTodoPlan(explanation) {
         if (!explanation || typeof explanation !== "string") { return []; }
         var planStart = explanation.indexOf("Plan:");
         if (planStart === -1) { return []; }
         var afterPlan = explanation.slice(planStart + 5);
-        var planBlock = afterPlan.split(/\n\n/)[0];
-        var lines = planBlock.split("\n");
+        var lines = afterPlan.split("\n");
         var items = [];
-        lines.forEach(function (line) {
-            var stripped = line.replace(/^\s*\d+[.):\s]+/, "").replace(/^\s*[-*]\s+/, "").trim();
-            if (stripped) { items.push({ text: stripped, status: "pending" }); }
-        });
+        var proseStreak = 0;
+        for (var i = 0; i < lines.length; i++) {
+            var line = lines[i];
+            if (!line.trim()) { continue; } // a blank line alone never ends the plan
+            var isListLine = /^\s*\d+[.):\s]/.test(line) || /^\s*[-*]\s+/.test(line);
+            if (isListLine) {
+                proseStreak = 0;
+                var stripped = line.replace(/^\s*\d+[.):\s]+/, "").replace(/^\s*[-*]\s+/, "").trim();
+                if (stripped) { items.push({ text: stripped, status: "pending" }); }
+                continue;
+            }
+            proseStreak++;
+            if (proseStreak >= 2) { break; }
+        }
         return items;
     }
 

package/lib/provider-anthropic.js

@@ -6,6 +6,28 @@ const ANTHROPIC_API_BASE = "https://api.anthropic.com";
 const ANTHROPIC_VERSION = "2023-06-01";
 const DEFAULT_MAX_TOKENS = 8192;
 
+// ---- temperature-deprecated detection (GitHub #9) ----
+// Models released after Claude Opus 4.6 reject any temperature value other
+// than 1.0 (Anthropic's own Messages API docs) — FlowPilot's default is 0.2,
+// so every request against a newer model fails outright with no reactive
+// handling. No model-name allowlist or version parsing: detect the actual
+// error shape live and adapt. In-memory only (module scope, keyed by model
+// name) — resets on a server restart, which is an acceptable, deliberate
+// simplification for a hotfix; the storage-backed persistence
+// `supportsTools` uses would need threading through every one of this
+// module's ~8 call sites in flowpilot.js and isn't worth that churn for a
+// per-process cache that already makes this a one-time cost per model for
+// the life of the running server.
+const modelsWithoutTemperatureSupport = new Map();
+
+function isTemperatureDeprecatedError(err) {
+  if (!err || typeof err.message !== "string") { return false; }
+  const msg = err.message;
+  return msg.indexOf("invalid_request_error") !== -1 &&
+    msg.indexOf("temperature") !== -1 &&
+    msg.indexOf("deprecated") !== -1;
+}
+
 // ---- HTTP helpers ----
 
 function postJson(urlString, headers, body, timeoutMs) {
@@ -109,8 +131,19 @@ function postStream(urlString, headers, body, timeoutMs, onDelta, onReasoningDel
     }, (res) => {
       res.setEncoding("utf8");
       if (res.statusCode < 200 || res.statusCode >= 300) {
-        res.on("data", () => {});
-        res.on("end", () => { reject(new Error("Provider request failed (status " + res.statusCode + ").")); });
+        // Capture the error body (same shape as postJson's non-2xx path)
+        // so callers can detect a specific error type (e.g. the
+        // temperature-deprecated case below) — this stays internal to the
+        // retry decision, never echoed to the HTTP client as the raw body
+        // (same ADR-007 boundary postJson already holds).
+        let errBody = "";
+        res.on("data", (chunk) => { errBody += chunk; });
+        res.on("end", () => {
+          let parsed = null;
+          try { parsed = errBody ? JSON.parse(errBody) : null; } catch (e) { /* fall through to generic message */ }
+          const msg = parsed && parsed.error ? JSON.stringify(parsed.error) : ("status " + res.statusCode);
+          reject(new Error("Provider request failed (" + res.statusCode + "): " + msg));
+        });
         return;
       }
 
@@ -263,23 +296,37 @@ async function chat(settings, messages, options) {
   const { system, messages: anthropicMessages } = convertMessages(messages);
   const temperature = settings.temperature !== undefined ? Number(settings.temperature) : 0.2;
 
-  const body = {
-    model: settings.model,
-    messages: anthropicMessages,
-    max_tokens: DEFAULT_MAX_TOKENS,
-    temperature: temperature,
-    stream: false
-  };
-  if (system) { body.system = system; }
-  if (options && Array.isArray(options.tools) && options.tools.length) {
-    body.tools = options.tools.map(toAnthropicTool).filter(Boolean);
-    body.tool_choice = {
-      type: options.toolChoice === "required" ? "any" : "auto"
+  function buildBody(includeTemperature) {
+    const body = {
+      model: settings.model,
+      messages: anthropicMessages,
+      max_tokens: DEFAULT_MAX_TOKENS,
+      stream: false
     };
+    if (includeTemperature) { body.temperature = temperature; }
+    if (system) { body.system = system; }
+    if (options && Array.isArray(options.tools) && options.tools.length) {
+      body.tools = options.tools.map(toAnthropicTool).filter(Boolean);
+      body.tool_choice = {
+        type: options.toolChoice === "required" ? "any" : "auto"
+      };
+    }
+    return body;
   }
 
+  const skipTemperature = modelsWithoutTemperatureSupport.get(settings.model) === true;
   const startedAt = Date.now();
-  const response = await postJson(baseUrl + "/v1/messages", anthropicHeaders(settings), body, settings.requestTimeoutMs || 180000);
+  let response;
+  try {
+    response = await postJson(baseUrl + "/v1/messages", anthropicHeaders(settings), buildBody(!skipTemperature), settings.requestTimeoutMs || 180000);
+  } catch (err) {
+    if (skipTemperature || !isTemperatureDeprecatedError(err)) { throw err; }
+    // First time seeing this on this model this process — cache it so
+    // every later call to this model skips straight to the no-temperature
+    // body, then retry this one request once.
+    modelsWithoutTemperatureSupport.set(settings.model, true);
+    response = await postJson(baseUrl + "/v1/messages", anthropicHeaders(settings), buildBody(false), settings.requestTimeoutMs || 180000);
+  }
   const totalMs = Date.now() - startedAt;
 
   const contentArray = (response && Array.isArray(response.content)) ? response.content : [];
@@ -307,16 +354,31 @@ async function chatStream(settings, messages, onDelta, onReasoningDelta) {
   const { system, messages: anthropicMessages } = convertMessages(messages);
   const temperature = settings.temperature !== undefined ? Number(settings.temperature) : 0.2;
 
-  const body = {
-    model: settings.model,
-    messages: anthropicMessages,
-    max_tokens: DEFAULT_MAX_TOKENS,
-    temperature: temperature,
-    stream: true
-  };
-  if (system) { body.system = system; }
+  function buildBody(includeTemperature) {
+    const body = {
+      model: settings.model,
+      messages: anthropicMessages,
+      max_tokens: DEFAULT_MAX_TOKENS,
+      stream: true
+    };
+    if (includeTemperature) { body.temperature = temperature; }
+    if (system) { body.system = system; }
+    return body;
+  }
 
-  const result = await postStream(baseUrl + "/v1/messages", anthropicHeaders(settings), body, settings.requestTimeoutMs || 180000, onDelta, onReasoningDelta);
+  const skipTemperature = modelsWithoutTemperatureSupport.get(settings.model) === true;
+  let result;
+  try {
+    result = await postStream(baseUrl + "/v1/messages", anthropicHeaders(settings), buildBody(!skipTemperature), settings.requestTimeoutMs || 180000, onDelta, onReasoningDelta);
+  } catch (err) {
+    if (skipTemperature || !isTemperatureDeprecatedError(err)) { throw err; }
+    // Same one-time detection as chat() above. Safe to retry whole-hog:
+    // postStream rejects on the response's status line, before any SSE
+    // data event is parsed, so onDelta/onReasoningDelta can't have already
+    // emitted partial content from the failed attempt.
+    modelsWithoutTemperatureSupport.set(settings.model, true);
+    result = await postStream(baseUrl + "/v1/messages", anthropicHeaders(settings), buildBody(false), settings.requestTimeoutMs || 180000, onDelta, onReasoningDelta);
+  }
 
   return {
     content: result.content || "",
@@ -362,8 +424,8 @@ async function probeTools(settings) {
   if (!settings.model) { throw new Error("Model is required."); }
   const baseUrl = resolveBaseUrl(settings);
 
-  try {
-    const response = await postJson(baseUrl + "/v1/messages", anthropicHeaders(settings), {
+  function buildProbeBody(includeTemperature) {
+    const body = {
       model: settings.model,
       messages: [{ role: "user", content: "Call the \"ping\" tool now with no arguments." }],
       system: "You are being tested for tool/function-calling support.",
@@ -374,9 +436,26 @@ async function probeTools(settings) {
       }],
       tool_choice: { type: "auto" },
       max_tokens: 128,
-      temperature: 0,
       stream: false
-    }, settings.requestTimeoutMs || 30000);
+    };
+    if (includeTemperature) { body.temperature = 0; }
+    return body;
+  }
+
+  const skipTemperature = modelsWithoutTemperatureSupport.get(settings.model) === true;
+  try {
+    let response;
+    try {
+      response = await postJson(baseUrl + "/v1/messages", anthropicHeaders(settings), buildProbeBody(!skipTemperature), settings.requestTimeoutMs || 30000);
+    } catch (err) {
+      // A temperature-deprecated failure here is not "no tool support" —
+      // it's an unrelated request-shape error. Retry without temperature
+      // before concluding anything about tool support (same detection as
+      // chat()/chatStream() above).
+      if (skipTemperature || !isTemperatureDeprecatedError(err)) { throw err; }
+      modelsWithoutTemperatureSupport.set(settings.model, true);
+      response = await postJson(baseUrl + "/v1/messages", anthropicHeaders(settings), buildProbeBody(false), settings.requestTimeoutMs || 30000);
+    }
 
     const contentArray = (response && Array.isArray(response.content)) ? response.content : [];
     const hasToolUse = contentArray.some(function (b) { return b.type === "tool_use" && b.name === "ping"; });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manny-est/node-red-flowpilot",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "FlowPilot for Node-RED - an AI-powered development assistant sidebar",
   "main": "flowpilot.js",
   "keywords": [