feat(workflow): 工作流提供方 - 集成 RunningHub 与 ComfyUI Bridge

2026-08-26 15:02:24 +08:00
parent 6141bd688c
commit 86fc3fda2f
82 changed files with 11405 additions and 248 deletions
--- a/web/src/stores/use-config-store.ts
+++ b/web/src/stores/use-config-store.ts
@@ -7,7 +7,7 @@ import { projectDesktopLocalChannelRuntime } from "@/lib/desktop-local-channel";
 import { scopedLocalStorage } from "@/lib/user-scope";
 import { modelProtocolCapability, normalizeModelProtocol, type ModelProtocol } from "@/lib/model-protocols";
 import { normalizeVideoDuration, normalizeVideoResolution } from "@/lib/video-generation-options";
-import type { ModelCapabilityConfig } from "@/lib/model-capabilities";
+import { workflowFieldRole, workflowFieldSafeToOverride, workflowVideoFieldsFromJson, type ModelCapabilityConfig } from "@/lib/model-capabilities";
 import { useLocalDreaminaModelStore } from "@/stores/use-local-dreamina-model-store";
 import { useUserStore } from "@/stores/use-user-store";
 import type { DreaminaLocalModel } from "@/services/local-dreamina-model-catalog";
@@ -16,8 +16,324 @@ import type { CapabilitySpec, PublicLogicalModelPriceTier } from "@/services/api
 export type ApiCallFormat = "openai" | "gemini" | "claude";
 export type ChannelInterfaceType = ModelProtocol;
 export type ChannelHeader = { name: string; value: string };
+export type RunningHubCapability = "image" | "video" | "audio";
+export type RunningHubWorkflowKind = "workflow" | "app";

