dsh-image-gen 0.2.0 → 0.2.2

package/lib/index.js

@@ -16,13 +16,16 @@ const IMAGE_PROVIDERS = [
 	"google",
 	"openai",
 	"seedream",
-	"dashscope"
+	"dashscope",
+	"comfyui"
 ];
 /** Default endpoints and base URLs. */
 const DEFAULT_GOOGLE_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/interactions";
 const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 const DEFAULT_SEEDREAM_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3";
 const DEFAULT_DASHSCOPE_ENDPOINT = "https://dashscope.aliyuncs.com/api/v1";
+const DEFAULT_COMFYUI_BASE_URL = "http://127.0.0.1:8188";
+const DEFAULT_COMFYUI_TIMEOUT_MS = 3e5;
 /** Default model names. */
 const DEFAULT_GOOGLE_MODEL = "gemini-3.1-flash-image";
 const DEFAULT_OPENAI_MODEL = "gpt-image-2";
@@ -52,6 +55,10 @@ const Config = z.object({
 	seedreamModel: z.string().default(DEFAULT_SEEDREAM_MODEL),
 	dashscopeEndpoint: z.string().default(DEFAULT_DASHSCOPE_ENDPOINT),
 	dashscopeModel: z.string().default(DEFAULT_DASHSCOPE_MODEL),
+	comfyuiBaseURL: z.string().default(DEFAULT_COMFYUI_BASE_URL),
+	comfyuiWorkflowJson: z.string().default(""),
+	comfyuiWorkflowName: z.string().default(""),
+	comfyuiTimeoutMs: z.number().min(1e3).max(36e5).default(DEFAULT_COMFYUI_TIMEOUT_MS),
 	saveToWorkspace: z.boolean().default(true),
 	workspaceFolder: z.string().default(DEFAULT_WORKSPACE_FOLDER)
 });
@@ -79,6 +86,13 @@ function resolveProvider(config) {
 			endpoint: config.dashscopeEndpoint ?? "https://dashscope.aliyuncs.com/api/v1",
 			imageSize: "1024*1024"
 		};
+		case "comfyui": return {
+			provider: "comfyui",
+			baseURL: config.comfyuiBaseURL ?? "http://127.0.0.1:8188",
+			workflowJson: config.comfyuiWorkflowJson ?? "",
+			workflowName: config.comfyuiWorkflowName?.trim() || "API workflow",
+			timeoutMs: config.comfyuiTimeoutMs ?? 3e5
+		};
 		case "google": return {
 			provider: "google",
 			apiKeyEnv: GOOGLE_API_KEY_ENV,
@@ -90,6 +104,256 @@ function resolveProvider(config) {
 	}
 }
 //#endregion
