comfyui-mcp 0.52.27 → 0.52.28

package/dist/orchestrator/panel-tools.js

@@ -34,6 +34,7 @@ import { fileURLToPath } from "node:url";
 import { comfyuiFetch } from "../comfyui/fetch.js";
 import { assertPanelNotTargetedUnverifiable } from "../services/panel-pin-guard.js";
 import { nodesInstallCommandArgs } from "../services/node-management.js";
+import { sanitizePanelUpdateNodeResult } from "../services/manager-update-error.js";
 import { formatQueueStatusPartialNote, getManifestPartialLeftover, } from "../services/manifest-partial.js";
 import { searchPanelNodes } from "../services/manager-node-search.js";
 import { isPanelAnsweredError } from "../services/panel-answered.js";
@@ -573,6 +574,11 @@ export const __panelToolsTestHooks = {
     setFreeVramDirect(fn) {
         freeVramDirectOverride = fn;
     },
+    /** Inject a fake post-/free /system_stats read so #1866 occupancy checks can
+     *  be driven without real HTTP. null restores the live readVramDevices. */
+    setReadVramDevices(fn) {
+        readVramDevicesOverride = fn;
+    },
     /** Direct access to the #742 decline recheck loop so its hard-deadline
      *  guarantee (codex gate r2) can be unit-tested with a custom deadline. */
     probeDeclineRecovery,
@@ -2185,17 +2191,7 @@ async function readVramDevices(base, timeoutMs) {
         const devices = body.devices;
         if (!Array.isArray(devices))
             return null;
-        return devices.map((d) => {
-            const dev = (d ?? {});
-            const sample = {};
-            if (typeof dev.name === "string")
-                sample.name = dev.name;
-            if (typeof dev.vram_total === "number")
-                sample.vram_total = dev.vram_total;
-            if (typeof dev.vram_free === "number")
-                sample.vram_free = dev.vram_free;
-            return sample;
-        });
+        return devices.map((d) => sampleVramDevice(d));
     }
     catch {
         return null; // unreachable/timed out — no numbers to report
@@ -2204,12 +2200,98 @@ async function readVramDevices(base, timeoutMs) {
         clearTimeout(timer);
     }
 }
+function sampleVramDevice(d) {
+    const dev = (d ?? {});
+    const sample = {};
+    if (typeof dev.name === "string")
+        sample.name = dev.name;
+    if (typeof dev.index === "number")
+        sample.index = dev.index;
+    if (typeof dev.vram_total === "number")
+        sample.vram_total = dev.vram_total;
+    if (typeof dev.vram_free === "number")
+        sample.vram_free = dev.vram_free;
+    if (typeof dev.torch_vram_total === "number")
+        sample.torch_vram_total = dev.torch_vram_total;
+    if (typeof dev.torch_vram_free === "number")
+        sample.torch_vram_free = dev.torch_vram_free;
+    return sample;
+}
+/** A device with at least 1 GiB of VRAM is still PINNED when less than 20% is
+ *  free after /free. CUDA context leftover on an unloaded GPU is a few hundred
+ *  MB to a couple of GiB, not 80%+ of a 21 GiB card. The reporter's Raylight
+ *  MiniMax H3 case was device 2 at ~0.8% free (~179 MiB of 21 GiB) next to
+ *  siblings at ~44% free — that occupancy is what this threshold names.
+ *
+ *  Unknown/unreadable counters are NOT pinned: an unknown answer claims
+ *  nothing in either direction (#1473). */
+const PINNED_VRAM_MIN_TOTAL_BYTES = 1024 * 1024 * 1024;
+const PINNED_VRAM_FREE_RATIO = 0.2;
+function deviceStillPinned(d) {
+    const total = d.vram_total;
+    const free = d.vram_free;
+    if (typeof total !== "number" || typeof free !== "number")
+        return false;
+    if (!Number.isFinite(total) || !Number.isFinite(free))
+        return false;
+    if (total < PINNED_VRAM_MIN_TOTAL_BYTES)
+        return false;
+    if (free < 0)
+        return true;
+    return free / total <= PINNED_VRAM_FREE_RATIO;
+}
+function pinnedVramDevices(devices) {
+    return devices.filter(deviceStillPinned);
+}
+/** /free only unloads ComfyUI's model manager. Ray workers, parallel CLIP
+ *  loaders, and other custom-node allocations survive it and keep the GPU
+ *  occupied — which is why a 2xx from /free is not evidence VRAM is free. */
+function pinnedVramAfterFreeNote(pinned) {
+    const named = pinned
+        .map((d) => {
+        if (typeof d.index === "number")
+            return `device ${d.index}`;
+        if (typeof d.name === "string" && d.name)
+            return d.name;
+        return "an unnamed device";
+    })
+        .join(", ");
+    return (`ComfyUI /free accepted (unload_models + free_memory) but VRAM is STILL PINNED on ` +
+        `${named}. /free only unloads ComfyUI's model manager — it does not terminate Ray ` +
+        `workers or custom-node allocations (Raylight sequence-parallel, parallel CLIP loaders). ` +
+        `This is not a successful VRAM recovery. Next: panel_restart_comfyui (last resort; ` +
+        `refuses mid-render) after confirming with get_system_stats (action:"stats").`);
+}
+function pinnedVramAfterFreeResult(pinned, extra) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    freed: false,
+                    unload_models: true,
+                    free_memory: true,
+                    model_manager_freed: true,
+                    pinned_devices: pinned,
+                    ...extra,
+                    note: pinnedVramAfterFreeNote(pinned),
+                }, null, 2),
+            },
+        ],
+        isError: true,
+    };
+}
+/** Test injection for the post-/free /system_stats occupancy read (#1866). */
+let readVramDevicesOverride = null;
+async function readVramDevicesMaybe(base, timeoutMs) {
+    return (readVramDevicesOverride ?? readVramDevices)(base, timeoutMs);
+}
 /** Issue ComfyUI's /free DIRECTLY against a proven-local base and read the
  *  VRAM counters around it. Never throws — every failure is a value, so the
  *  settle can degrade to the honest outcome-unknown instead of masking the
  *  original timeout behind a new error. */
 async function freeVramDirect(base) {
-    const before = await readVramDevices(base, FREE_VRAM_DIRECT_TIMEOUT_MS);
+    const before = await readVramDevicesMaybe(base, FREE_VRAM_DIRECT_TIMEOUT_MS);
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), FREE_VRAM_DIRECT_TIMEOUT_MS);
     timer.unref?.();