-// 这是只读目录适配器的内部键，不是供应渠道或数据库实体 ID。
+export type WorkflowFieldMapping = {
+    id?: string;
+    nodeId: string;
+    classType?: string;
+    fieldName: string;
+    fieldValue?: unknown;
+    value?: unknown;
+    default?: unknown;
+    defaultValue?: unknown;
+    fieldType?: string;
+    label?: string;
+    role?: string;
+    safeToOverride?: boolean;
+    optionsSource?: "workflow" | "manual" | "preset";
+    options?: unknown[];
+    min?: unknown;
+    max?: unknown;
+    step?: unknown;
+    enabled?: boolean;
+    source?: string;
+    sourceIndex?: number;
+    imageOrder?: number;
+    required?: boolean;
+    randomEnabled?: boolean;
+    bindPrompt?: boolean;
+    sourceFromUpstream?: boolean;
+    sourceAutomatic?: boolean;
+};
+
+export function normalizeRunningHubCapability(value: unknown, fallback: RunningHubCapability = "image"): RunningHubCapability {
+    return value === "image" || value === "video" || value === "audio" ? value : fallback;
+}
+
+export function normalizeRunningHubWorkflowKind(value: unknown): RunningHubWorkflowKind {
+    return value === "app" ? "app" : "workflow";
+}
+
+function normalizeWorkflowFieldSourceName(value: unknown, capability?: RunningHubCapability) {
+    const source = String(value || "").trim();
+    const normalized = source.toLowerCase().replace(/[\s_-]/g, "");
+    const aliases: Record<string, string> = {
+        text: "prompt", positive: "prompt", positiveprompt: "prompt",
+        image: "referenceImage", referenceimage: "referenceImage", referenceimages: "referenceImage",
+        video: "referenceVideo", referencevideo: "referenceVideo", referencevideos: "referenceVideo",
+        audio: "referenceAudio", referenceaudio: "referenceAudio", referenceaudios: "referenceAudio",
+        sizewidth: "width", imagewidth: "width", videowidth: "width", sizeheight: "height", imageheight: "height", videoheight: "height",
+        ratio: "aspectRatio", aspectratio: "aspectRatio", imageaspectratio: "aspectRatio", imageratio: "aspectRatio", videoaspectratio: "aspectRatio", videoratio: "aspectRatio",
+        videoresolution: "vquality", batch: "count", batchsize: "count", duration: "videoSeconds", videoseconds: "videoSeconds", videoquality: "vquality",
+        generateaudio: "videoGenerateAudio", videogenerateaudio: "videoGenerateAudio", watermark: "videoWatermark", videowatermark: "videoWatermark", voice: "audioVoice",
+        systemprompt: "systemPrompt", transparentbackground: "transparentBackground", audiovoice: "audioVoice",
+        audioformat: "audioFormat", audiospeed: "audioSpeed", audioinstructions: "audioInstructions",
+    };
+    if (normalized === "resolution") return capability === "video" ? "vquality" : "size";
+    // 工作流的 quality 可能是连续数值（例如 0.1-3），不能按视频分辨率处理。
+    if (normalized === "quality") return "quality";
+    return aliases[normalized] || source;
+}
+
+const workflowDimensionPrefixes = ["", "image", "video", "size", "output", "target", "latent", "frame", "canvas", "source", "resolution", "final"];
+
+function workflowDimensionSource(key: string) {
+    if (workflowDimensionPrefixes.some((prefix) => key === `${prefix}width`) || key === "pixelwidth" || key === "widthpixels") return "width";
+    if (workflowDimensionPrefixes.some((prefix) => key === `${prefix}height`) || key === "pixelheight" || key === "heightpixels") return "height";
+    return "";
+}
+
+function inferWorkflowFieldSource(fieldName: string, fieldType: string, capability?: RunningHubCapability) {
+    const key = fieldName.toLowerCase().replace(/[\s_-]/g, "");
+    const normalizedFieldType = fieldType.trim().toLowerCase();
+    if (["text", "prompt", "positive", "positiveprompt"].includes(key)) return "prompt";
+    if (key.includes("mask")) return "mask";
+    const dimensionSource = workflowDimensionSource(key);
+    if (dimensionSource) return dimensionSource;
+    if (["ratio", "aspectratio", "imageaspectratio", "imageratio", "videoaspectratio", "videoratio"].includes(key)) return "aspectRatio";
+    if (["videoresolution", "videoquality", "vquality"].includes(key)) return "vquality";
+    if (["size", "imagesize", "imageresolution"].includes(key)) return "size";
+    if (key === "resolution") return capability === "video" ? "vquality" : capability === "image" ? "size" : "";
+    if (["batch", "batchsize", "count", "numimages", "numberofimages", "imagecount", "imagescount"].includes(key)) return "count";
+    if (key === "quality") return "quality";
+    if (["duration", "seconds", "durationseconds", "videoseconds", "videoduration", "videodurationseconds", "videolength", "clipduration"].includes(key)) return "videoSeconds";
+    if (["generateaudio", "videogenerateaudio"].includes(key)) return "videoGenerateAudio";
+    if (["watermark", "videowatermark"].includes(key)) return "videoWatermark";
+    if (key === "audioformat" || (key === "format" && normalizedFieldType === "audio")) return "audioFormat";
+    if (["voice", "audiovoice"].includes(key)) return "audioVoice";
+    if ((key === "speed" && normalizedFieldType === "audio") || key === "audiospeed") return "audioSpeed";
+    if ((key === "instructions" && normalizedFieldType === "audio") || key === "audioinstructions") return "audioInstructions";
+    if (["transparentbackground", "transparent"].includes(key)) return "transparentBackground";
+    if (normalizedFieldType === "image") return "referenceImage";
+    if (normalizedFieldType === "video") return "referenceVideo";
+    if (normalizedFieldType === "audio") return "referenceAudio";
+    return "";
+}
+
+function shouldRepairLegacyWorkflowSource(fieldName: string, source: string, inferredSource: string, capability?: RunningHubCapability) {
+    if (!source || !inferredSource || source === inferredSource) return false;
+    const key = fieldName.toLowerCase().replace(/[\s_-]/g, "");
+    const wasMistakenForMedia = ["referenceImage", "referenceVideo", "referenceAudio"].includes(source);
+    if (wasMistakenForMedia && (workflowDimensionSource(key) || inferredSource === "aspectRatio" || inferredSource === "vquality")) return true;
+    // 旧版把通用 resolution 固定识别为图片尺寸；视频条目必须恢复为视频清晰度。
+    if (key === "resolution" && capability === "video" && source === "size") return true;
+    if (key === "resolution" && capability === "image" && source === "vquality") return true;
+    if (key === "quality" && source === "vquality") return true;
+    return false;
+}
+
+export function normalizeWorkflowFieldMappings(value: unknown, capability?: RunningHubCapability): WorkflowFieldMapping[] {
+    if (!Array.isArray(value)) return [];
+    const fields = value.flatMap((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+        const raw = item as Record<string, unknown>;
+        const nodeId = String(raw.nodeId || raw.node || raw.node_id || "").trim();
+        const fieldName = String(raw.fieldName || raw.input || raw.inputName || raw.input_name || "").trim();
+        if (!nodeId || !fieldName) return [];
+        // source 明确存在但为空，表示用户要求保留工作流默认值；只有旧数据完全缺少来源字段时才自动补绑定。
+        const sourceKey = ["source", "bind", "from"].find((key) => Object.prototype.hasOwnProperty.call(raw, key));
+        const sourceConfigured = Boolean(sourceKey);
+        const configuredSource = sourceKey ? raw[sourceKey] : (raw.bindPrompt === true || raw.bind_prompt === true ? "prompt" : "");
+        let source = normalizeWorkflowFieldSourceName(configuredSource, capability);
+        const rawSourceAutomatic = raw.sourceAutomatic ?? raw.source_automatic;
+        let sourceAutomatic = typeof rawSourceAutomatic === "boolean" ? rawSourceAutomatic : !sourceConfigured && Boolean(source);
+        const upstreamAllowed = raw.sourceFromUpstream !== false && raw.source_from_upstream !== false;
+        const upstreamExplicit = raw.sourceFromUpstream === true || raw.source_from_upstream === true;
+        const fieldType = String(raw.fieldType || raw.type || "").trim();
+        const inferredSource = inferWorkflowFieldSource(fieldName, fieldType, capability);
+        if (!source && !sourceConfigured && upstreamAllowed) {
+            source = inferredSource;
+            sourceAutomatic = Boolean(source);
+            if (!source && upstreamExplicit && ["text", "prompt", "positiveprompt", "positive"].includes(fieldName.toLowerCase().replace(/[\s_-]/g, ""))) {
+                source = "prompt";
+                sourceAutomatic = true;
+            }
+        } else if (shouldRepairLegacyWorkflowSource(fieldName, source, inferredSource, capability)) {
+            source = inferredSource;
+        }
+        // 比例、清晰度、时长等标量必须按 nodeId + fieldName 独立配置。
+        // 旧版自动来源会把两个同类字段折叠到同一个全局参数，重新归一化为直接字段值。
+        if (sourceAutomatic && !["prompt", "referenceImage", "referenceVideo", "referenceAudio", "mask"].includes(source)) {
+            source = "";
+            sourceAutomatic = false;
+        }
+        const fieldValue = raw.fieldValue ?? raw.defaultValue ?? raw.default_value ?? raw.default ?? raw.value;
+        const rawOptions = raw.options ?? raw.values ?? raw.choices ?? raw.enum ?? raw.fieldOptions ?? raw.field_options;
+        const options = Array.isArray(rawOptions)
+            ? rawOptions
+            : rawOptions && typeof rawOptions === "object"
+                ? ((rawOptions as Record<string, unknown>).choices ?? (rawOptions as Record<string, unknown>).options ?? (rawOptions as Record<string, unknown>).values)
+                : undefined;
+        const range = workflowFieldRange(rawOptions);
+        const min = raw.min ?? raw.minValue ?? raw.min_value ?? range.min;
+        const max = raw.max ?? raw.maxValue ?? raw.max_value ?? range.max;
+        const step = raw.step ?? raw.stepValue ?? raw.step_value ?? range.step;
+        const required = raw.required ?? raw.isRequired ?? raw.is_required;
+        const randomEnabled = raw.randomEnabled ?? raw.random_enabled;
+        const sourceIndex = Number(raw.sourceIndex ?? raw.source_index ?? raw.index);
+        const imageOrder = Number(raw.imageOrder ?? raw.image_order);
+        const candidate: WorkflowFieldMapping = {
+            ...raw,
+            nodeId,
+            classType: String(raw.classType || raw.class_type || "").trim() || undefined,
+            fieldName,
+            id: String(raw.id || `${nodeId}::${fieldName}`),
+            source,
+            ...(fieldValue !== undefined ? { fieldValue } : {}),
+            ...(Array.isArray(options) ? { options } : {}),
+            ...(min !== undefined ? { min } : {}),
+            ...(max !== undefined ? { max } : {}),
+            ...(step !== undefined ? { step } : {}),
+            ...(typeof required === "boolean" ? { required } : {}),
+            ...(typeof randomEnabled === "boolean" ? { randomEnabled } : {}),
+            sourceAutomatic,
+            ...(Number.isFinite(sourceIndex) ? { sourceIndex } : {}),
+            ...(Number.isFinite(imageOrder) ? { imageOrder } : {}),
+        } as WorkflowFieldMapping;
+        const safeToOverride = raw.safeToOverride !== false && raw.safe_to_override !== false && workflowFieldSafeToOverride(candidate);
+        const role = workflowFieldRole({ ...candidate, role: String(raw.role || "") });
+        const configuredEnabled = typeof raw.enabled === "boolean" ? raw.enabled : role !== "internal";
+        const optionsSource = ["workflow", "manual", "preset"].includes(String(raw.optionsSource || raw.options_source || ""))
+            ? String(raw.optionsSource || raw.options_source) as WorkflowFieldMapping["optionsSource"]
+            : Array.isArray(options) ? "workflow" : undefined;
+        return [{ ...candidate, role, safeToOverride, enabled: safeToOverride && configuredEnabled, ...(optionsSource ? { optionsSource } : {}) }];
+    });
+    let imageOrder = 0;
+    let videoOrder = 0;
+    let audioOrder = 0;
+    return fields.map((field) => {
+        if (field.source === "referenceImage") {
+            const configuredOrder = Number(field.imageOrder);
+            const nextOrder = Number.isInteger(configuredOrder) && configuredOrder > 0 ? configuredOrder : imageOrder + 1;
+            imageOrder = Math.max(imageOrder, nextOrder);
+            return { ...field, imageOrder: nextOrder, sourceIndex: nextOrder - 1, required: field.required ?? nextOrder === 1 };
+        }
+        if (field.source === "referenceVideo") {
+            const configuredIndex = Number(field.sourceIndex);
+            const nextIndex = Number.isInteger(configuredIndex) && configuredIndex >= 0 ? configuredIndex : videoOrder;
+            videoOrder = Math.max(videoOrder, nextIndex + 1);
+            return { ...field, sourceIndex: nextIndex, required: field.required ?? nextIndex === 0 };
+        }
+        if (field.source === "referenceAudio") {
+            const configuredIndex = Number(field.sourceIndex);
+            const nextIndex = Number.isInteger(configuredIndex) && configuredIndex >= 0 ? configuredIndex : audioOrder;
+            audioOrder = Math.max(audioOrder, nextIndex + 1);
+            return { ...field, sourceIndex: nextIndex, required: field.required ?? nextIndex === 0 };
+        }
+        if (field.source === "prompt") return { ...field, required: field.required ?? true };
+        return field;
+    });
+}
+
+export function mergeWorkflowFieldMappings(current: unknown, incoming: unknown, capability?: RunningHubCapability) {
+    const previousFields = normalizeWorkflowFieldMappings(current, capability);
+    const nextFields = normalizeWorkflowFieldMappings(incoming, capability);
+    const previousByKey = new Map(previousFields.map((field) => [`${field.nodeId}::${field.fieldName}`, field]));
+    const policyKeys: Array<keyof WorkflowFieldMapping> = [
+        "label", "enabled",
+        "randomEnabled", "source", "sourceAutomatic", "sourceFromUpstream", "sourceIndex",
+        "imageOrder", "required", "bindPrompt",
+    ];
+    return nextFields.map((field) => {
+        const previous = previousByKey.get(`${field.nodeId}::${field.fieldName}`);
+        if (!previous) return field;
+        const merged = { ...field } as WorkflowFieldMapping;
+        const target = merged as unknown as Record<string, unknown>;
+        const source = previous as unknown as Record<string, unknown>;
+        policyKeys.forEach((key) => {
+            if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        });
+        // 字段类型、枚举和数值范围属于上游协议。只有本次拉取未返回时，才沿用本地补充配置。
+        if (!field.fieldType && previous.fieldType) merged.fieldType = previous.fieldType;
+        if (!field.options?.length && previous.options?.length) {
+            merged.options = previous.options;
+            merged.optionsSource = previous.optionsSource;
+        }
+        if (field.min === undefined && previous.min !== undefined) merged.min = previous.min;
+        if (field.max === undefined && previous.max !== undefined) merged.max = previous.max;
+        if (field.step === undefined && previous.step !== undefined) merged.step = previous.step;
+        // 首次获得角色信息时采用服务端的内部参数默认值；之后才保留用户明确的启用选择。
+        if (field.role === "internal" && previous.role !== "internal") merged.enabled = field.enabled;
+        if (field.safeToOverride === false) merged.enabled = false;
+        return merged;
+    });
+}
+
+function normalizeSavedWorkflowFields(workflow: { fields?: unknown; workflowJson?: Record<string, unknown> }, capability: RunningHubCapability) {
+    const schemaFields = workflowVideoFieldsFromJson(workflow.workflowJson);
+    return schemaFields.length
+        ? mergeWorkflowFieldMappings(workflow.fields, schemaFields, capability)
+        : normalizeWorkflowFieldMappings(workflow.fields, capability);
+}
+
+function workflowFieldRange(value: unknown) {
+    const candidates: Record<string, unknown>[] = [];
+    const add = (item: unknown) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) return;
+        const record = item as Record<string, unknown>;
+        candidates.push(record);
+        add(record.range);
+    };
+    add(value);
+    if (Array.isArray(value)) value.forEach(add);
+    const read = (keys: string[]) => candidates.map((item) => keys.map((key) => item[key]).find((candidate) => candidate !== undefined)).find((candidate) => candidate !== undefined);
+    return { min: read(["min", "minValue", "min_value"]), max: read(["max", "maxValue", "max_value"]), step: read(["step", "stepValue", "step_value"]) };
+}
+
+export type RunningHubWorkflow = {
+    kind?: RunningHubWorkflowKind;
+    capability?: RunningHubCapability;
+    workflowId: string;
+    webappId?: string;
+    title?: string;
+    description?: string;
+    fields?: WorkflowFieldMapping[];
+    workflowJson?: Record<string, unknown>;
+    optionalImageMode?: string;
+    raw?: Record<string, unknown>;
+};
+
+export type RunningHubConfig = {
+    enabled: boolean;
+    baseUrl: string;
+    apiKey: string;
+    walletApiKey: string;
+    /** 仅用于 RunningHub 参考素材上传，通常填写企业级 API Key。 */
+    uploadApiKey?: string;
+    useWallet: boolean;
+    capability: RunningHubCapability;
+    selectedKind: RunningHubWorkflowKind;
+    workflowId: string;
+    workflows: RunningHubWorkflow[];
+};
+
+export type ComfyBridgeWorkflow = {
+    workflowId: string;
+    title?: string;
+    capability: "image" | "video" | "audio";
+    fields?: WorkflowFieldMapping[];
+    workflowJson?: Record<string, unknown>;
+    workflowGraph?: WorkflowGraphPreview;
+};
+
+export type WorkflowGraphPreview = {
+    nodes: Array<{ id: string; title?: string; classType?: string }>;
+    edges: Array<{ from: string; to: string }>;
+};
+
+export type ComfyBridgeConfig = {
+    enabled: boolean;
+    bridgeId: string;
+    comfyUrl: string;
+    workflowDir: string;
+    workflowId: string;
+    capability: "image" | "video" | "audio";
+    workflows: ComfyBridgeWorkflow[];
+};
+
+// 兼容仍在使用旧目录标识的会话恢复和模型选择器。
 export const PUBLIC_MODEL_CATALOG_ID = "managed";

 export type ModelChannel = {
@@ -68,6 +384,10 @@ export type AiConfig = {
    apiKey: string;
    apiFormat: ApiCallFormat;
    channels: ModelChannel[];
+    runningHub: RunningHubConfig;
+    comfyBridge: ComfyBridgeConfig;
+    /** 仅用于单次生成任务路由，不属于全局渠道启用状态。 */
+    taskWorkflowProvider?: "model" | "runninghub" | "comfyui";
    model: string;
    imageModel: string;
    videoModel: string;
@@ -109,6 +429,9 @@ export const defaultConfig: AiConfig = {
    apiFormat: "openai",
    // 创作端模型目录只能来自后台公开逻辑模型和用户自定义渠道，不能内置供应商模型。
    channels: [],
+    runningHub: { enabled: false, baseUrl: "https://www.runninghub.cn", apiKey: "", walletApiKey: "", uploadApiKey: "", useWallet: false, capability: "image", selectedKind: "workflow", workflowId: "", workflows: [] },
+    comfyBridge: { enabled: false, bridgeId: "", comfyUrl: "http://127.0.0.1:8188", workflowDir: "D:\\ComfyUI\\workflows", workflowId: "", capability: "image", workflows: [] },
+    taskWorkflowProvider: "model",
    model: "",
    imageModel: "",
    videoModel: "",
@@ -257,6 +580,13 @@ export function configuredModelMatchesCapability(config: AiConfig, model: string
 }

 function isAiConfigReady(config: AiConfig, model: string) {
+    if (config.taskWorkflowProvider === "runninghub") {
+        const key = config.runningHub.apiKey;
+        return Boolean(config.runningHub.enabled && config.runningHub.baseUrl.trim() && key.trim() && config.runningHub.workflowId.trim());
+    }
+    if (config.taskWorkflowProvider === "comfyui") {
+        return Boolean(config.comfyBridge.enabled && config.comfyBridge.bridgeId.trim() && config.comfyBridge.workflowId.trim());
+    }
    const channel = resolveModelChannel(config, model);
    if (channel.transport === "local-runtime") return channel.enabled !== false && Boolean(channel.localModels?.some((item) => item.id === modelOptionName(model)));
    return Boolean(model.trim() && channel.baseUrl.trim() && channel.apiKey.trim());
@@ -308,7 +638,61 @@ export const useConfigStore = create<ConfigStore>()(
 export function normalizeConfigSnapshot(snapshot: ConfigStoreSnapshot | undefined = {}) {
    // 坏存储/旧版本快照可能是 undefined 或缺 config，兜底为 defaultConfig，保证渲染不崩溃
    const persistedConfig = (snapshot?.config || {}) as Partial<AiConfig>;
-    const config = { ...defaultConfig, ...persistedConfig };
+    const persistedRunningHub = persistedConfig.runningHub;
+    const runningHubCapability = normalizeRunningHubCapability(persistedRunningHub?.capability, defaultConfig.runningHub.capability);
+    const runningHubWorkflows = Array.isArray(persistedRunningHub?.workflows)
+        ? persistedRunningHub.workflows
+            .filter((item): item is RunningHubWorkflow => Boolean(item && typeof item === "object" && String(item.workflowId || "").trim()))
+            .map((item) => {
+                const capability = normalizeRunningHubCapability(item.capability, runningHubCapability);
+                return {
+                    ...item,
+                    kind: normalizeRunningHubWorkflowKind(item.kind),
+                    workflowId: String(item.workflowId || "").trim(),
+                    capability,
+                    fields: normalizeSavedWorkflowFields(item, capability),
+                };
+            })
+        : [];
+    const runningHubWorkflowID = String(persistedRunningHub?.workflowId || "").trim();
+    const runningHubSelectedKind = persistedRunningHub?.selectedKind
+        ? normalizeRunningHubWorkflowKind(persistedRunningHub.selectedKind)
+        : normalizeRunningHubWorkflowKind(runningHubWorkflows.find((item) => item.workflowId === runningHubWorkflowID)?.kind);
+    const persistedComfyBridge = persistedConfig.comfyBridge;
+    const comfyBridgeCapability = normalizeRunningHubCapability(persistedComfyBridge?.capability, defaultConfig.comfyBridge.capability);
+    const comfyBridgeWorkflows = Array.isArray(persistedComfyBridge?.workflows)
+        ? persistedComfyBridge.workflows
+            .filter((item): item is ComfyBridgeWorkflow => Boolean(item && typeof item === "object" && String(item.workflowId || "").trim()))
+            .map((item) => {
+                const capability = normalizeRunningHubCapability(item.capability, comfyBridgeCapability);
+                return {
+                    ...item,
+                    workflowId: String(item.workflowId || "").trim(),
+                    capability,
+                    fields: normalizeSavedWorkflowFields(item, capability),
+                };
+            })
+        : [];
+    const config = {
+        ...defaultConfig,
+        ...persistedConfig,
+        taskWorkflowProvider: "model" as const,
+        runningHub: {
+            ...defaultConfig.runningHub,
+            ...(persistedRunningHub || {}),
+            capability: runningHubCapability,
+            selectedKind: runningHubSelectedKind,
+            workflowId: runningHubWorkflowID,
+            workflows: runningHubWorkflows,
+        },
+        comfyBridge: {
+            ...defaultConfig.comfyBridge,
+            ...(persistedComfyBridge || {}),
+            capability: comfyBridgeCapability,
+            workflowId: String(persistedComfyBridge?.workflowId || "").trim(),
+            workflows: comfyBridgeWorkflows,
+        },
+    };
    const hasPersistedChannels = Array.isArray(persistedConfig.channels);
    if (!hasPersistedChannels) config.channels = [];
    const channels = normalizeChannels(config, !hasPersistedChannels);