+//#region lib/types/comfyui-workflow.js
+/** Pure ComfyUI API-workflow validation and placeholder injection. */
+const COMFYUI_PROMPT_PLACEHOLDER = "{{prompt}}";
+const COMFYUI_SEED_PLACEHOLDER = "{{seed}}";
+/** Parse, clone, and inject one prompt plus an optional randomized seed. */
+function prepareComfyUIWorkflow(workflowJson, prompt, seed = randomSeed()) {
+	const workflow = parseWorkflow(workflowJson);
+	let promptReplacements = 0;
+	const inject = (value) => {
+		if (typeof value === "string") {
+			if (value === "{{prompt}}") {
+				promptReplacements += 1;
+				return prompt;
+			}
+			if (value === "{{seed}}") return seed;
+			if (value.includes("{{prompt}}")) {
+				promptReplacements += 1;
+				return value.replaceAll(COMFYUI_PROMPT_PLACEHOLDER, prompt);
+			}
+			return value.includes("{{seed}}") ? value.replaceAll(COMFYUI_SEED_PLACEHOLDER, String(seed)) : value;
+		}
+		if (Array.isArray(value)) return value.map(inject);
+		if (!isRecord(value)) return value;
+		return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, inject(child)]));
+	};
+	const prepared = Object.fromEntries(Object.entries(workflow).map(([nodeId, value]) => {
+		const node = record$4(value);
+		const inputs = node === void 0 ? void 0 : record$4(node.inputs);
+		return inputs === void 0 ? [nodeId, value] : [nodeId, {
+			...node,
+			inputs: inject(inputs)
+		}];
+	}));
+	if (promptReplacements === 0) throw new Error(`ComfyUI workflow must contain ${COMFYUI_PROMPT_PLACEHOLDER} in a text input`);
+	return prepared;
+}
+function parseWorkflow(workflowJson) {
+	if (workflowJson.trim().length === 0) throw new Error("Import a ComfyUI API workflow JSON file in Settings before generating");
+	if (new TextEncoder().encode(workflowJson).byteLength > 5242880) throw new Error("ComfyUI workflow file must be no larger than 5 MB");
+	let value;
+	try {
+		value = JSON.parse(workflowJson);
+	} catch {
+		throw new Error("ComfyUI workflow file is not valid JSON");
+	}
+	if (!isRecord(value) || Object.keys(value).length === 0) throw new Error("ComfyUI workflow must be a non-empty API-format JSON object");
+	if (!Object.values(value).some((node) => {
+		const inputs = record$4(node)?.inputs;
+		return inputs !== void 0 && containsPromptPlaceholder(inputs);
+	})) throw new Error(`ComfyUI workflow must contain ${COMFYUI_PROMPT_PLACEHOLDER} in a text input`);
+	return value;
+}
+function containsPromptPlaceholder(value) {
+	if (typeof value === "string") return value.includes(COMFYUI_PROMPT_PLACEHOLDER);
+	if (Array.isArray(value)) return value.some(containsPromptPlaceholder);
+	return isRecord(value) && Object.values(value).some(containsPromptPlaceholder);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record$4(value) {
+	return isRecord(value) ? value : void 0;
+}
+function randomSeed() {
+	return Math.floor(Math.random() * 4294967296);
+}
+//#endregion
+//#region lib/types/comfyui.js
+const ERROR_LIMIT$3 = 4096;
+const POLL_INTERVAL_MS = 500;
+const MAX_HISTORY_BYTES = 16777216;
+/** Run one ComfyUI workflow and return its first final image. */
+async function generateComfyUIImage(input) {
+	input.signal.throwIfAborted();
+	const baseURL = comfyUIBaseURL(input.baseURL);
+	const workflow = prepareComfyUIWorkflow(input.workflowJson, input.prompt);
+	const controller = new AbortController();
+	const forwardAbort = () => {
+		controller.abort(input.signal.reason);
+	};
+	input.signal.addEventListener("abort", forwardAbort, { once: true });
+	const timeout = setTimeout(() => {
+		controller.abort(/* @__PURE__ */ new Error("ComfyUI generation timed out"));
+	}, input.timeoutMs);
+	try {
+		return await downloadOutput(baseURL, await waitForOutput(baseURL, await submitWorkflow(baseURL, workflow, controller.signal), controller.signal), input.maxBytes, controller.signal);
+	} catch (error) {
+		input.signal.throwIfAborted();
+		if (controller.signal.aborted) throw new Error(`ComfyUI generation timed out after ${String(input.timeoutMs)} ms`);
+		if (error instanceof TypeError) throw new Error(`Could not connect to ComfyUI at ${baseURL.origin}`);
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+		input.signal.removeEventListener("abort", forwardAbort);
+	}
+}
+async function submitWorkflow(baseURL, workflow, signal) {
+	const response = await fetch(endpoint(baseURL, "prompt"), {
+		method: "POST",
+		redirect: "error",
+		signal,
+		headers: {
+			"content-type": "application/json",
+			accept: "application/json"
+		},
+		body: JSON.stringify({ prompt: workflow })
+	});
+	const text = await readBoundedText$3(response, ERROR_LIMIT$3);
+	if (!response.ok) throw new Error(`ComfyUI rejected the workflow (${response.status}): ${text}`);
+	const payload = parseJsonRecord(text, "ComfyUI /prompt returned invalid JSON");
+	if (typeof payload.prompt_id !== "string" || payload.prompt_id.length === 0) throw new Error(`ComfyUI /prompt returned no prompt_id: ${text}`);
+	return payload.prompt_id;
+}
+async function waitForOutput(baseURL, promptId, signal) {
+	for (;;) {
+		signal.throwIfAborted();
+		const response = await fetch(endpoint(baseURL, `history/${encodeURIComponent(promptId)}`), {
+			redirect: "error",
+			signal,
+			headers: { accept: "application/json" }
+		});
+		const text = await readBoundedText$3(response, MAX_HISTORY_BYTES);
+		if (!response.ok) throw new Error(`ComfyUI history request failed (${response.status}): ${text.slice(0, ERROR_LIMIT$3)}`);
+		const entry = record$3(parseJsonRecord(text, "ComfyUI history returned invalid JSON")[promptId]);
+		if (entry !== void 0) {
+			const status = record$3(entry.status);
+			if (status?.status_str === "error") throw new Error(`ComfyUI workflow failed: ${JSON.stringify(status.messages ?? status).slice(0, ERROR_LIMIT$3)}`);
+			const output = firstOutputImage(entry.outputs);
+			if (output !== void 0) return output;
+			if (status?.completed === true) throw new Error("ComfyUI workflow completed without an output image");
+		}
+		await delay(POLL_INTERVAL_MS, signal);
+	}
+}
+function firstOutputImage(value) {
+	const outputs = record$3(value);
+	if (outputs === void 0) return void 0;
+	for (const nodeOutput of Object.values(outputs)) {
+		const images = record$3(nodeOutput)?.images;
+		if (!Array.isArray(images)) continue;
+		for (const image of images) {
+			const item = record$3(image);
+			if (typeof item?.filename !== "string" || item.filename.length === 0) continue;
+			const output = {
+				filename: item.filename,
+				subfolder: typeof item.subfolder === "string" ? item.subfolder : "",
+				type: typeof item.type === "string" ? item.type : "output"
+			};
+			if (output.type === "output") return output;
+		}
+	}
+}
+async function downloadOutput(baseURL, output, maxBytes, signal) {
+	const url = endpoint(baseURL, "view");
+	url.searchParams.set("filename", output.filename);
+	url.searchParams.set("subfolder", output.subfolder);
+	url.searchParams.set("type", output.type);
+	const response = await fetch(url, {
+		redirect: "error",
+		signal
+	});
+	if (!response.ok) throw new Error(`ComfyUI image download failed (${response.status})`);
+	const mediaType = imageMediaType$3(response.headers.get("content-type")) ?? imageMediaTypeFromName(output.filename);
+	if (mediaType === void 0) throw new Error("ComfyUI image download returned an unsupported content type");
+	return {
+		data: await readBoundedBytes$2(response, maxBytes),
+		mediaType
+	};
+}
+function comfyUIBaseURL(value) {
+	let url;
+	try {
+		url = new URL(value.endsWith("/") ? value : `${value}/`);
+	} catch {
+		throw new Error("ComfyUI URL must be an absolute http:// or https:// URL");
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("ComfyUI URL must use http:// or https://");
+	return url;
+}
+function endpoint(baseURL, path) {
+	return new URL(path, baseURL);
+}
+function record$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function parseJsonRecord(text, message) {
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch {
+		throw new Error(message);
+	}
+	const parsed = record$3(value);
+	if (parsed === void 0) throw new Error(message);
+	return parsed;
+}
+function imageMediaType$3(value) {
+	const mediaType = value?.split(";", 1)[0]?.trim().toLowerCase();
+	return mediaType === "image/png" || mediaType === "image/jpeg" || mediaType === "image/webp" || mediaType === "image/gif" ? mediaType : void 0;
+}
+function imageMediaTypeFromName(filename) {
+	const lower = filename.toLowerCase();
+	if (lower.endsWith(".png")) return "image/png";
+	if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+	if (lower.endsWith(".webp")) return "image/webp";
+	if (lower.endsWith(".gif")) return "image/gif";
+}
+async function delay(milliseconds, signal) {
+	await new Promise((resolve, reject) => {
+		const timer = setTimeout(done, milliseconds);
+		const abort = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", abort);
+			reject(signal.reason);
+		};
+		function done() {
+			signal.removeEventListener("abort", abort);
+			resolve();
+		}
+		signal.addEventListener("abort", abort, { once: true });
+	});
+}
+async function readBoundedText$3(response, maxBytes) {
+	return new TextDecoder().decode(await readBoundedBytes$2(response, maxBytes));
+}
+async function readBoundedBytes$2(response, maxBytes) {
+	if (response.body === null) return /* @__PURE__ */ new Uint8Array();
+	const reader = response.body.getReader();
+	const chunks = [];
+	let bytes = 0;
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			bytes += next.value.byteLength;
+			if (bytes > maxBytes) throw new Error(`ComfyUI response exceeded the ${String(maxBytes)} byte limit`);
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const joined = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		joined.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return joined;
+}
+//#endregion
 //#region lib/types/dashscope.js
 async function generateDashScopeImage(options) {
 	assertQwenImageModel(options.model);
@@ -116,7 +380,7 @@ async function editDashScopeImage(options) {
 			model: options.model,
 			input: { messages: [{
 				role: "user",
-				content: [{ image: toDataUrl$1(options.sourceImage) }, { text: options.prompt }]
+				content: [...options.sourceImages.map((sourceImage) => ({ image: toDataUrl$1(sourceImage) })), { text: options.prompt }]
 			}] },
 			parameters: {
 				prompt_extend: true,
@@ -197,11 +461,11 @@ function editGoogleImage(input) {
 		interactionInput: [{
 			type: "text",
 			text: input.prompt
-		}, {
+		}, ...input.sourceImages.map((sourceImage) => ({
 			type: "image",
-			mime_type: input.sourceImage.mediaType,
-			data: Buffer.from(input.sourceImage.data).toString("base64")
-		}]
+			mime_type: sourceImage.mediaType,
+			data: Buffer.from(sourceImage.data).toString("base64")
+		}))]
 	});
 }
 /** Shared Google request, response parsing, decoding, and size enforcement. */
