@openclaw/comfy-provider 2026.11.3 → 2026.11.5-beta.2

package/dist/.source-module-urls/af112485932ee2451e1e8378d37b2058d6bb057dc6d0fd0f3b04da8b7510d1be.json

@@ -0,0 +1 @@
+{"version":3,"entries":[{"output":"index.js","source":"extensions/comfy/index.ts"},{"output":"workflow-http.js","source":"extensions/comfy/workflow-http.ts"},{"output":"workflow-runtime.js","source":"extensions/comfy/workflow-runtime.ts"}],"chunks":[{"output":"index.js","sha256":"c403ae5912cedc989f2fb8a1b08b67fb0865e1e5fca5cc635a01d7383e3258de","facadeSource":"extensions/comfy/index.ts","sources":["extensions/comfy/index.ts"]},{"output":"workflow-http.js","sha256":"82c1403fa34781b80c8cede9aabc7e8e1f88d9d8ee6cc26984aa7ef68cb4cec4","facadeSource":"extensions/comfy/workflow-http.ts","sources":["extensions/comfy/workflow-http.ts"]},{"output":"workflow-runtime.js","sha256":"a9883b89df220759026445689df0e6f6f1b92436a9e036b3d74a1afcd8397162","facadeSource":"extensions/comfy/workflow-runtime.ts","sources":["extensions/comfy/workflow-runtime.ts"]}],"unrenderedSources":[]}

package/dist/index.js

@@ -1,10 +1,45 @@
-import { buildComfyImageGenerationProvider } from "./image-generation-provider.js";
-import { buildComfyMusicGenerationProvider } from "./music-generation-provider.js";
-import { buildComfyVideoGenerationProvider } from "./video-generation-provider.js";
+import { DEFAULT_COMFY_MODEL, isComfyCapabilityConfigured, isComfyCapabilityConfiguredAsync, runComfyWorkflow } from "./workflow-runtime.js";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { createProviderApiKeyAuthMethod } from "openclaw/plugin-sdk/provider-auth-api-key";
 //#region extensions/comfy/index.ts
 const PROVIDER_ID = "comfy";
+const COMFY_MAX_INPUT_IMAGES = 1;
+function comfyProviderDefaults(capability) {
+	return {
+		id: PROVIDER_ID,
+		label: "ComfyUI",
+		defaultModel: DEFAULT_COMFY_MODEL,
+		models: [DEFAULT_COMFY_MODEL],
+		isConfigured: ({ cfg, agentDir }) => isComfyCapabilityConfigured({
+			cfg,
+			agentDir,
+			capability
+		}),
+		isConfiguredAsync: ({ cfg, agentDir }) => isComfyCapabilityConfiguredAsync({
+			cfg,
+			agentDir,
+			capability
+		})
+	};
+}
+function resolveInputImage(inputImage) {
+	if (!inputImage) return;
+	if (!inputImage.buffer) throw new Error("Comfy music generation requires loaded reference image bytes.");
+	return {
+		buffer: inputImage.buffer,
+		mimeType: inputImage.mimeType ?? "image/png",
+		fileName: inputImage.fileName
+	};
+}
+function toComfyInputImage(inputImage) {
+	if (!inputImage) return;
+	if (!inputImage.buffer || !inputImage.mimeType) throw new Error("Comfy video generation requires a local reference image file");
+	return {
+		buffer: inputImage.buffer,
+		mimeType: inputImage.mimeType,
+		fileName: inputImage.fileName
+	};
+}
 var comfy_default = definePluginEntry({
 	id: PROVIDER_ID,
 	name: "ComfyUI Provider",
@@ -35,9 +70,106 @@ var comfy_default = definePluginEntry({
 				}
 			})]
 		});