@@ -2234,7 +2316,7 @@ async function freeVramDirect(base) {
     finally {
         clearTimeout(timer);
     }
-    const after = await readVramDevices(base, FREE_VRAM_DIRECT_TIMEOUT_MS);
+    const after = await readVramDevicesMaybe(base, FREE_VRAM_DIRECT_TIMEOUT_MS);
     return { ok: true, before, after };
 }
 /** Test injection for the direct server-side /free, so the settle can be
@@ -2277,6 +2359,21 @@ async function settleFreeVramAfterAckTimeout(ctx, timedOut) {
             ],
         };
     }
+    const extra = {
+        acknowledged: false,
+        verified: "server-side",
+        via: `POST ${base}/free`,
+        ...(direct.before != null ? { vram_before: direct.before } : {}),
+        ...(direct.after != null ? { vram_after: direct.after } : {}),
+    };
+    // #1866 — a 2xx from /free is not a free GPU. Ray/CLIP workers can keep a
+    // device pinned. When we have occupancy numbers, they are the verdict.
+    if (direct.after != null) {
+        const pinned = pinnedVramDevices(direct.after);
+        if (pinned.length > 0) {
+            return pinnedVramAfterFreeResult(pinned, extra);
+        }
+    }
     const statsNote = direct.before != null && direct.after != null
         ? "vram_before/vram_after are the server's own /system_stats counters around the free."
         : "The /system_stats read around it did not answer, so no VRAM counters are reported — the 2xx from /free is the verification, not a measured delta.";
@@ -2284,11 +2381,7 @@ async function settleFreeVramAfterAckTimeout(ctx, timedOut) {
         freed: true,
         unload_models: true,
         free_memory: true,
-        acknowledged: false,
-        verified: "server-side",
-        via: `POST ${base}/free`,
-        ...(direct.before != null ? { vram_before: direct.before } : {}),
-        ...(direct.after != null ? { vram_after: direct.after } : {}),
+        ...extra,
         note: `The panel tab never acknowledged (frozen or backgrounded), so the free was issued ` +
             `DIRECTLY to the ComfyUI server this tab provably fronts — the same /free endpoint the ` +
             `panel would have called — and the server confirmed it. /free is idempotent: if the tab's ` +
@@ -2296,6 +2389,32 @@ async function settleFreeVramAfterAckTimeout(ctx, timedOut) {
             `twice. ${statsNote}`,
     });
 }
+/**
+ * #1866 — a panel ack of `{freed:true}` is the /free HTTP 2xx, not a measured
+ * GPU. After the tab says it posted /free, re-read /system_stats and refuse to
+ * claim VRAM was freed when a device is still occupied. Unreadable stats leave
+ * the original ack UNTOUCHED: an unknown answer claims nothing extra.
+ */
+async function annotateFreeVramAck(res) {
+    if (res.isError)
+        return res;
+    const parsed = parseToolResultJson(res);
+    if (!parsed || parsed.freed !== true)
+        return res;
+    const base = (getComfyUIBaseUrl() || "").replace(/\/+$/, "");
+    if (!base)
+        return res;
+    const devices = await readVramDevicesMaybe(base, FREE_VRAM_DIRECT_TIMEOUT_MS);
+    if (devices == null)
+        return res;
+    const pinned = pinnedVramDevices(devices);
+    if (pinned.length === 0)
+        return res;
+    return pinnedVramAfterFreeResult(pinned, {
+        acknowledged: true,
+        devices,
+    });
+}
 // ---- panel_install_node: accepted-but-never-enqueued (#1129) ---------------
 // #1143 fixed the pre-queue REFUSAL (403/404 → direct clone). This is the other
 // half of the same family: legacy Manager 3.x answers the install POST with