@@ -309,30 +573,67 @@ async function readBoundedText$2(response, maxBytes, label) {
 //#region lib/types/reference-image.js
 /** Latest-DSH compatibility boundary for resolving conversation image references. */
 /**
-* Resolve and read the image to edit from the current effective conversation.
-*
-* This is the only module allowed to know how DSH sessions expose effective
-* messages or how nested model-facing content stores durable image refs.
+* Resolve one or more edit references while keeping every DSH-specific detail
+* behind this compatibility boundary. Explicit selectors preserve caller order;
+* without selectors, all images in the newest image-bearing message are used.
 */
-async function resolveReferenceImage(input) {
-	if (input.sourceAttachmentId !== void 0 && input.sourcePath !== void 0) throw new Error("edit_image accepts either source_attachment_id or source_path, not both");
-	if (input.sourcePath !== void 0) return readWorkspaceReferenceImage({
-		sourcePath: input.sourcePath,
+async function resolveReferenceImages(input) {
+	const sourceAttachmentIds = mergeSelectors({
+		single: input.sourceAttachmentId,
+		multiple: input.sourceAttachmentIds,
+		singleName: "source_attachment_id",
+		multipleName: "source_attachment_ids",
+		equal: attachmentIdsEqual
+	});
+	const sourcePaths = mergeSelectors({
+		single: input.sourcePath,
+		multiple: input.sourcePaths,
+		singleName: "source_path",
+		multipleName: "source_paths",
+		equal: (left, right) => left.trim() === right.trim()
+	});
+	if (sourceAttachmentIds !== void 0 && sourcePaths !== void 0) throw new Error("edit_image accepts only one of source_attachment_id, source_attachment_ids, source_path, or source_paths");
+	if (sourcePaths !== void 0) return Promise.all(sourcePaths.map((sourcePath) => readWorkspaceReferenceImage({
+		sourcePath,
 		...input.agent?.session.header?.cwd === void 0 ? {} : { workspaceRoot: input.agent.session.header.cwd },
 		...input.maxBytes === void 0 ? {} : { maxBytes: input.maxBytes },
 		signal: input.signal
-	});
+	})));
 	if (input.agent === void 0) throw new Error("edit_image requires an active DSH agent session to resolve a reference image");
-	const ref = findReferenceImage(input.agent.session.deriveMessages(), input.sourceAttachmentId);
-	if (ref === void 0) {
-		if (input.sourceAttachmentId !== void 0) throw new Error(`edit_image could not find image attachment ${input.sourceAttachmentId} in the current conversation`);
+	const refs = findReferenceImages(input.agent.session.deriveMessages(), sourceAttachmentIds);
+	if (refs.length === 0) {
+		if (sourceAttachmentIds !== void 0) throw new Error(`edit_image could not find image attachment ${sourceAttachmentIds[0]} in the current conversation`);
 		throw new Error("edit_image requires an image in the current conversation; upload or generate an image first");
 	}
-	const stored = await input.attachments.readImage(ref, input.signal);
-	return {
-		data: stored.data,
-		mediaType: stored.ref.mediaType
-	};
+	if (sourceAttachmentIds !== void 0 && refs.length !== sourceAttachmentIds.length) {
+		const missing = sourceAttachmentIds.find((id) => !refs.some((ref) => attachmentIdsEqual(String(ref.attachmentId), id)));
+		throw new Error(`edit_image could not find image attachment ${missing ?? "unknown"} in the current conversation`);
+	}
+	return Promise.all(refs.map(async (ref) => {
+		const stored = await input.attachments.readImage(ref, input.signal);
+		if (input.maxBytes !== void 0 && stored.data.byteLength > input.maxBytes) throw new Error(`edit_image source image is too large (${stored.data.byteLength} bytes; maximum ${input.maxBytes})`);
+		return {
+			data: stored.data,
+			mediaType: stored.ref.mediaType
+		};
+	}));
+}
+/** Find images in caller order, or every image in the newest image-bearing message. */
+function findReferenceImages(messages, sourceAttachmentIds) {
+	if (sourceAttachmentIds !== void 0) return sourceAttachmentIds.flatMap((id) => {
+		const ref = findReferenceImage(messages, id);
+		return ref === void 0 ? [] : [ref];
+	});
+	const latestHumanMessage = [...messages].reverse().find((message) => message.source?.kind === "user");
+	if (latestHumanMessage !== void 0) {
+		const refs = collectInBlocks(latestHumanMessage.content);
+		if (refs.length > 0) return refs;
+	}
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const refs = collectInBlocks(messages[index]?.content ?? []);
+		if (refs.length > 0) return refs;
+	}
+	return [];
 }
 /**
 * Read an explicitly named workspace image without exposing filesystem or DSH
@@ -397,7 +698,7 @@ function findInBlocks(blocks, sourceAttachmentId) {
 		const block = blocks[index];
 		if (block === void 0) continue;
 		if (block.type === "image") {
-			if (sourceAttachmentId === void 0 || String(block.attachment.attachmentId) === sourceAttachmentId) return block.attachment;
+			if (sourceAttachmentId === void 0 || attachmentIdsEqual(String(block.attachment.attachmentId), sourceAttachmentId)) return block.attachment;
 			continue;
 		}
 		if (block.type === "tool-result") {
@@ -417,6 +718,33 @@ function parseDimensions(value) {
 function imageMediaType$2(value) {
 	return value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif";
 }
+function collectInBlocks(blocks) {
+	const refs = [];
+	for (const block of blocks) {
+		if (block.type === "image") refs.push(block.attachment);
+		if (block.type === "tool-result") refs.push(...collectInBlocks(block.content));
+	}
+	return refs;
+}
+function attachmentIdsEqual(actual, requested) {
+	if (actual === requested) return true;
+	const actualDigest = sha256Digest(actual);
+	const requestedDigest = sha256Digest(requested);
+	return actualDigest !== void 0 && actualDigest === requestedDigest;
+}
+function sha256Digest(value) {
+	return /^(?:sha256:)?([0-9a-f]{64})$/i.exec(value.trim())?.[1]?.toLowerCase();
+}
+function mergeSelectors(input) {
+	if (input.multiple === void 0) return input.single === void 0 ? void 0 : [input.single];
+	if (input.multiple.length === 0) {
+		if (input.single !== void 0) return [input.single];
+		throw new Error(`edit_image ${input.multipleName} must not be empty`);
+	}
+	const single = input.single;
+	if (single !== void 0 && !input.multiple.some((value) => input.equal(single, value))) throw new Error(`edit_image ${input.singleName} must also appear in ${input.multipleName} when both are provided`);
+	return input.multiple;
+}
 function detectImageMediaType(data) {
 	if (startsWith(data, [
 		137,
@@ -538,8 +866,11 @@ async function generateOpenAICompatibleImage(input) {
 }
 async function editOpenAICompatibleImage(input) {
 	const form = new FormData();
-	const uploadBytes = new Uint8Array(input.sourceImage.data);
-	form.append("image", new Blob([uploadBytes], { type: input.sourceImage.mediaType }), `reference.${extensionOf(input.sourceImage.mediaType)}`);
+	const imageField = input.sourceImages.length === 1 ? "image" : "image[]";
+	input.sourceImages.forEach((sourceImage, index) => {
+		const uploadBytes = new Uint8Array(sourceImage.data);
+		form.append(imageField, new Blob([uploadBytes], { type: sourceImage.mediaType }), `reference-${index + 1}.${extensionOf(sourceImage.mediaType)}`);
+	});
 	form.append("prompt", input.prompt);
 	form.append("model", input.model);
 	if (input.size !== void 0 && input.size.length > 0) form.append("size", input.size);
@@ -684,7 +1015,7 @@ async function editSeedreamImage(input) {
 		body: JSON.stringify({
 			model: input.model,
 			prompt: input.prompt,
-			image: [toDataUrl(input.sourceImage)],
+			image: input.sourceImages.map(toDataUrl),
 			...input.size === void 0 || input.size.length === 0 ? {} : { size: input.size },
 			response_format: "b64_json"
 		})
@@ -961,6 +1292,14 @@ function apply(ctx, config = {}) {
 		output: imageOutput("Generated"),
 		async execute(args, exec) {
 			const active = resolveProvider(current());
+			if (active.provider === "comfyui") return saveGenerated(ctx, await generateComfyUIImage({
+				baseURL: active.baseURL,
+				workflowJson: active.workflowJson,
+				prompt: args.prompt,
+				timeoutMs: active.timeoutMs,
+				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
+				signal: exec.signal
+			}), active.provider, active.workflowName, "API workflow", current(), exec);
 			const credential = await ctx.credentials.resolve(credentialRef(active.apiKeyEnv));
 			if (credential === void 0 || credential.value.length === 0) throw new Error(`generate_image requires the ${active.apiKeyEnv} credential; configure it in Settings > Plugins > Image generation.`);
 			if (active.provider === "google") {
@@ -1005,7 +1344,7 @@ function apply(ctx, config = {}) {
 	}));
 	ctx.tools.register(defineTool({
 		name: "edit_image",
-		description: "Edit or restyle an existing image with the configured provider. For a named workspace file, pass its exact path as source_path. For a specific image still attached to the current conversation, pass source_attachment_id. Never provide both. Omit both only when the user clearly means the newest conversation image. If the user identifies an older image but its exact path or attachment id is unknown, do not silently edit the newest image: first use an image-reading tool to put the intended file into the conversation, then call edit_image without a source.",
+		description: "Edit, combine, or restyle existing images with the configured provider. Images attached inline to the latest human message are already readable DSH attachments even when no workspace file exists. In that case, call edit_image immediately with prompt only; NEVER call read_image, glob, or shell to locate them, and NEVER invent @ paths. All inline images will be used in upload order. For specific older conversation images use source_attachment_id or source_attachment_ids; both canonical sha256: IDs and full bare SHA-256 digests are accepted. For files the user explicitly names in the workspace use source_path or source_paths. Provide exactly one selector field. Without a selector, images from the latest human message take priority; only when that message has no images does editing fall back to the newest conversation image.",
 		parameters: {
 			prompt: {
 				type: "string",
@@ -1016,10 +1355,20 @@ function apply(ctx, config = {}) {
 				type: "string",
 				description: "Optional attachment id of a specific image already present in the current conversation."
 			},
+			source_attachment_ids: {
+				type: "array",
+				items: { type: "string" },
+				description: "Optional ordered attachment ids of multiple images already present in the current conversation. Prompt references such as image 1 and image 2 follow this order."
+			},
 			source_path: {
 				type: "string",
 				description: "Optional absolute or workspace-relative path of a specific image file inside the active session workspace. Prefer this when the user names a saved file."
 			},
+			source_paths: {
+				type: "array",
+				items: { type: "string" },
+				description: "Optional ordered absolute or workspace-relative paths of multiple image files inside the active session workspace."
+			},
 			aspect_ratio: {
 				type: "string",
 				enum: [
@@ -1050,13 +1399,16 @@ function apply(ctx, config = {}) {
 		output: imageOutput("Edited"),
 		async execute(args, exec) {
 			const active = resolveProvider(current());
+			if (active.provider === "comfyui") throw new Error("edit_image is not yet supported by the ComfyUI provider; switch providers or use generate_image");
 			const credential = await ctx.credentials.resolve(credentialRef(active.apiKeyEnv));
 			if (credential === void 0 || credential.value.length === 0) throw new Error(`edit_image requires the ${active.apiKeyEnv} credential; configure it in Settings > Plugins > Image generation.`);
-			const sourceImage = await resolveReferenceImage({
+			const sourceImages = await resolveReferenceImages({
 				...exec.agent === void 0 ? {} : { agent: exec.agent },
 				attachments: ctx.attachments,
 				...typeof args.source_attachment_id === "string" ? { sourceAttachmentId: args.source_attachment_id } : {},
+				...Array.isArray(args.source_attachment_ids) ? { sourceAttachmentIds: args.source_attachment_ids } : {},
 				...typeof args.source_path === "string" ? { sourcePath: args.source_path } : {},
+				...Array.isArray(args.source_paths) ? { sourcePaths: args.source_paths } : {},
 				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
 				signal: exec.signal
 			});
@@ -1068,7 +1420,7 @@ function apply(ctx, config = {}) {
 					endpoint: active.endpoint,
 					model: active.model,
 					prompt: args.prompt,
-					sourceImage,
+					sourceImages,
 					aspectRatio,
 					imageSize,
 					maxBytes: ctx.attachments.imageLimits.maxImageBytes,
@@ -1081,7 +1433,7 @@ function apply(ctx, config = {}) {
 				baseURL: active.baseURL,
 				model: active.model,
 				prompt: args.prompt,
-				sourceImage,
+				sourceImages,
 				size,
 				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
 				signal: exec.signal
@@ -1091,7 +1443,7 @@ function apply(ctx, config = {}) {
 				baseURL: active.baseURL,
 				model: active.model,
 				prompt: args.prompt,
-				sourceImage,
+				sourceImages,
 				size,
 				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
 				signal: exec.signal
@@ -1101,7 +1453,7 @@ function apply(ctx, config = {}) {
 				endpoint: active.endpoint,
 				model: active.model,
 				prompt: args.prompt,
-				sourceImage,
+				sourceImages,
 				size,
 				maxBytes: ctx.attachments.imageLimits.maxImageBytes,
 				signal: exec.signal

package/lib/types/client/index.d.ts

@@ -1,5 +1,4 @@
 import type { Context } from '@deepseek-ai/cordis';
-import type { ConnectionHandle } from '@deepseek-ai/dsh-client-connection/client';
 import type { SettingsScope } from '@deepseek-ai/dsh-client-runtime/client';
 import type { InjectFace, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 import { type ImageProvider } from '../shared.js';
@@ -15,12 +14,33 @@ interface ImageSettings {
     seedreamModel?: string;
     dashscopeEndpoint?: string;
     dashscopeModel?: string;
+    comfyuiBaseURL?: string;
+    comfyuiWorkflowJson?: string;
+    comfyuiWorkflowName?: string;
+    comfyuiTimeoutMs?: number;
     saveToWorkspace?: boolean;
     workspaceFolder?: string;
 }
+interface CredentialInfo {
+    configured?: boolean;
+}
+interface CredentialResult {
+    ok: boolean;
+    value?: Readonly<Record<string, CredentialInfo>>;
+}
+interface CredentialMutationResult {
+    ok: boolean;
+    error?: {
+        message?: string;
+    };
+}
+interface CredentialsRemote {
+    describe(refs: string[]): Promise<CredentialResult>;
+    set(ref: string, value: string): Promise<CredentialMutationResult>;
+}
 interface SettingsFace {
     scope: SettingsScope<ImageSettings>;
-    credentials: ConnectionHandle['api']['credentials'];
+    credentials: CredentialsRemote;
     locale?: LocaleService | undefined;
 }
 interface ImageCardFace {

package/lib/types/comfyui-workflow.d.ts

@@ -0,0 +1,8 @@
+export declare const COMFYUI_PROMPT_PLACEHOLDER = "{{prompt}}";
+export declare const COMFYUI_SEED_PLACEHOLDER = "{{seed}}";
+type JsonRecord = Record<string, unknown>;
+/** Validate imported JSON without exposing workflow graph details to callers. */
+export declare function validateComfyUIWorkflowJson(workflowJson: string): void;
+/** Parse, clone, and inject one prompt plus an optional randomized seed. */
+export declare function prepareComfyUIWorkflow(workflowJson: string, prompt: string, seed?: number): JsonRecord;
+export {};

package/lib/types/comfyui.d.ts

@@ -0,0 +1,15 @@
+/** ComfyUI text-to-image adapter using an imported API-format workflow. */
+import type { ImageMediaType } from '@deepseek-ai/dsh-attachment';
+export interface GeneratedComfyUIImage {
+    data: Uint8Array;
+    mediaType: ImageMediaType;
+}
+/** Run one ComfyUI workflow and return its first final image. */
+export declare function generateComfyUIImage(input: {
+    baseURL: string;
+    workflowJson: string;
+    prompt: string;
+    timeoutMs: number;
+    maxBytes: number;
+    signal: AbortSignal;
+}): Promise<GeneratedComfyUIImage>;

package/lib/types/config.d.ts

@@ -1,7 +1,7 @@
 /** User-facing configuration for supported image providers. */
 import z from '@deepseek-ai/schemastery';
-import { DEFAULT_DASHSCOPE_ENDPOINT, DEFAULT_DASHSCOPE_MODEL, DEFAULT_GOOGLE_ENDPOINT, DEFAULT_GOOGLE_MODEL, DEFAULT_OPENAI_BASE_URL, DEFAULT_OPENAI_MODEL, DEFAULT_SEEDREAM_BASE_URL, DEFAULT_SEEDREAM_MODEL, IMAGE_PROVIDERS, type ImageProvider } from './shared.js';
-export { DEFAULT_DASHSCOPE_ENDPOINT, DEFAULT_DASHSCOPE_MODEL, DEFAULT_GOOGLE_ENDPOINT, DEFAULT_GOOGLE_MODEL, DEFAULT_OPENAI_BASE_URL, DEFAULT_OPENAI_MODEL, DEFAULT_SEEDREAM_BASE_URL, DEFAULT_SEEDREAM_MODEL, IMAGE_PROVIDERS, type ImageProvider, };
+import { DEFAULT_DASHSCOPE_ENDPOINT, DEFAULT_DASHSCOPE_MODEL, DEFAULT_COMFYUI_BASE_URL, DEFAULT_COMFYUI_TIMEOUT_MS, DEFAULT_COMFYUI_WORKFLOW_LABEL, DEFAULT_GOOGLE_ENDPOINT, DEFAULT_GOOGLE_MODEL, DEFAULT_OPENAI_BASE_URL, DEFAULT_OPENAI_MODEL, DEFAULT_SEEDREAM_BASE_URL, DEFAULT_SEEDREAM_MODEL, IMAGE_PROVIDERS, type ImageProvider } from './shared.js';
+export { DEFAULT_DASHSCOPE_ENDPOINT, DEFAULT_DASHSCOPE_MODEL, DEFAULT_COMFYUI_BASE_URL, DEFAULT_COMFYUI_TIMEOUT_MS, DEFAULT_COMFYUI_WORKFLOW_LABEL, DEFAULT_GOOGLE_ENDPOINT, DEFAULT_GOOGLE_MODEL, DEFAULT_OPENAI_BASE_URL, DEFAULT_OPENAI_MODEL, DEFAULT_SEEDREAM_BASE_URL, DEFAULT_SEEDREAM_MODEL, IMAGE_PROVIDERS, type ImageProvider, };
 /** Default workspace subfolder that receives generated image files. */
 export declare const DEFAULT_WORKSPACE_FOLDER = "dsh-image-gen";
 /** Google API credential reference. */
@@ -28,6 +28,12 @@ export interface Config {
     seedreamModel?: string;
     dashscopeEndpoint?: string;
     dashscopeModel?: string;
+    comfyuiBaseURL?: string;
+    /** ComfyUI API-format workflow JSON imported through the Web settings page. */
+    comfyuiWorkflowJson?: string;
+    /** Original imported file name, used as a human-readable result label. */
+    comfyuiWorkflowName?: string;
+    comfyuiTimeoutMs?: number;
     /** Also write every generated image as a file under the session workspace. */
     saveToWorkspace?: boolean;
     /** Workspace subfolder for generated images; empty means the workspace root. */
@@ -61,4 +67,10 @@ export declare function resolveProvider(config: Config): {
     model: string;
     endpoint: string;
     imageSize: string;
+} | {
+    provider: 'comfyui';
+    baseURL: string;
+    workflowJson: string;
+    workflowName: string;
+    timeoutMs: number;
 };