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

package/CHANGELOG.md

@@ -2,6 +2,66 @@
 
 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
+- **Deterministic run summaries actually work now.** 0.6.0 shipped this
+  feature — the per-item ✓/✗ outcome from a Modify or Generate run,
+  built from what the WRITE tools actually reported instead of the
+  model's own retelling — but a control-flow bug in the message-
+  rendering path made it unreachable for every real run: the code path
+  that shows the deterministic summary as primary (with the model's
+  own explanation demoted underneath) never executed. Every response
+  fell through to showing the model's own prose at full weight
+  instead, exactly the narrative-accuracy gap this feature exists to
+  close. Found and fixed during this release's own go-live testing,
+  now live-verified against a real agentic write.
+- **Installed-package awareness was silently non-functional — FlowPilot
+  now actually receives your palette.** The feature that keeps
+  Generate/Modify from proposing node types you don't have, and lets
+  FlowPilot correctly answer "is X installed?", called a Node-RED API
+  that doesn't exist on this version's plugin interface. The call was
+  a silent no-op on every single request: FlowPilot never had real
+  palette information to work with, so the model either said as much
+  or, in some cases, guessed. This wasn't a timing bug or a stale
+  cache — the underlying data source itself never worked. Now reads
+  the live node registry directly and is correct immediately, from
+  the very first request after a restart.
+
 ## [0.6.0] - 2026-09-01
 
 Promoted from `0.6.0-beta.1` to the stable `latest` npm tag.

package/flowpilot.js

@@ -1,6 +1,6 @@
-const http = require("http");
 const https = require("https");
 const path = require("path");
+const nodeRedRegistry = require("@node-red/registry");
 const PACKAGE_VERSION = require("./package.json").version;
 const createStorage = require("./lib/storage");
 const openaiProvider = require("./lib/provider-openai-compatible");
@@ -189,7 +189,47 @@ async function performUpdateCheck() {
   }
 }
 
