dsh-image-gen 0.2.1 → 0.2.3

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);
@@ -1028,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") {
@@ -1127,6 +1399,7 @@ 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 sourceImages = await resolveReferenceImages({

package/lib/types/client/image-ref.d.ts

@@ -0,0 +1,8 @@
+/** Dual-path image attachment resolution for legacy rc.2 and modern DSH runtime blocks. */
+import type { ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import type { ToolCallBlock } from '@deepseek-ai/dsh-client-runtime/client';
+/**
+ * Extract the verified durable image attachment from a completed tool result block.
+ * Supports legacy rc.2 `resultView.content` and modern DSH `block.content`.
+ */
+export declare function imageRef(block: ToolCallBlock): ImageAttachmentRef | undefined;

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;
 };

package/lib/types/shared.d.ts

@@ -4,13 +4,17 @@ export declare const IMAGE_ROUTE = "/plugins/dsh-image-gen/image";
 /** Namespace persisted through DSH Settings. */
 export declare const IMAGE_GENERATION_NAMESPACE = "image-generation";
 /** Supported providers. */
-export declare const IMAGE_PROVIDERS: readonly ["google", "openai", "seedream", "dashscope"];
+export declare const IMAGE_PROVIDERS: readonly ["google", "openai", "seedream", "dashscope", "comfyui"];
 export type ImageProvider = typeof IMAGE_PROVIDERS[number];
 /** Default endpoints and base URLs. */
 export declare const DEFAULT_GOOGLE_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/interactions";
 export declare const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 export declare const DEFAULT_SEEDREAM_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3";
 export declare const DEFAULT_DASHSCOPE_ENDPOINT = "https://dashscope.aliyuncs.com/api/v1";
+export declare const DEFAULT_COMFYUI_BASE_URL = "http://127.0.0.1:8188";
+export declare const DEFAULT_COMFYUI_TIMEOUT_MS = 300000;
+export declare const DEFAULT_COMFYUI_WORKFLOW_LABEL = "API workflow";
+export declare const MAX_COMFYUI_WORKFLOW_BYTES: number;
 /** Default model names. */
 export declare const DEFAULT_GOOGLE_MODEL = "gemini-3.1-flash-image";
 export declare const DEFAULT_OPENAI_MODEL = "gpt-image-2";