@@ -12481,7 +12600,16 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
             mode: z.enum(["remote", "local", "cache"]).optional().describe("DB source (default 'remote')."),
         }, async (args, ctx) => {
             assertPanelNotTargetedUnverifiable("panel_update_node", args.id);
-            return ctx.call({ cmd: "graph_update_node", id: args.id, version: args.version, channel: args.channel, mode: args.mode }, 30000);
+            const res = await ctx.call({ cmd: "graph_update_node", id: args.id, version: args.version, channel: args.channel, mode: args.mode }, 30000);
+            // #1870 — the panel attaches /internal/logs/raw as "Manager traceback"
+            // when do_update stores only the generic sentence. That log also holds
+            // the previous generation error, which names the same pack, so a zip
+            // update-git miss was reported as FalApiError. Keep Manager evidence
+            // (res.action=update-git) and drop execution history.
+            return sanitizePanelUpdateNodeResult(res, {
+                id: typeof args.id === "string" ? args.id : "",
+                version: typeof args.version === "string" ? args.version : undefined,
+            });
         }),
         def("panel_node_queue_status", "Check the built-in Manager's install/update queue status (to see if a queued install finished). Read-only. " +
             "A drained queue (total_count: 0, is_processing: false) only means THIS queue is idle — " +
@@ -13740,16 +13868,18 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
                         ".") + argvNote + (preflightNote ? ` ${preflightNote}` : ""),
             });
         }),
-        def("panel_free_vram", "Unload all loaded models and free VRAM (ComfyUI /free). Use to unwedge a stuck/OOM ComfyUI when a cancel didn't free memory — before retrying or, last resort, restarting (panel_restart_comfyui). Does NOT restart ComfyUI; it just drops resident models and frees cached memory. If the panel tab is frozen and cannot acknowledge, the free is instead issued DIRECTLY to the ComfyUI server and verified there (same /free, idempotent) whenever the tab provably fronts the local server — otherwise the outcome is reported unknown rather than claimed.", {}, async (_args, ctx) => {
+        def("panel_free_vram", "Unload all loaded models and free VRAM (ComfyUI /free). Use to unwedge a stuck/OOM ComfyUI when a cancel didn't free memory — before retrying or, last resort, restarting (panel_restart_comfyui). Does NOT restart ComfyUI; it just drops resident models and frees cached memory. After /free, occupancy is re-read from /system_stats: if a device remains pinned (Ray workers, parallel CLIP, custom-node allocations /free cannot terminate), the reply names those devices and does NOT claim VRAM was freed — next step is panel_restart_comfyui. If the panel tab is frozen and cannot acknowledge, the free is instead issued DIRECTLY to the ComfyUI server and verified there (same /free, idempotent) whenever the tab provably fronts the local server — otherwise the outcome is reported unknown rather than claimed.", {}, async (_args, ctx) => {
             const res = await ctx.call({ cmd: "free_vram" }, 15000);
             // #1249 — ONLY a no-reply is settled server-side. An acked executor error
             // (the panel's own "Failed to free VRAM: …") is a reply the bridge
             // received and relayed; it already says what failed, and re-issuing from
             // out here would fire a second mutation behind a verdict the caller was
             // given. A tagged reply-timeout is the one case where nothing answered.
-            if (!isReplyTimeoutResult(res))
-                return res;
-            return settleFreeVramAfterAckTimeout(ctx, res);
+            if (isReplyTimeoutResult(res))
+                return settleFreeVramAfterAckTimeout(ctx, res);
+            // #1866 — a successful /free ack is not a free GPU. Re-read occupancy
+            // and refuse to report freed:true when a device is still pinned.
+            return annotateFreeVramAck(res);
         }),
         def("panel_show_media", "Display one or more images or videos directly in the panel chat. Use this whenever the user asks to SEE or SHOW a file — a disk path you composited/downloaded/generated (absolute path on the orchestrator host) OR a ComfyUI output ref ({ filename, subfolder?, type? }). Items are rendered as media cards in the agent chat area; supply optional captions. Max 8 items per call. A path item OVER the 20 MB inline cap that is not under any directory ComfyUI serves can still be shown by passing stage:true on that item — the orchestrator COPIES it into <output>/_panel_staged (an opt-in, persistent disk write; 512 MB per-file and 2 GB total caps) and displays the copy by reference. NEVER describe an image with emoji or text placeholders — call this tool instead.", {
             items: z