+// Found live (0.6.1), while verifying the palette-cache fix below: Node-RED
+// loads flowpilot.js TWICE per process start, and always has — package.json
+// declares BOTH "nodes": {"flowpilot": "flowpilot-node-entry.js"} (itself a
+// shim added earlier this same release for a related but distinct bug — see
+// that shim's own comment) AND "plugins": {"flowpilot": "flowpilot.html"}.
+// @node-red/registry/lib/loader.js's loadPluginConfig derives a companion
+// runtime file for every "plugins" entry via the SAME basename-replace
+// pattern (file.replace(/\.[^.]+$/,".js")) that caused the earlier
+// flowpilot.html double-load — "flowpilot.html" -> "flowpilot.js", which
+// genuinely exists, so Node-RED loads and calls it a second time completely
+// independently of the "nodes" entry's shim. Confirmed live: a temporary
+// diagnostic showed flowPilotRuntime executing twice per restart, and a
+// registered RED.events.on("nodes-started", ...) listener firing twice.
+// Unlike the client-side html/script duplication, this one can't be closed
+// by renaming what "plugins" points to without duplicating flowpilot.html's
+// content under a second filename — not worth the maintenance burden for
+// what's fundamentally the same fix in spirit. Guard here instead.
+//
+// A first attempt at this guard used a plain module-level `let` flag,
+// reasoning that Node's require() cache makes a module's own top-level code
+// run exactly once. That reasoning doesn't hold here: confirmed by reading
+// @node-red/registry/lib/loader.js directly, the "nodes" entry is loaded via
+// loadNodeSet, which uses a dynamic import() of a file:// URL (see its
+// `pathToFileURL(node.file)` call), while the "plugins" entry's companion
+// file is loaded via loadPlugin, which uses a plain require(). Node's CJS
+// require() cache and its ESM import() module cache are not the same
+// cache — a module reached through both paths can genuinely execute its
+// top-level code twice, each with its OWN independent closure (own
+// `let flowPilotRuntimeInitialized`, own everything). Confirmed live: a
+// module-level flag did NOT stop the second invocation's independent
+// httpAdmin route registrations from being the ones actually serving
+// requests, while the diagnostic-carrying instance sat silent.
+//
+// Fix: mark completion on `global` instead. Node's global object is a
+// true process-wide singleton — unaffected by which loader/module-cache
+// reached this file — so it's a reliable gate regardless of how many
+// separate module realms this file's code ends up evaluated in.
 module.exports = function flowPilotRuntime(RED) {
+  if (global.__flowPilotRuntimeInitialized) { return; }
+  global.__flowPilotRuntimeInitialized = true;
+
   const storage = createStorage(RED.settings.userDir);
 
   // ---------------------------------------------------------------------
@@ -703,17 +743,42 @@ module.exports = function flowPilotRuntime(RED) {
   // their node types when relevant and otherwise stick to core nodes
   // rather than proposing types that aren't installed.
   //
-  // The node-level RED API passed to this module has no direct registry
-  // lookup (no RED.nodes.getNodeList), so the node list is fetched via a
-  // loopback call to Node-RED's own admin API (the same data the palette
-  // sidebar uses) and cached briefly — the palette rarely changes, and
-  // every chat/generate/document/modify request goes through
-  // buildMessages, so this must stay cheap and synchronous.
+  // Node-RED's admin GET /nodes route ultimately reads the runtime registry's
+  // getNodeList(). A previous fix tried to reach that through RED.nodes, but
+  // Node-RED 5's @node-red/registry/lib/util.js createNodeApi only copies a
+  // small allow-list onto the node-level RED API (createNode/getNode/
+  // eachNode/addCredentials/getCredentials/deleteCredentials) —
+  // getNodeList is NOT one of them. Confirmed live: RED.nodes.getNodeList is
+  // undefined in this runtime, so describeInstalledNodes() quietly returned
+  // null from its catch on every request even after flows:started had fired.
+  //
+  // Use the registry module directly instead. FlowPilot already runs inside
+  // the same Node-RED process, and @node-red/registry is the exact source
+  // runtime.nodes.getNodeList() delegates to.
+  //
+  // Found live (0.6.1): this WAS a cached snapshot, through three
+  // successive designs (a naive restart-seeded TTL timer; a
+  // "nodes-started"-gated refresh; that plus a bounded settle re-check on
+  // top), because the original data source was an HTTP loopback to this
+  // same instance's own /nodes admin route — expensive enough to be worth
+  // caching, and, on any adminAuth-enabled instance, unable to
+  // authenticate itself at all (a real bug, fixed by switching to the
+  // in-process RED.nodes.getNodeList() call below). Once the data source
+  // is a synchronous, already-in-memory function call, caching it stops
+  // paying for itself — it only adds staleness/timing bugs, three of
+  // which got live-found in a row this same afternoon (the gate never
+  // set; set but the fetch 401ing; set and fetched but still an early
+  // snapshot for a slow-registering package like uibuilder). The one
+  // thing still worth gating is genuinely knowing nothing yet: before
+  // Node-RED's own "flows:started" event (the non-deprecated alias of
+  // "nodes-started", confirmed emitted from
+  // @node-red/runtime/lib/flows/index.js right after every active flow's
+  // own start() resolves) has fired at least once,
+  // describeInstalledNodes() returns null — "don't know yet" instead of a
+  // false "confirmed absent."
   // ---------------------------------------------------------------------
-  let installedNodesCache = null;
-  let installedNodesCacheAt = 0;
-  let installedNodesRefreshInFlight = false;
-  const INSTALLED_NODES_CACHE_TTL_MS = 5 * 60 * 1000;
+  let nodesRegistryReady = false;
+  RED.events.on("flows:started", function () { nodesRegistryReady = true; });
 
   function buildInstalledNodesContent(list) {
     if (!Array.isArray(list)) { return null; }
@@ -752,39 +817,13 @@ module.exports = function flowPilotRuntime(RED) {
     return content;
   }
 
-  function refreshInstalledNodesCache() {
-    if (installedNodesRefreshInFlight) { return; }
-    installedNodesRefreshInFlight = true;
-
-    const root = String(RED.settings.httpAdminRoot || "/").replace(/\/+$/, "");
-    const req = http.get({
-      host: "127.0.0.1",
-      port: RED.settings.uiPort,
-      path: root + "/nodes",
-      headers: { Accept: "application/json" },
-      timeout: 5000
-    }, function (res) {
-      const chunks = [];
-      res.on("data", function (chunk) { chunks.push(chunk); });
-      res.on("end", function () {
-        installedNodesRefreshInFlight = false;
-        if (res.statusCode !== 200) { return; }
-        try {
-          const list = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-          installedNodesCache = buildInstalledNodesContent(list);
-          installedNodesCacheAt = Date.now();
-        } catch (err) { /* leave previous cache value in place */ }
-      });
-    });
-    req.on("error", function () { installedNodesRefreshInFlight = false; });
-    req.on("timeout", function () { req.destroy(); installedNodesRefreshInFlight = false; });
-  }
-
   function describeInstalledNodes() {
-    if (Date.now() - installedNodesCacheAt > INSTALLED_NODES_CACHE_TTL_MS) {
-      refreshInstalledNodesCache();
+    if (!nodesRegistryReady) { return null; }
+    try {
+      return buildInstalledNodesContent(nodeRedRegistry.getNodeList());
+    } catch (err) {
+      return null;
     }
-    return installedNodesCache;
   }
 
   // Chat-only: the user's base system prompt plus a freshly-generated

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

@@ -1259,7 +1259,19 @@
             updateSelectionStatus();
             return true;
         }
-        if (data.prose) {
+        // finalizeSimpleGeneration/finalizeModifyResult set prose:true on
+        // EVERY agent-strategy final response, whether or not real
+        // WRITE-tool work happened this run — it's the server's generic
+        // "no classic flow/changes to review" signal, not a claim that
+        // nothing happened. When real write results are attached
+        // (data._agentWriteResults, added client-side in handleStep before
+        // onDone fires), the caller's own deterministic-summary rendering
+        // needs to run instead of this generic prose bubble — bug found
+        // live during the 0.6.0 go-live smoke test: this unconditional
+        // early-return made C1's entire deterministic-summary/prose-
+        // demotion feature unreachable for every real agent-strategy run.
+        var hasRealWriteResults = Array.isArray(data._agentWriteResults) && data._agentWriteResults.length > 0;
+        if (data.prose && !hasRealWriteResults) {
             if (looksLikeToolEnvelope(data.explanation)) {
                 handleExecuteError("FlowPilot's reply didn't come through as expected.", data.explanation);
                 updateSelectionStatus();
@@ -1320,7 +1332,7 @@
         // executable flows (not documentation-only comment nodes) and when no
         // loop is already active. The secondary "Just add to canvas" button is
         // always shown alongside it as an escape hatch.
-        var _hasDeployable = flow.some(function (n) { return n && n.type !== "comment" && n.type !== "group"; });
+        var _hasDeployable = (flow || []).some(function (n) { return n && n.type !== "comment" && n.type !== "group"; });
         var _buildOnImported = (goalPrompt && !activeBuildLoop && _hasDeployable)
             ? function (importResult) { startBuildLoop(goalPrompt, flow, importResult); }
             : null;
@@ -1663,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;
     }
 
@@ -2019,7 +2056,7 @@
         // also runs verifyImportedNodes so the todo record still gets checked
         // off. Without a build loop, fall back to a plain "Add to canvas"
         // button that still fires the verify callback.
-        var _hasDeployable = flow.some(function (n) { return n && n.type !== "comment" && n.type !== "group"; });
+        var _hasDeployable = (flow || []).some(function (n) { return n && n.type !== "comment" && n.type !== "group"; });
         var _wantLoop = goalPrompt && !activeBuildLoop && _hasDeployable;
         var _onImported = _wantLoop
             ? function (importResult) {

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.0",
+  "version": "0.6.2",
   "description": "FlowPilot for Node-RED - an AI-powered development assistant sidebar",
   "main": "flowpilot.js",
   "keywords": [