-		api.registerImageGenerationProvider(buildComfyImageGenerationProvider());
-		api.registerMusicGenerationProvider(buildComfyMusicGenerationProvider());
-		api.registerVideoGenerationProvider(buildComfyVideoGenerationProvider());
+		api.registerImageGenerationProvider({
+			...comfyProviderDefaults("image"),
+			capabilities: {
+				generate: {
+					maxCount: 1,
+					supportsSize: false,
+					supportsAspectRatio: false,
+					supportsResolution: false
+				},
+				edit: {
+					enabled: true,
+					maxCount: 1,
+					maxInputImages: 1,
+					supportsSize: false,
+					supportsAspectRatio: false,
+					supportsResolution: false
+				}
+			},
+			async generateImage(req) {
+				if ((req.inputImages?.length ?? 0) > 1) throw new Error("Comfy image generation currently supports at most one reference image");
+				const result = await runComfyWorkflow({
+					...req,
+					capability: "image",
+					inputImage: req.inputImages?.[0]
+				});
+				return {
+					images: result.assets,
+					model: result.model,
+					metadata: result.metadata
+				};
+			}
+		});
+		api.registerMusicGenerationProvider({
+			...comfyProviderDefaults("music"),
+			capabilities: {
+				generate: {},
+				edit: {
+					enabled: true,
+					maxInputImages: COMFY_MAX_INPUT_IMAGES
+				}
+			},
+			async generateMusic(req) {
+				if ((req.inputImages?.length ?? 0) > COMFY_MAX_INPUT_IMAGES) throw new Error(`Comfy music generation supports at most ${COMFY_MAX_INPUT_IMAGES} reference image.`);
+				const result = await runComfyWorkflow({
+					...req,
+					capability: "music",
+					inputImage: resolveInputImage(req.inputImages?.[0])
+				});
+				return {
+					tracks: result.assets.map(({ buffer, mimeType, fileName }) => ({
+						buffer,
+						mimeType,
+						fileName
+					})),
+					model: result.model,
+					metadata: {
+						...result.metadata,
+						inputImageCount: req.inputImages?.length ?? 0
+					}
+				};
+			}
+		});
+		api.registerVideoGenerationProvider({
+			...comfyProviderDefaults("video"),
+			capabilities: {
+				generate: {
+					maxVideos: 1,
+					supportsSize: false,
+					supportsAspectRatio: false,
+					supportsResolution: false,
+					supportsAudio: false,
+					supportsWatermark: false
+				},
+				imageToVideo: {
+					enabled: true,
+					maxVideos: 1,
+					maxInputImages: 1,
+					supportsSize: false,
+					supportsAspectRatio: false,
+					supportsResolution: false,
+					supportsAudio: false,
+					supportsWatermark: false
+				},
+				videoToVideo: { enabled: false }
+			},
+			async generateVideo(req) {
+				if ((req.inputImages?.length ?? 0) > 1) throw new Error("Comfy video generation currently supports at most one reference image");
+				if ((req.inputVideos?.length ?? 0) > 0) throw new Error("Comfy video generation does not support input videos");
+				const result = await runComfyWorkflow({
+					...req,
+					capability: "video",
+					inputImage: toComfyInputImage(req.inputImages?.[0])
+				});
+				return {
+					videos: result.assets,
+					model: result.model,
+					metadata: result.metadata
+				};
+			}
+		});
 	}
 });
 //#endregion

package/dist/workflow-http.js

