comfyui-mcp 0.50.99 → 0.50.101

package/dist/orchestrator/panel-tools.js

@@ -1341,6 +1341,28 @@ function toolResultText(res) {
  *  else about it — including `isError` and any non-text content. Used where the
  *  original message must reach the caller VERBATIM and we are only adding what we
  *  additionally know, never restating (or re-classifying) what it already said. */
+/** All text in a tool result, joined — for quoting one result inside another. */
+function textOfToolResult(res) {
+    return res.content.map((c) => c.text ?? "").join(" ").trim();
+}
+/**
+ * #1329 — the panel's STALE NODE SCHEMA refusal, which is worth acting on rather than
+ * relaying.
+ *
+ * It is the one refusal here whose prescribed remedy has no decision in it: the class
+ * this page registered has drifted from the server's, and `refresh_nodes` re-fetches
+ * /object_info and re-registers it in place. The reporter ran that by hand twice and it
+ * worked twice.
+ *
+ * Matched on the drift sentence rather than on "panel_refresh_nodes", which appears in
+ * several unrelated remedies — keying on the recommendation would make any of them
+ * trigger an add-retry.
+ */
+function isStaleNodeSchemaRefusal(res) {
+    if (!res.isError)
+        return false;
+    return /added or retyped since this page loaded its node schema/i.test(textOfToolResult(res));
+}
 function appendToolResultText(res, extra) {
     const idx = res?.content?.findIndex((c) => c.type === "text") ?? -1;
     const block = idx >= 0 ? res.content[idx] : undefined;
@@ -5168,15 +5190,17 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets) {
         catch (err) {
             // Only a card-reply TIMEOUT is recoverable/honest-as-timeout: poll the late
             // buffer, then report "timeout" if still unanswered. Any other error (no
-            // panel, transport failure) → "no" so the destructive op is SKIPPED, exactly
-            // as the previous catch-all did.
+            // panel, transport failure) still SKIPS the destructive op — but it is reported
+            // as `unreachable`, not `no` (#1332). The user did not decline; we never got to
+            // ask them, and a caller that says "cancelled" on this is describing a decision
+            // nobody made.
             if (isReplyTimeoutError(err)) {
                 const late = await pollLateAskReply(bridge, askId, timing, budgetEnd);
                 if (late !== undefined)
                     return isAffirmative(late) ? "yes" : "no";
                 return "timeout";
             }
-            return "no";
+            return "unreachable";
         }
     };
     // EXPLICIT self-heal — see PanelToolCtx.rebindToActiveTab. Only rebinds when
@@ -6673,12 +6697,46 @@ export function buildPanelToolDefs() {
                 .optional()
                 .describe("Canvas [x, y] (two numbers). Auto-placed beside existing nodes when omitted."),
             title: z.string().optional().describe("Optional custom node title."),
-        }, async (args, ctx) => 
-        // #599: the frontend gates the add on a FRESH /object_info (assertAddNode-
-        // ResolvableRefreshing) so an uninstalled class can't be added as a
-        // placeholder — that fetch can outlast the 6000 ms default on a large
-        // install. Give it the bounded refresh ack budget.
-        ctx.call({ cmd: "graph_add_node", class_type: args.class_type, pos: args.pos, title: args.title }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS)),
+        }, async (args, ctx) => {
+            // #599: the frontend gates the add on a FRESH /object_info (assertAddNode-
+            // ResolvableRefreshing) so an uninstalled class can't be added as a
+            // placeholder — that fetch can outlast the 6000 ms default on a large
+            // install. Give it the bounded refresh ack budget.
+            const add = () => ctx.call({ cmd: "graph_add_node", class_type: args.class_type, pos: args.pos, title: args.title }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS);
+            const first = await add();
+            if (!isStaleNodeSchemaRefusal(first))
+                return first;
+            // #1329 — DO THE REFRESH THE REFUSAL ASKS FOR, instead of billing the caller.
+            //
+            // The reporter uploaded two images, and both LoadImage adds were refused with
+            // "call panel_refresh_nodes and retry". Doing exactly that worked, both times.
+            // That is a round trip and an agent-visible error for something with one
+            // correct response and no decision in it.
+            //
+            // Safe to automate for a checkable reason, not a hopeful one: the panel's guard
+            // throws BEFORE it creates anything ("Refuse before creating anything"), so the
+            // retry cannot leave two nodes behind. Mutations are otherwise never re-issued
+            // on our own initiative, and that rule is intact — this is not a transport
+            // failure with an unknown outcome, it is a refusal that states its own.
+            const refreshed = await ctx.call({ cmd: "refresh_nodes" }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS);
+            if (refreshed.isError) {
+                // The refusal is the better error: it names what is wrong with the SCHEMA and
+                // what clears it. Carry the refresh failure alongside so the caller knows the
+                // automatic attempt happened and why it did not help.
+                return appendToolResultText(first, `\n\n(Tried to clear this automatically: panel_refresh_nodes was dispatched and FAILED, ` +
+                    `so the schema is unchanged and retrying the add will refuse again. ` +
+                    `${textOfToolResult(refreshed)})`);
+            }
+            const second = await add();
+            if (!isStaleNodeSchemaRefusal(second))
+                return second;
+            // Still stale after a successful refresh: report THAT, because it means the
+            // remedy the refusal prescribes does not fix this instance and a caller
+            // following it by hand would loop.
+            return appendToolResultText(second, `\n\n(This was already retried ONCE automatically: panel_refresh_nodes reported success ` +
+                `and the add still refuses, so repeating panel_refresh_nodes will not clear it. ` +
+                `Reload the ComfyUI browser tab, which rebuilds the page's node registry from scratch.)`);
+        }),
         def("panel_remove_node", "Remove a node (and its connections) from the user's open graph by id. Undoable with Ctrl+Z.", { node_id: nodeId().describe("Node id from panel_graph_outline / panel_query_graph.") }, async (args, ctx) => ctx.call({ cmd: "graph_remove_node", node_id: args.node_id })),
         def("panel_clear", "Remove EVERY node from the user's open graph — only for an explicit 'clear/reset the canvas'. Just CALL THIS DIRECTLY when they ask to clear: the tool itself pops a confirm card and only wipes on a yes (don't ask separately first). The wipe is a single Ctrl+Z undo. NEVER use this for a 'new workflow' — that's panel_new_workflow (a new tab, leaves this graph intact).", {}, async (_args, ctx) => {
             const decision = await ctx.confirm("Clear the canvas? This removes every node from the open workflow. (One Ctrl+Z undoes it.)", "Clear canvas");
@@ -6686,6 +6744,14 @@ export function buildPanelToolDefs() {
                 return ok("Timed out waiting for your confirmation, so I left the canvas as-is. " +
                     "Tell me to clear it again when you're ready.");
             }
+            if (decision === "unreachable") {
+                // #1332 — the canvas is still untouched, which is the part that matters, but
+                // the user never saw the question. Saying "cancelled" would credit them with
+                // a decision they were never offered.
+                return ok("The canvas was left as-is — but NOT because it was declined: the panel could " +
+                    "not be reached to ask, so the question never appeared. Nothing was cleared. " +
+                    "Check the panel tab is connected, then ask again.");
+            }
             if (decision !== "yes") {
                 return ok("Cancelled — the canvas was left as-is.");
             }
@@ -8878,7 +8944,26 @@ export function buildPanelToolDefs() {
                         : "Cancelled — no new restart was dispatched. ComfyUI was briefly " +
                             "unreachable but is healthy again.");
                 }
-                return ok("Cancelled — ComfyUI was not restarted.");
+                // #1332 — the reporter's exact string, and it was FALSE. They accepted the
+                // restart, ComfyUI restarted (a fresh startup in the server log), and this
+                // said it had not — because the restart dropped the socket the answer had to
+                // travel back on, and a transport failure used to arrive here as "no".
+                //
+                // The probes above already refuse to claim "not restarted" while the server
+                // is DOWN. This is the remaining case: the server is HEALTHY, which is
+                // equally true of "nothing happened" and of "it restarted and came back".
+                // With an explicit decline we know which; without one we do not, and the
+                // sentence must stop asserting it.
+                return ok(decision === "unreachable"
+                    ? "This call did NOT dispatch a restart. Whether ComfyUI restarted for some " +
+                        "other reason cannot be told from here: the panel could not be reached to " +
+                        "ask for confirmation — the question never appeared — so no decision was " +
+                        "made either way, and the server is reachable now, which looks the same " +
+                        "whether it never went down or went down and came back. If you asked for a " +
+                        "restart and one has already happened, this is that transport loss, not a " +
+                        "cancellation. Check the ComfyUI log for a fresh startup line before " +
+                        "restarting again."
+                    : "Cancelled — ComfyUI was not restarted.");
             }
             // Heal an orphaned session onto the live tab FIRST, then bind the reboot dispatch
             // to that ONE tab id (no await between capture and dispatch, so JS run-to-