Standardize configurable Comfy pipeline

API.md

@@ -16,7 +16,28 @@ Returns `{"status":true}` when the application is ready.
 POST /api/generate?p=PASSWORD
 Content-Type: application/json
 
-{"prompt":"an orange cat","width":1152,"height":896,"steps":16,"negative":"text, watermark","sampler":"euler_ancestral","scheduler":"karras","cfg":4}
+{
+  "prompt": "an orange cat",
+  "negative": "text, watermark",
+  "width": 1152,
+  "height": 896,
+  "model": "52_novaAnimeXL_ilV190.safetensors",
+  "loras": [{"name": "8_bikabaka.safetensors", "strength": 1, "clip": 0}],
+  "sampler": "euler_ancestral",
+  "scheduler": "karras",
+  "steps": 16,
+  "cfg": 4,
+  "upscale": true,
+  "upscale_method": "bislerp",
+  "upscale_scale": 1.1,
+  "second_model": "",
+  "second_loras": [],
+  "second_sampler": "euler",
+  "second_scheduler": "karras",
+  "second_steps": 18,
+  "second_cfg": 5,
+  "denoise": 0.5
+}
 ```
 
-Returns the generated PNG at 50% of its full dimensions with content type `image/png`. Add `&res=full` to return the full resolution. Only `prompt` is required. Width and height default to 1152 by 896, steps defaults to 16, sampler defaults to `euler_ancestral`, scheduler defaults to `karras`, CFG defaults to 4, and negative defaults to the built-in negative prompt. Width and height must be multiples of 8 from 64 through 2048; steps must be from 1 through 100.
+Returns the generated PNG at 50% of its full dimensions with content type `image/png`. Add `&res=full` to return the full resolution. Only `prompt` is required for the built-in site defaults. LoRAs run in array order. Each request creates a random first-pass seed and, when `upscale` is true, performs latent upscaling followed by a second sampler with another random seed. Leave `second_model` empty to reuse the first model and LoRA chain; otherwise `second_loras` applies to the selected second model. Width and height must be multiples of 8 from 64 through 2048; steps must be from 1 through 100.

app.py

@@ -1,4 +1,3 @@
-import math
 import os
 import random
 import re
@@ -12,7 +11,6 @@ import warnings
 from asyncio.base_events import BaseEventLoop
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
-from io import BytesIO
 from pathlib import Path
 from zoneinfo import ZoneInfo
 
@@ -34,8 +32,6 @@ import gradio as gr
 import numpy as np
 import spaces
 import torch
-from cryptography.hazmat.primitives.ciphers.aead import AESGCM
-from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
 from fastapi import Depends, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
@@ -56,10 +52,6 @@ OUTPUT_DIR = DATA_DIR / "output"
 TIMEZONE = ZoneInfo("Asia/Singapore")
 MIB = 1024 * 1024
 COPY_SIZE = 16 * MIB
-SALT_SIZE = 16
-NONCE_SIZE = 12
-SCRYPT_N = 2**14
-FILE_MAGIC = b"EPNG1"
 RETURN_SCALE = .5
 PORT = int(os.environ.get("PORT", "7860"))
 LOCAL_URL = os.environ.get("LOCAL_URL", f"http://127.0.0.1:{PORT}")
@@ -94,11 +86,6 @@ ASSETS = {
         "vae",
         "vae/3_sdxlVAE_sdxlVAE.safetensors",
     ),
-    "upscale": (
-        "1x-Archivist_Soft.pth",
-        "upscale_models",
-        "upscale_models/1x-Archivist_Soft.pth",
-    ),
 }
 
 DEFAULT_NEGATIVE = (
@@ -110,6 +97,19 @@ DEFAULT_NEGATIVE = (
 DEFAULT_SAMPLER = "euler_ancestral"
 DEFAULT_SCHEDULER = "karras"
 DEFAULT_CFG = 4
+DEFAULT_MODEL = ASSETS["checkpoint"][0]
+DEFAULT_LORAS = (
+    (ASSETS["bikabaka"][0], .5, 0),
+    (ASSETS["5cm"][0], 1.2, 0),
+    (ASSETS["saturation"][0], -1.4, 0),
+)
+DEFAULT_UPSCALE_METHOD = "bislerp"
+DEFAULT_UPSCALE_SCALE = 1.1
+DEFAULT_SECOND_SAMPLER = "euler"
+DEFAULT_SECOND_SCHEDULER = "karras"
+DEFAULT_SECOND_STEPS = 18
+DEFAULT_SECOND_CFG = 5
+DEFAULT_DENOISE = .5
 GPU_ABORT_ERROR = "GPU task aborted"
 
 paths = {}
@@ -207,6 +207,42 @@ def stage_assets():
         log(f"Copied {target.name}: {size // MIB} MiB")
 
 
+class LoraRequest(BaseModel):
+    name: str
+    strength: float = 1
+    clip: float = 0
+
+
+def default_loras():
+    return [
+        LoraRequest(name=name, strength=strength, clip=clip)
+        for name, strength, clip in DEFAULT_LORAS
+    ]
+
+
+class DirectRequest(BaseModel):
+    prompt: str
+    negative: str = DEFAULT_NEGATIVE
+    width: int = Field(1152, ge=64, le=2048)
+    height: int = Field(896, ge=64, le=2048)
+    model: str = DEFAULT_MODEL
+    loras: list[LoraRequest] = Field(default_factory=default_loras)
+    sampler: str = DEFAULT_SAMPLER
+    scheduler: str = DEFAULT_SCHEDULER
+    steps: int = Field(16, ge=1, le=100)
+    cfg: float = Field(DEFAULT_CFG, ge=0, le=100)
+    upscale: bool = False
+    upscale_method: str = DEFAULT_UPSCALE_METHOD
+    upscale_scale: float = Field(DEFAULT_UPSCALE_SCALE, gt=0)
+    second_model: str = ""
+    second_loras: list[LoraRequest] = Field(default_factory=list)
+    second_sampler: str = DEFAULT_SECOND_SAMPLER
+    second_scheduler: str = DEFAULT_SECOND_SCHEDULER
+    second_steps: int = Field(DEFAULT_SECOND_STEPS, ge=1, le=100)
+    second_cfg: float = Field(DEFAULT_SECOND_CFG, ge=0, le=100)
+    denoise: float = Field(DEFAULT_DENOISE, ge=0, le=1)
+
+
 def ensure_comfy():
     if COMFYUI_PATH.is_dir():
         log(f"Found ComfyUI at {COMFYUI_PATH}")
@@ -242,90 +278,44 @@ def init_comfy():
 
     args.cpu_vae = False
 
-    from comfy_extras.nodes_upscale_model import (
-        ImageUpscaleWithModel,
-        UpscaleModelLoader,
-    )
     from nodes import (
+        CLIPTextEncode,
         CheckpointLoaderSimple,
         EmptyLatentImage,
         KSampler,
+        LatentUpscaleBy,
         LoraLoader,
         VAEDecode,
         VAELoader,
     )
 
+    for kind in {asset[1] for asset in ASSETS.values()}:
+        folder_paths.add_model_folder_path(kind, str(DATA_DIR / kind))
+
     for key, path in paths.items():
         kind = ASSETS[key][1]
         folder_paths.add_model_folder_path(kind, str(path.parent))
 
-    log(f"Loading checkpoint {paths['checkpoint'].name}")
-    checkpoint = CheckpointLoaderSimple().load_checkpoint(
-        ckpt_name=paths["checkpoint"].name
-    )
-
-    loader = LoraLoader()
-
-    log(f"Loading LoRA {paths['bikabaka'].name}")
-    first = loader.load_lora(
-        model=checkpoint[0],
-        clip=checkpoint[1],
-        lora_name=paths["bikabaka"].name,
-        strength_model=.5,
-        strength_clip=0,
-    )
-
-    log(f"Loading LoRA {paths['5cm'].name}")
-    second = loader.load_lora(
-        model=first[0],
-        clip=first[1],
-        lora_name=paths["5cm"].name,
-        strength_model=1.2,
-        strength_clip=0,
-    )
-
-    log(f"Loading LoRA {paths['saturation'].name}")
-    final = loader.load_lora(
-        model=second[0],
-        clip=second[1],
-        lora_name=paths["saturation"].name,
-        strength_model=-1.4,
-        strength_clip=0,
-    )
-
     log(f"Loading VAE {paths['vae'].name}")
-    log(f"Loading upscale model {paths['upscale'].name}")
 
     state.update(
-        model=final[0],
-        clip=final[1],
-        negative_clip=second[1],
+        checkpoint=CheckpointLoaderSimple(),
+        lora=LoraLoader(),
+        encode=CLIPTextEncode(),
         vae=VAELoader().load_vae(
             vae_name=paths["vae"].name
         )[0],
         latent=EmptyLatentImage(),
         sample=KSampler(),
         decode=VAEDecode(),
-        upscale_model=UpscaleModelLoader().load_model(
-            paths["upscale"].name
-        )[0],
-        upscale=ImageUpscaleWithModel(),
+        upscale=LatentUpscaleBy(),
     )
 
     log("ComfyUI initialization complete")
 
 
-@spaces.GPU(duration=11)
-def generate_core(
-    steps,
-    positive,
-    negative,
-    latent,
-    seed,
-    sampler,
-    scheduler,
-    cfg,
-):
+@spaces.GPU(duration=30)
+def generate_core(body):
     with torch.inference_mode(), warnings.catch_warnings():
         warnings.filterwarnings(
             "ignore",
@@ -334,90 +324,105 @@ def generate_core(
             module=r"torchsde\._brownian\.brownian_interval",
         )
 
+        request = DirectRequest.model_validate_json(body)
+        model, clip = load_chain(request.model, request.loras)
+        positive = state["encode"].encode(request.prompt, clip)[0]
+        negative = state["encode"].encode(request.negative, clip)[0]
+        latent = state["latent"].generate(
+            width=request.width,
+            height=request.height,
+            batch_size=1,
+        )[0]
+        first_seed = random.randrange(2**64)
         samples = state["sample"].sample(
-            model=state["model"],
-            seed=seed,
-            steps=steps,
-            cfg=cfg,
-            sampler_name=sampler,
-            scheduler=scheduler,
-            positive=state["clip"].encode_from_tokens_scheduled(positive),
-            negative=state["negative_clip"].encode_from_tokens_scheduled(negative),
+            model=model,
+            seed=first_seed,
+            steps=request.steps,
+            cfg=request.cfg,
+            sampler_name=request.sampler,
+            scheduler=request.scheduler,
+            positive=positive,
+            negative=negative,
             latent_image=latent,
             denoise=1,
         )[0]
 
+        second_seed = None
+        if request.upscale:
+            samples = state["upscale"].upscale(
+                samples=samples,
+                upscale_method=request.upscale_method,
+                scale_by=request.upscale_scale,
+            )[0]
+            if request.second_model:
+                model, clip = load_chain(
+                    request.second_model,
+                    request.second_loras,
+                )
+                positive = state["encode"].encode(request.prompt, clip)[0]
+                negative = state["encode"].encode(request.negative, clip)[0]
+
+            second_seed = random.randrange(2**64)
+            samples = state["sample"].sample(
+                model=model,
+                seed=second_seed,
+                steps=request.second_steps,
+                cfg=request.second_cfg,
+                sampler_name=request.second_sampler,
+                scheduler=request.second_scheduler,
+                positive=positive,
+                negative=negative,
+                latent_image=samples,
+                denoise=request.denoise,
+            )[0]
+
         image = state["decode"].decode(
             vae=state["vae"],
             samples=samples,
         )[0]
+        return image[0], first_seed, second_seed
 
-        return state["upscale"].upscale(
-            state["upscale_model"],
-            image,
-        )[0][0]
 
+def load_chain(model_name, loras):
+    model, clip = state["checkpoint"].load_checkpoint(
+        ckpt_name=model_name
+    )[:2]
 
-def generate_image(
-    prompt,
-    width=1152,
-    height=896,
-    steps=16,
-    negative=DEFAULT_NEGATIVE,
-    sampler=DEFAULT_SAMPLER,
-    scheduler=DEFAULT_SCHEDULER,
-    cfg=DEFAULT_CFG,
-    tag="ST",
-):
-    width = int(width)
-    height = int(height)
-    steps = int(steps)
-    cfg = float(cfg)
-
-    if (
-        not 64 <= width <= 2048
-        or width % 8
-        or not 64 <= height <= 2048
-        or height % 8
-    ):
-        raise ValueError(
-            "Width and height must be multiples of 8 from 64 to 2048"
+    for lora in loras:
+        model, clip = state["lora"].load_lora(
+            model=model,
+            clip=clip,
+            lora_name=lora.name,
+            strength_model=lora.strength,
+            strength_clip=lora.clip,
         )
 
-    if not 1 <= steps <= 100:
-        raise ValueError("Steps must be from 1 to 100")
+    return model, clip
 
-    if not 0 <= cfg <= 100:
-        raise ValueError("CFG must be from 0 to 100")
+
+def generate_image(request, tag="ST"):
+    if (
+        request.width % 8
+        or request.height % 8
+    ):
+        raise ValueError("Width and height must be multiples of 8")
 
     with lock:
         init_comfy()
 
         options = state["sample"].INPUT_TYPES()["required"]
-        if (
-            sampler not in options["sampler_name"][0]
-            or scheduler not in options["scheduler"][0]
-        ):
+        samplers = [request.sampler]
+        schedulers = [request.scheduler]
+        if request.upscale:
+            samplers.append(request.second_sampler)
+            schedulers.append(request.second_scheduler)
+        if any(value not in options["sampler_name"][0] for value in samplers):
+            raise ValueError("Unsupported sampler or scheduler")
+        if any(value not in options["scheduler"][0] for value in schedulers):
             raise ValueError("Unsupported sampler or scheduler")
 
-        positive = state["clip"].tokenize(prompt)
-        negative_tokens = state["negative_clip"].tokenize(negative)
-        latent = state["latent"].generate(
-            width=width,
-            height=height,
-            batch_size=1,
-        )[0]
-        seed = random.randrange(2**64)
-
-        image = generate_core(
-            steps,
-            positive,
-            negative_tokens,
-            latent,
-            seed,
-            sampler,
-            scheduler,
-            cfg,
+        image, first_seed, second_seed = generate_core(
+            request.model_dump_json()
         )
 
         result = Image.fromarray(
@@ -430,15 +435,9 @@ def generate_image(
 
         result.info.update(
             image_metadata(
-                prompt,
-                width,
-                height,
-                steps,
-                seed,
-                negative,
-                sampler,
-                scheduler,
-                cfg,
+                request.model_dump(),
+                [first_seed, second_seed],
+                paths["vae"].name,
             )
         )
 
@@ -450,38 +449,22 @@ def archive_image(image, tag):
     try:
         path = DATA_DIR / "img" / datetime.now(TIMEZONE).date().isoformat()
         path.mkdir(parents=True, exist_ok=True)
-        data = BytesIO()
         pnginfo = PngInfo()
 
-        for key in ("prompt", "workflow"):
-            pnginfo.add_text(key, image.info[key])
+        for key, value in image.info.items():
+            pnginfo.add_text(key, value)
 
-        image.save(
-            data,
-            format="PNG",
-            pnginfo=pnginfo,
-        )
-        salt = os.urandom(SALT_SIZE)
-        nonce = os.urandom(NONCE_SIZE)
-        key = Scrypt(
-            salt=salt,
-            length=32,
-            n=SCRYPT_N,
-            r=8,
-            p=1,
-        ).derive(PASSWORD.encode())
-        encrypted = AESGCM(key).encrypt(nonce, data.getvalue(), FILE_MAGIC)
         number = (
             sum(
-                file.suffix.casefold() == ".epng"
+                file.suffix.casefold() == ".png"
                 for file in path.iterdir()
             )
             + 1
         )
-        name = f"{number}{tag}.epng"
+        name = f"{number}_{tag}.png"
         output = path / name
-        temp = output.with_suffix(".epng.part")
-        temp.write_bytes(FILE_MAGIC + salt + nonce + encrypted)
+        temp = output.with_suffix(".png.part")
+        image.save(temp, format="PNG", pnginfo=pnginfo)
         temp.replace(output)
         log(f"Saved img/{path.name}/{name}")
     except Exception as error:
@@ -506,68 +489,33 @@ def generate(
     if not valid_pass(p):
         raise gr.Error("Invalid password")
 
-    return generate_image(
-        prompt,
-        width,
-        height,
-        steps,
-        negative,
-        sampler,
-        scheduler,
-        cfg,
-        "GR",
+    request = DirectRequest(
+        prompt=prompt,
+        width=width,
+        height=height,
+        steps=steps,
+        negative=negative,
+        sampler=sampler,
+        scheduler=scheduler,
+        cfg=cfg,
     )
+    return generate_image(request, "GR")
 
 
-def api_generate(
-    prompt,
-    width=1152,
-    height=896,
-    steps=16,
-    negative=DEFAULT_NEGATIVE,
-    sampler=DEFAULT_SAMPLER,
-    scheduler=DEFAULT_SCHEDULER,
-    cfg=DEFAULT_CFG,
-    p="",
-):
+def api_generate(body, p=""):
     if not valid_pass(p):
         raise gr.Error("Invalid password")
 
-    return generate_image(
-        prompt,
-        width,
-        height,
-        steps,
-        negative,
-        sampler,
-        scheduler,
-        cfg,
-    )
+    return generate_image(DirectRequest.model_validate_json(body))
 
 
-def queued_generate(
-    prompt,
-    width,
-    height,
-    steps,
-    negative=DEFAULT_NEGATIVE,
-    sampler=DEFAULT_SAMPLER,
-    scheduler=DEFAULT_SCHEDULER,
-    cfg=DEFAULT_CFG,
-):
+def queued_generate(request):
     client = Client(LOCAL_URL, verbose=False)
 
     for attempt in range(2):
         try:
             result = client.predict(
-                prompt,
-                width,
-                height,
-                steps,
-                negative,
-                sampler,
-                scheduler,
-                cfg,
+                request.model_dump_json(),
                 PASSWORD,
                 api_name="/generate",
             )
@@ -654,14 +602,16 @@ def run_job(job_id, workflow):
         ) = workflow_values(workflow)
 
         image = queued_generate(
-            prompt,
-            width,
-            height,
-            steps,
-            negative,
-            sampler,
-            scheduler,
-            cfg,
+            DirectRequest(
+                prompt=prompt,
+                width=width,
+                height=height,
+                steps=steps,
+                negative=negative,
+                sampler=sampler,
+                scheduler=scheduler,
+                cfg=cfg,
+            )
         )
 
         filename = f"{job_id}.png"
@@ -706,17 +656,6 @@ def run_job(job_id, workflow):
         }
 
 
-class DirectRequest(BaseModel):
-    prompt: str
-    width: int = Field(1152, ge=64, le=2048)
-    height: int = Field(896, ge=64, le=2048)
-    steps: int = Field(16, ge=1, le=100)
-    negative: str = DEFAULT_NEGATIVE
-    sampler: str = DEFAULT_SAMPLER
-    scheduler: str = DEFAULT_SCHEDULER
-    cfg: float = Field(DEFAULT_CFG, ge=0, le=100)
-
-
 api = App()
 api.add_middleware(
     CORSMiddleware,
@@ -755,8 +694,11 @@ def system_stats():
     dependencies=[Depends(require_pass)],
 )
 def object_info():
-    ensure_assets()
+    init_comfy()
     options = state["sample"].INPUT_TYPES()["required"]
+    checkpoints = state["checkpoint"].INPUT_TYPES()["required"]
+    loras = state["lora"].INPUT_TYPES()["required"]
+    upscalers = state["upscale"].INPUT_TYPES()["required"]
 
     return {
         "KSampler": {
@@ -775,7 +717,25 @@ def object_info():
             "input": {
                 "required": {
                     "ckpt_name": [
-                        [paths["checkpoint"].name]
+                        checkpoints["ckpt_name"][0]
+                    ]
+                }
+            }
+        },
+        "LoraLoader": {
+            "input": {
+                "required": {
+                    "lora_name": [
+                        loras["lora_name"][0]
+                    ]
+                }
+            }
+        },
+        "LatentUpscaleBy": {
+            "input": {
+                "required": {
+                    "upscale_method": [
+                        upscalers["upscale_method"][0]
                     ]
                 }
             }
@@ -871,16 +831,7 @@ def direct(
     res: str = Query(""),
 ):
     try:
-        image = queued_generate(
-            body.prompt,
-            body.width,
-            body.height,
-            body.steps,
-            body.negative,
-            body.sampler,
-            body.scheduler,
-            body.cfg,
-        )
+        image = queued_generate(body)
     except ValueError as error:
         raise HTTPException(422, str(error)) from error
 
@@ -967,6 +918,7 @@ with gr.Blocks(title="Image API") as demo:
 
     api_button = gr.Button(visible=False)
     api_pass_input = gr.Textbox(visible=False)
+    request_input = gr.Textbox(visible=False)
     negative_input = gr.Textbox(
         DEFAULT_NEGATIVE,
         visible=False,
@@ -1013,14 +965,7 @@ with gr.Blocks(title="Image API") as demo:
     api_button.click(
         api_generate,
         [
-            prompt_input,
-            width_input,
-            height_input,
-            steps_input,
-            negative_input,
-            sampler_input,
-            scheduler_input,
-            cfg_input,
+            request_input,
             api_pass_input,
         ],
         output,

requirements.txt

@@ -1,5 +1,4 @@
 fastapi
-cryptography
 gradio==6.20.0
 huggingface_hub>=1.6
 numpy

workflow_api.py

@@ -582,36 +582,90 @@ def build_extra_pnginfo() -> dict[str, Any] | None:
     }
 
 
-def image_metadata(text, width, height, steps, seed, negative, sampler, scheduler, cfg):
-    api = build_workflow()
-    api["118"]["inputs"]["string_a"] = text
-    api["3"]["inputs"]["text"] = negative
-    api["27"]["inputs"].update(width=width, height=height)
-    api["5"]["inputs"].update(
-        seed=seed, steps=steps, sampler_name=sampler, scheduler=scheduler, cfg=cfg,
-    )
-    api["28"]["inputs"].update(model=["10", 0], clip=["10", 1])
-    api.pop("38")
-
-    workflow = build_extra_pnginfo()["workflow"]
-    nodes = {node["id"]: node for node in workflow["nodes"]}
-    nodes[118]["widgets_values"][0] = text
-    nodes[3]["widgets_values"][0] = negative
-    nodes[27]["widgets_values"][:2] = [width, height]
-    nodes[5]["widgets_values"][0] = seed
-    nodes[5]["widgets_values"][2] = steps
-    nodes[5]["widgets_values"][3] = cfg
-    nodes[5]["widgets_values"][4:6] = [sampler, scheduler]
-    nodes[10]["outputs"][0]["links"] = [27]
-    nodes[10]["outputs"][1]["links"] = [28]
-    workflow["nodes"] = [node for node in workflow["nodes"] if node["id"] != 38]
-    workflow["links"] = [
-        [link[0], 10, *link[2:]] if link[0] in {27, 28} else link
-        for link in workflow["links"] if link[0] not in {29, 30}
-    ]
+def image_metadata(config, seeds, vae):
+    api = {}
+
+    def add(class_type, inputs):
+        node_id = str(len(api) + 1)
+        api[node_id] = {"inputs": inputs, "class_type": class_type}
+        return node_id
+
+    def load_chain(model_name, loras):
+        node_id = add("CheckpointLoaderSimple", {"ckpt_name": model_name})
+        model = [node_id, 0]
+        clip = [node_id, 1]
+        for lora in loras:
+            node_id = add("LoraLoader", {
+                "lora_name": lora["name"],
+                "strength_model": lora["strength"],
+                "strength_clip": lora["clip"],
+                "model": model,
+                "clip": clip,
+            })
+            model = [node_id, 0]
+            clip = [node_id, 1]
+        return model, clip
+
+    model, clip = load_chain(config["model"], config["loras"])
+    positive = [add("CLIPTextEncode", {
+        "text": config["prompt"], "clip": clip,
+    }), 0]
+    negative = [add("CLIPTextEncode", {
+        "text": config["negative"], "clip": clip,
+    }), 0]
+    latent = [add("EmptyLatentImage", {
+        "width": config["width"],
+        "height": config["height"],
+        "batch_size": 1,
+    }), 0]
+    samples = [add("KSampler", {
+        "seed": seeds[0],
+        "steps": config["steps"],
+        "cfg": config["cfg"],
+        "sampler_name": config["sampler"],
+        "scheduler": config["scheduler"],
+        "denoise": 1,
+        "model": model,
+        "positive": positive,
+        "negative": negative,
+        "latent_image": latent,
+    }), 0]
+
+    if config["upscale"]:
+        samples = [add("LatentUpscaleBy", {
+            "upscale_method": config["upscale_method"],
+            "scale_by": config["upscale_scale"],
+            "samples": samples,
+        }), 0]
+        if config["second_model"]:
+            model, clip = load_chain(
+                config["second_model"], config["second_loras"],
+            )
+            positive = [add("CLIPTextEncode", {
+                "text": config["prompt"], "clip": clip,
+            }), 0]
+            negative = [add("CLIPTextEncode", {
+                "text": config["negative"], "clip": clip,
+            }), 0]
+        samples = [add("KSampler", {
+            "seed": seeds[1],
+            "steps": config["second_steps"],
+            "cfg": config["second_cfg"],
+            "sampler_name": config["second_sampler"],
+            "scheduler": config["second_scheduler"],
+            "denoise": config["denoise"],
+            "model": model,
+            "positive": positive,
+            "negative": negative,
+            "latent_image": samples,
+        }), 0]
+
+    vae_node = add("VAELoader", {"vae_name": vae})
+    image = add("VAEDecode", {"samples": samples, "vae": [vae_node, 0]})
+    add("PreviewImage", {"images": [image, 0]})
     return {
         "prompt": json.dumps(api, separators=(",", ":")),
-        "workflow": json.dumps(workflow, separators=(",", ":")),
+        "parameters": json.dumps(config, separators=(",", ":")),
     }