@@ -0,0 +1,38 @@
+import { resolvePositiveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { assertOkOrThrowHttpError, readProviderJsonResponse } from "openclaw/plugin-sdk/provider-http";
+import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
+//#region extensions/comfy/workflow-http.ts
+async function readJsonResponse(params) {
+	const { errorPrefix, deadline, timeoutMs, ...request } = params;
+	const remainingMs = () => resolveComfyRemainingMs(deadline, timeoutMs);
+	const { response, release } = await fetchWithSsrFGuard({
+		...request,
+		timeoutMs: remainingMs()
+	});
+	try {
+		const requestHeaders = params.init?.headers;
+		await assertOkOrThrowHttpError(response, errorPrefix, {
+			requestHeaders,
+			bodyTimeoutMs: remainingMs,
+			onBodyTimeout: () => createComfyTimeoutError(timeoutMs)
+		});
+		return await readProviderJsonResponse(response, errorPrefix, {
+			requestHeaders,
+			timeoutMs: remainingMs,
+			onTimeout: () => createComfyTimeoutError(timeoutMs)
+		});
+	} finally {
+		await release();
+	}
+}
+function createComfyTimeoutError(timeoutMs) {
+	return /* @__PURE__ */ new Error(`Comfy workflow did not finish within ${Math.ceil(timeoutMs / 1e3)}s`);
+}
+function resolveComfyRemainingMs(deadline, timeoutMs, defaultTimeoutMs = timeoutMs) {
+	const defaultMs = resolvePositiveTimerTimeoutMs(defaultTimeoutMs, 1);
+	const remainingMs = deadline - performance.now();
+	if (remainingMs <= 0) throw createComfyTimeoutError(timeoutMs);
+	return Math.max(1, Math.min(defaultMs, remainingMs));
+}
+//#endregion
+export { createComfyTimeoutError, readJsonResponse, resolveComfyRemainingMs };

package/dist/workflow-runtime.js

@@ -1,4 +1,4 @@
-import { isTerminalComfyHistory } from "./workflow-history.js";
+import { createComfyTimeoutError, readJsonResponse, resolveComfyRemainingMs } from "./workflow-http.js";
 import { randomInt } from "node:crypto";
 import fs from "node:fs/promises";
 import { bufferToBlobPart } from "openclaw/plugin-sdk/blob-runtime";
@@ -7,13 +7,22 @@ import { extensionForMime } from "openclaw/plugin-sdk/media-mime";
 import { resolvePositiveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { isProviderApiKeyConfigured, isProviderApiKeyConfiguredAsync } from "openclaw/plugin-sdk/provider-auth";
 import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";
-import { assertOkOrThrowHttpError, readProviderBinaryResponse, readProviderJsonResponse, redactProviderResponseErrorText, resolveProviderHttpRequestConfig } from "openclaw/plugin-sdk/provider-http";
+import { assertOkOrThrowHttpError, readProviderBinaryResponse, redactProviderResponseErrorText, resolveProviderHttpRequestConfig } from "openclaw/plugin-sdk/provider-http";
 import { normalizeSecretInputString, resolveConfiguredSecretInputString, resolveSecretInputString } from "openclaw/plugin-sdk/secret-input-runtime";
 import { canResolveEnvSecretRefInReadOnlyPath } from "openclaw/plugin-sdk/secret-ref-readonly";
 import { fetchWithSsrFGuard, isPrivateOrLoopbackHost, mergeSsrFPolicies, ssrfPolicyFromHttpBaseUrlAllowedOrigin } from "openclaw/plugin-sdk/ssrf-runtime";
 import { asBoolean, isRecord, normalizeOptionalLowercaseString, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveUserPath, sleep } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/comfy/workflow-runtime.ts
+function isTerminalComfyHistory(entry, headers) {
+	if (entry.status?.status_str === "error") {
+		const messages = entry.status.messages;
+		const errorDetails = (Array.isArray(messages) ? messages.findLast((message) => Array.isArray(message) && message[0] === "execution_error") : void 0)?.[1];
+		const detail = isRecord(errorDetails) ? normalizeOptionalString(errorDetails.exception_message) : void 0;
+		throw new Error(`Comfy workflow failed${detail ? `: ${redactProviderResponseErrorText(detail, headers)}` : ""}`);
+	}
+	return entry.status?.completed === true || Boolean(entry.outputs && Object.keys(entry.outputs).length);
+}
 const DEFAULT_COMFY_LOCAL_BASE_URL = "http://127.0.0.1:8188";
 const DEFAULT_COMFY_CLOUD_BASE_URL = "https://cloud.comfy.org";
 const DEFAULT_POLL_INTERVAL_MS = 1500;
@@ -131,40 +140,6 @@ function resolveComfyNetworkPolicy(params) {
 function isSingleLabelServiceHostname(hostname) {
 	return /^[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?$/u.test(hostname);
 }
-async function readJsonResponse(params) {
-	const { errorPrefix, ...request } = params;
-	const { response, release } = await fetchWithSsrFGuard(request);
-	try {
-		const requestHeaders = params.init?.headers;
-		await assertOkOrThrowHttpError(response, errorPrefix, { requestHeaders });
-		return await readProviderJsonResponse(response, errorPrefix, { requestHeaders });
-	} finally {
-		await release();
-	}
-}
-async function uploadInputImage(connection, image, capability) {
-	const { baseUrl, mode, headers: requestHeaders, ...request } = connection;
-	const form = new FormData();
-	form.set("image", new Blob([bufferToBlobPart(image.buffer)], { type: image.mimeType }), normalizeOptionalString(image.fileName) || `input.${extensionForMime(image.mimeType)?.slice(1) || "bin"}`);
-	form.set("type", "input");
-	form.set("overwrite", "true");
-	const headers = new Headers(requestHeaders);
-	headers.delete("Content-Type");
-	const payload = await readJsonResponse({
-		...request,
-		url: `${baseUrl}${mode === "cloud" ? "/api/upload/image" : "/upload/image"}`,
-		init: {
-			method: "POST",
-			headers,
-			body: form
-		},
-		auditContext: `comfy-${capability}-upload`,
-		errorPrefix: "Comfy image upload failed"
-	});
-	const uploadedName = normalizeOptionalString(payload.filename) || normalizeOptionalString(payload.name);
-	if (!uploadedName) throw new Error("Comfy image upload response missing filename");
-	return uploadedName;
-}
 function extractHistoryEntry(history, promptId) {
 	if (!isRecord(history)) return null;
 	const directOutputs = history.outputs;
@@ -173,108 +148,6 @@ function extractHistoryEntry(history, promptId) {
 	if (isRecord(nested)) return nested;
 	return null;
 }
-async function waitForComfyHistory(params, promptId, pollIntervalMs) {
-	const { baseUrl, headers: requestHeaders, mode, ...request } = params;
-	const headers = new Headers(requestHeaders);
-	const deadline = performance.now() + params.timeoutMs;
-	const read = (path, kind, timeoutMs) => readJsonResponse({
-		...request,
-		url: `${baseUrl}${path}`,
-		init: {
-			method: "GET",
-			headers
-		},
-		timeoutMs,
-		auditContext: `comfy-${kind}`,
-		errorPrefix: `Comfy ${kind} lookup failed`
-	});
-	for (;;) {
-		const requestTimeoutMs = resolveComfyRemainingMs(deadline, params.timeoutMs);
-		if (mode === "cloud") {
-			const status = await read(`/api/job/${promptId}/status`, "status", requestTimeoutMs);
-			if (status.status === "completed") return await read(`/api/history_v2/${promptId}`, "history", params.timeoutMs);
-			if (status.status === "failed" || status.status === "cancelled") {
-				const detail = redactProviderResponseErrorText(status.error ?? status.message ?? promptId, headers);
-				throw new Error(`Comfy workflow ${status.status}: ${detail}`);
-			}
-		} else {
-			const entry = extractHistoryEntry(await read(`/history/${promptId}`, "history", requestTimeoutMs), promptId);
-			if (entry && isTerminalComfyHistory(entry, params.headers)) return entry;
-		}
-		const pollDelayMs = resolveComfyRemainingMs(deadline, params.timeoutMs, pollIntervalMs);
-		await sleep(pollDelayMs);
-	}
-}
-function resolveComfyRemainingMs(deadline, timeoutMs, defaultTimeoutMs = timeoutMs) {
-	const defaultMs = resolvePositiveTimerTimeoutMs(defaultTimeoutMs, 1);
-	const remainingMs = deadline - performance.now();
-	if (remainingMs <= 0) throw new Error(`Comfy workflow did not finish within ${Math.ceil(timeoutMs / 1e3)}s`);
-	return Math.max(1, Math.min(defaultMs, remainingMs));
-}
-function collectOutputFiles(params) {
-	const outputs = params.history.outputs;
-	if (!outputs) return [];
-	const nodeIds = params.outputNodeId ? [params.outputNodeId] : Object.keys(outputs);
-	const files = [];
-	for (const nodeId of nodeIds) {
-		const entry = outputs[nodeId];
-		if (!entry) continue;
-		for (const kind of params.outputKinds) {
-			const bucket = entry[kind];
-			if (!Array.isArray(bucket)) continue;
-			for (const file of bucket) {
-				if (params.capability === "video" && kind === "images") {
-					const fileName = normalizeOptionalString(file.filename) || normalizeOptionalString(file.name);
-					if (!fileName || !/\.(?:mp4|webm)$/i.test(fileName)) continue;
-				}
-				files.push({
-					nodeId,
-					file
-				});
-			}
-		}
-	}
-	return files;
-}
-async function downloadOutputFile(params, file, capability, maxBytes) {
-	const { baseUrl, headers: requestHeaders, mode, ...request } = params;
-	const headers = new Headers(requestHeaders);
-	const fileName = normalizeOptionalString(file.filename) || normalizeOptionalString(file.name);
-	if (!fileName) throw new Error("Comfy output entry missing filename");
-	const query = new URLSearchParams({
-		filename: fileName,
-		subfolder: normalizeOptionalString(file.subfolder) ?? "",
-		type: normalizeOptionalString(file.type) ?? "output"
-	});
-	const viewPath = mode === "cloud" ? "/api/view" : "/view";
-	const auditContext = `comfy-${capability}-download`;
-	const firstResponse = await fetchWithSsrFGuard({
-		...request,
-		url: `${baseUrl}${viewPath}?${query.toString()}`,
-		init: {
-			method: "GET",
-			headers
-		},
-		auditContext
-	});
-	try {
-		await assertOkOrThrowHttpError(firstResponse.response, "Comfy output download failed", { requestHeaders: headers });
-		const mimeType = normalizeOptionalString(firstResponse.response.headers.get("content-type")) || "application/octet-stream";
-		const downloadLabel = `Comfy ${capability} output download`;
-		return {
-			buffer: await readProviderBinaryResponse(firstResponse.response, downloadLabel, capability, {
-				maxBytes,
-				chunkTimeoutMs: params.timeoutMs,
-				onOverflow: ({ maxBytes: limit }) => /* @__PURE__ */ new Error(`${downloadLabel} exceeds ${limit} bytes`),
-				onIdleTimeout: ({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`${downloadLabel} stalled after ${chunkTimeoutMs}ms`)
-			}),
-			mimeType,
-			fileName
-		};
-	} finally {
-		await firstResponse.release();
-	}
-}
 function hasUnavailableComfyHeaderSecret(value, cfg) {
 	if (!isRecord(value)) return false;
 	return Object.entries(value).some(([name, headerValue]) => {
@@ -334,7 +207,7 @@ async function runComfyWorkflow(params) {
 	const seedInputName = normalizeOptionalString(capabilityConfig.seedInputName) ?? "seed";
 	const outputNodeId = normalizeOptionalString(capabilityConfig.outputNodeId);
 	const pollIntervalMs = resolvePositiveTimerTimeoutMs(readConfigInteger(capabilityConfig, "pollIntervalMs"), DEFAULT_POLL_INTERVAL_MS);
-	const timeoutMs = resolvePositiveTimerTimeoutMs(readConfigInteger(capabilityConfig, "timeoutMs") ?? params.timeoutMs, DEFAULT_TIMEOUT_MS);
+	const timeoutMs = resolvePositiveTimerTimeoutMs(params.timeoutMs ?? readConfigInteger(capabilityConfig, "timeoutMs"), DEFAULT_TIMEOUT_MS);
 	const providerModel = normalizeOptionalString(params.model) || "workflow";
 	setWorkflowInput(workflow, promptNodeId, promptInputName, params.prompt);
 	if (seedNodeId) setWorkflowInput(workflow, seedNodeId, seedInputName, randomInt(RANDOM_SEED_EXCLUSIVE_MAX));
@@ -366,17 +239,33 @@ async function runComfyWorkflow(params) {
 		explicitAllowPrivateNetwork,
 		mode
 	});
-	const connection = {
-		baseUrl,
-		headers,
-		timeoutMs,
-		policy: networkPolicy,
-		dispatcherPolicy,
-		mode
-	};
+	const deadline = performance.now() + timeoutMs;
+	const remainingMs = () => resolveComfyRemainingMs(deadline, timeoutMs);
 	if (params.inputImage) {
 		if (!inputImageNodeId) throw new Error("Comfy edit requests require plugins.entries.comfy.config.<capability>.inputImageNodeId to be configured");
-		setWorkflowInput(workflow, inputImageNodeId, inputImageInputName, await uploadInputImage(connection, params.inputImage, params.capability));
+		const form = new FormData();
+		form.set("image", new Blob([bufferToBlobPart(params.inputImage.buffer)], { type: params.inputImage.mimeType }), normalizeOptionalString(params.inputImage.fileName) || `input.${extensionForMime(params.inputImage.mimeType)?.slice(1) || "bin"}`);
+		form.set("type", "input");
+		form.set("overwrite", "true");
+		const uploadHeaders = new Headers(headers);
+		uploadHeaders.delete("Content-Type");
+		const payload = await readJsonResponse({
+			deadline,
+			timeoutMs,
+			policy: networkPolicy,
+			dispatcherPolicy,
+			url: `${baseUrl}${mode === "cloud" ? "/api/upload/image" : "/upload/image"}`,
+			init: {
+				method: "POST",
+				headers: uploadHeaders,
+				body: form
+			},
+			auditContext: `comfy-${params.capability}-upload`,
+			errorPrefix: "Comfy image upload failed"
+		});
+		const uploadedName = normalizeOptionalString(payload.filename) || normalizeOptionalString(payload.name);
+		if (!uploadedName) throw new Error("Comfy image upload response missing filename");
+		setWorkflowInput(workflow, inputImageNodeId, inputImageInputName, uploadedName);
 	}
 	const submitPayload = {
 		prompt: workflow,
@@ -389,6 +278,7 @@ async function runComfyWorkflow(params) {
 			headers,
 			body: JSON.stringify(submitPayload)
 		},
+		deadline,
 		timeoutMs,
 		policy: networkPolicy,
 		dispatcherPolicy,
@@ -397,24 +287,117 @@ async function runComfyWorkflow(params) {
 	});
 	const promptId = normalizeOptionalString(promptResponse.prompt_id);
 	if (!promptId) throw new Error("Comfy workflow submit response missing prompt_id");
-	const historyEntry = extractHistoryEntry(await waitForComfyHistory(connection, promptId, pollIntervalMs), promptId);
+	const waitForHistory = async () => {
+		const read = (path, kind) => readJsonResponse({
+			policy: networkPolicy,
+			dispatcherPolicy,
+			url: `${baseUrl}${path}`,
+			init: {
+				method: "GET",
+				headers
+			},
+			deadline,
+			timeoutMs,
+			auditContext: `comfy-${kind}`,
+			errorPrefix: `Comfy ${kind} lookup failed`
+		});
+		for (;;) {
+			if (mode === "cloud") {
+				const status = await read(`/api/job/${promptId}/status`, "status");
+				if (status.status === "completed") return await read(`/api/history_v2/${promptId}`, "history");
+				if (status.status === "failed" || status.status === "cancelled") {
+					const detail = redactProviderResponseErrorText(status.error ?? status.message ?? promptId, headers);
+					throw new Error(`Comfy workflow ${status.status}: ${detail}`);
+				}
+			} else {
+				const entry = extractHistoryEntry(await read(`/history/${promptId}`, "history"), promptId);
+				if (entry && isTerminalComfyHistory(entry, headers)) return entry;
+			}
+			const pollDelayMs = resolveComfyRemainingMs(deadline, timeoutMs, pollIntervalMs);
+			await sleep(pollDelayMs);
+		}
+	};
+	const historyEntry = extractHistoryEntry(await waitForHistory(), promptId);
 	if (!historyEntry) throw new Error(`Comfy history response missing outputs for prompt ${promptId}`);
-	const outputFiles = collectOutputFiles({
-		history: historyEntry,
-		outputNodeId,
-		outputKinds: params.capability === "music" ? ["audio"] : params.capability === "video" ? [
-			"images",
-			"gifs",
-			"videos"
-		] : ["images"],
-		capability: params.capability
-	});
+	const outputKinds = params.capability === "music" ? ["audio"] : params.capability === "video" ? [
+		"images",
+		"gifs",
+		"videos"
+	] : ["images"];
+	const outputFiles = [];
+	const outputs = historyEntry.outputs;
+	if (outputs) {
+		const nodeIds = outputNodeId ? [outputNodeId] : Object.keys(outputs);
+		for (const nodeId of nodeIds) {
+			const entry = outputs[nodeId];
+			if (!entry) continue;
+			for (const kind of outputKinds) {
+				const bucket = entry[kind];
+				if (!Array.isArray(bucket)) continue;
+				for (const file of bucket) {
+					if (params.capability === "video" && kind === "images") {
+						const fileName = normalizeOptionalString(file.filename) || normalizeOptionalString(file.name);
+						if (!fileName || !/\.(?:mp4|webm)$/i.test(fileName)) continue;
+					}
+					outputFiles.push({
+						nodeId,
+						file
+					});
+				}
+			}
+		}
+	}
 	if (outputFiles.length === 0) throw new Error(`Comfy workflow ${promptId} completed without ${params.capability} outputs`);
+	const downloadOutputFile = async (file, maxBytes) => {
+		const fileName = normalizeOptionalString(file.filename) || normalizeOptionalString(file.name);
+		if (!fileName) throw new Error("Comfy output entry missing filename");
+		const query = new URLSearchParams({
+			filename: fileName,
+			subfolder: normalizeOptionalString(file.subfolder) ?? "",
+			type: normalizeOptionalString(file.type) ?? "output"
+		});
+		const viewPath = mode === "cloud" ? "/api/view" : "/view";
+		const auditContext = `comfy-${params.capability}-download`;
+		const firstResponse = await fetchWithSsrFGuard({
+			timeoutMs: remainingMs(),
+			policy: networkPolicy,
+			dispatcherPolicy,
+			url: `${baseUrl}${viewPath}?${query.toString()}`,
+			init: {
+				method: "GET",
+				headers
+			},
+			auditContext
+		});
+		try {
+			await assertOkOrThrowHttpError(firstResponse.response, "Comfy output download failed", {
+				requestHeaders: headers,
+				bodyTimeoutMs: remainingMs,
+				onBodyTimeout: () => createComfyTimeoutError(timeoutMs)
+			});
+			const mimeType = normalizeOptionalString(firstResponse.response.headers.get("content-type")) || "application/octet-stream";
+			const downloadLabel = `Comfy ${params.capability} output download`;
+			return {
+				buffer: await readProviderBinaryResponse(firstResponse.response, downloadLabel, params.capability, {
+					maxBytes,
+					chunkTimeoutMs: remainingMs(),
+					timeoutMs: remainingMs,
+					onTimeout: () => createComfyTimeoutError(timeoutMs),
+					onOverflow: ({ maxBytes: limit }) => /* @__PURE__ */ new Error(`${downloadLabel} exceeds ${limit} bytes`),
+					onIdleTimeout: ({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`${downloadLabel} stalled after ${chunkTimeoutMs}ms`)
+				}),
+				mimeType,
+				fileName
+			};
+		} finally {
+			await firstResponse.release();
+		}
+	};
 	const assets = [];
 	const outputKind = params.capability === "music" ? "audio" : params.capability;
 	const maxOutputBytes = outputKind === "image" ? resolveGeneratedImageDownloadMaxBytes(params.cfg) : resolveGeneratedMediaMaxBytes(params.cfg, outputKind);
 	for (const output of outputFiles) {
-		const downloaded = await downloadOutputFile(connection, output.file, params.capability, maxOutputBytes);
+		const downloaded = await downloadOutputFile(output.file, maxOutputBytes);
 		assets.push({
 			...downloaded,
 			metadata: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/comfy-provider",
-  "version": "2026.11.3",
+  "version": "2026.11.5-beta.2",
   "description": "OpenClaw ComfyUI provider plugin.",
   "repository": {
     "type": "git",
@@ -18,10 +18,10 @@
       "minHostVersion": ">=2026.7.2"
     },
     "compat": {
-      "pluginApi": ">=2026.11.3"
+      "pluginApi": ">=2026.11.5-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.11.3",
+      "openclawVersion": "2026.11.5-beta.2",
       "bundledDist": false
     },
     "release": {
@@ -40,7 +40,7 @@
     "assets/activity.svg"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.11.3"
+    "openclaw": ">=2026.11.5-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/dist/image-generation-provider.js

@@ -1,51 +0,0 @@
-import { DEFAULT_COMFY_MODEL, isComfyCapabilityConfigured, isComfyCapabilityConfiguredAsync, runComfyWorkflow } from "./workflow-runtime.js";
-//#region extensions/comfy/image-generation-provider.ts
-function buildComfyImageGenerationProvider() {
-	return {
-		id: "comfy",
-		label: "ComfyUI",
-		defaultModel: DEFAULT_COMFY_MODEL,
-		models: [DEFAULT_COMFY_MODEL],
-		isConfigured: ({ cfg, agentDir }) => isComfyCapabilityConfigured({
-			cfg,
-			agentDir,
-			capability: "image"
-		}),
-		isConfiguredAsync: ({ cfg, agentDir }) => isComfyCapabilityConfiguredAsync({
-			cfg,
-			agentDir,
-			capability: "image"
-		}),
-		capabilities: {
-			generate: {
-				maxCount: 1,
-				supportsSize: false,
-				supportsAspectRatio: false,
-				supportsResolution: false
-			},
-			edit: {
-				enabled: true,
-				maxCount: 1,
-				maxInputImages: 1,
-				supportsSize: false,
-				supportsAspectRatio: false,
-				supportsResolution: false
-			}
-		},
-		async generateImage(req) {
-			if ((req.inputImages?.length ?? 0) > 1) throw new Error("Comfy image generation currently supports at most one reference image");
-			const result = await runComfyWorkflow({
-				...req,
-				capability: "image",
-				inputImage: req.inputImages?.[0]
-			});
-			return {
-				images: result.assets,
-				model: result.model,
-				metadata: result.metadata
-			};
-		}
-	};
-}
-//#endregion
-export { buildComfyImageGenerationProvider };

package/dist/music-generation-provider.js

@@ -1,59 +0,0 @@
-import { DEFAULT_COMFY_MODEL, isComfyCapabilityConfigured, isComfyCapabilityConfiguredAsync, runComfyWorkflow } from "./workflow-runtime.js";
-//#region extensions/comfy/music-generation-provider.ts
-const COMFY_MAX_INPUT_IMAGES = 1;
-function resolveInputImage(inputImage) {
-	if (!inputImage) return;
-	if (!inputImage.buffer) throw new Error("Comfy music generation requires loaded reference image bytes.");
-	return {
-		buffer: inputImage.buffer,
-		mimeType: inputImage.mimeType ?? "image/png",
-		fileName: inputImage.fileName
-	};
-}
-function buildComfyMusicGenerationProvider() {
-	return {
-		id: "comfy",
-		label: "ComfyUI",
-		defaultModel: DEFAULT_COMFY_MODEL,
-		models: [DEFAULT_COMFY_MODEL],
-		isConfigured: ({ cfg, agentDir }) => isComfyCapabilityConfigured({
-			cfg,
-			agentDir,
-			capability: "music"
-		}),
-		isConfiguredAsync: ({ cfg, agentDir }) => isComfyCapabilityConfiguredAsync({
-			cfg,
-			agentDir,
-			capability: "music"
-		}),
-		capabilities: {
-			generate: {},
-			edit: {
-				enabled: true,
-				maxInputImages: COMFY_MAX_INPUT_IMAGES
-			}
-		},
-		async generateMusic(req) {
-			if ((req.inputImages?.length ?? 0) > COMFY_MAX_INPUT_IMAGES) throw new Error(`Comfy music generation supports at most ${COMFY_MAX_INPUT_IMAGES} reference image.`);
-			const result = await runComfyWorkflow({
-				...req,
-				capability: "music",
-				inputImage: resolveInputImage(req.inputImages?.[0])
-			});
-			return {
-				tracks: result.assets.map(({ buffer, mimeType, fileName }) => ({
-					buffer,
-					mimeType,
-					fileName
-				})),
-				model: result.model,
-				metadata: {
-					...result.metadata,
-					inputImageCount: req.inputImages?.length ?? 0
-				}
-			};
-		}
-	};
-}
-//#endregion
-export { buildComfyMusicGenerationProvider };

package/dist/video-generation-provider.js

@@ -1,66 +0,0 @@
-import { DEFAULT_COMFY_MODEL, isComfyCapabilityConfigured, isComfyCapabilityConfiguredAsync, runComfyWorkflow } from "./workflow-runtime.js";
-//#region extensions/comfy/video-generation-provider.ts
-function toComfyInputImage(inputImage) {
-	if (!inputImage) return;
-	if (!inputImage.buffer || !inputImage.mimeType) throw new Error("Comfy video generation requires a local reference image file");
-	return {
-		buffer: inputImage.buffer,
-		mimeType: inputImage.mimeType,
-		fileName: inputImage.fileName
-	};
-}
-function buildComfyVideoGenerationProvider() {
-	return {
-		id: "comfy",
-		label: "ComfyUI",
-		defaultModel: DEFAULT_COMFY_MODEL,
-		models: [DEFAULT_COMFY_MODEL],
-		isConfigured: ({ cfg, agentDir }) => isComfyCapabilityConfigured({
-			cfg,
-			agentDir,
-			capability: "video"
-		}),
-		isConfiguredAsync: ({ cfg, agentDir }) => isComfyCapabilityConfiguredAsync({
-			cfg,
-			agentDir,
-			capability: "video"
-		}),
-		capabilities: {
-			generate: {
-				maxVideos: 1,
-				supportsSize: false,
-				supportsAspectRatio: false,
-				supportsResolution: false,
-				supportsAudio: false,
-				supportsWatermark: false
-			},
-			imageToVideo: {
-				enabled: true,
-				maxVideos: 1,
-				maxInputImages: 1,
-				supportsSize: false,
-				supportsAspectRatio: false,
-				supportsResolution: false,
-				supportsAudio: false,
-				supportsWatermark: false
-			},
-			videoToVideo: { enabled: false }
-		},
-		async generateVideo(req) {
-			if ((req.inputImages?.length ?? 0) > 1) throw new Error("Comfy video generation currently supports at most one reference image");
-			if ((req.inputVideos?.length ?? 0) > 0) throw new Error("Comfy video generation does not support input videos");
-			const result = await runComfyWorkflow({
-				...req,
-				capability: "video",
-				inputImage: toComfyInputImage(req.inputImages?.[0])
-			});
-			return {
-				videos: result.assets,
-				model: result.model,
-				metadata: result.metadata
-			};
-		}
-	};
-}
-//#endregion
-export { buildComfyVideoGenerationProvider };

package/dist/workflow-history.js

@@ -1,14 +0,0 @@
-import { redactProviderResponseErrorText } from "openclaw/plugin-sdk/provider-http";
-import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/comfy/workflow-history.ts
-function isTerminalComfyHistory(entry, headers) {
-	if (entry.status?.status_str === "error") {
-		const messages = entry.status.messages;
-		const executionError = Array.isArray(messages) ? messages.findLast((message) => Array.isArray(message) && message[0] === "execution_error") : void 0;
-		const detail = Array.isArray(executionError) && isRecord(executionError[1]) ? normalizeOptionalString(executionError[1].exception_message) : void 0;
-		throw new Error(`Comfy workflow failed${detail ? `: ${redactProviderResponseErrorText(detail, headers)}` : ""}`);
-	}
-	return entry.status?.completed === true || Boolean(entry.outputs && Object.keys(entry.outputs).length);
-}
-//#endregion
-export { isTerminalComfyHistory };