workflow_schema.json

{
    "$id": "https://github.com/dkackman/diffusers-helper/workflow",
    "$schema": "https://json-schema.org/draft/2020-12/schema#",
    "description": "The definition of the diffusers-workflow.",
    "type": "object",
    "properties": {
        "id": {
            "type": "string"
        },
        "description": {
            "type": "string"
        },
        "configures": {
            "type": "string",
            "description": "For a workflow under models/: the templates/ workflow this is a tuned per-checkpoint configuration of, as a catalog name such as 'templates/text-to-image'."
        },
        "shape": {
            "type": "string",
            "enum": ["image", "image-set", "image-edit", "shot", "sequence", "audio", "text", "utility"],
            "description": "What the workflow produces. Derived from the steps by the server; declare it only where the derivation is wrong. Closed vocabulary - adding a value is additive, renaming one breaks every client that filtered on it."
        },
        "traits": {
            "type": "array",
            "uniqueItems": true,
            "items": {
                "type": "string",
                "enum": ["has-audio", "chained", "image-conditioned", "identity-referenced", "needs-input-media", "composes-workflows"]
            },
            "description": "How the output is made or what it needs supplied. Derived by the server; declare only to override."
        },
        "summary": {
            "type": "string",
            "maxLength": 120,
            "description": "One line saying what the workflow is for, carried in catalog listings. Defaults to the first sentence of 'description'."
        },
        "cost": {
            "type": "array",
            "description": "Measured runs, one per device the maintainer measured on. Never derived; absent means unknown. 'minutes' is the whole run's wall clock on a worker that has to load the models - what a consumer actually waits through, not the denoise loop alone; on a video template the two differ by minutes.",
            "items": {
                "type": "object",
                "required": ["device", "vram_gb", "minutes"],
                "properties": {
                    "device": {"type": "string", "enum": ["cuda", "mps", "cpu"]},
                    "name": {"type": "string", "description": "The accelerator, for a person: 'RTX 4090', 'M2 Ultra'"},
                    "vram_gb": {"type": "number", "minimum": 0},
                    "minutes": {"type": "number", "minimum": 0},
                    "per_entry": {
                        "type": "object",
                        "description": "For a list-driven workflow: the measured cost of one entry of 'variable' (every member it produces), and the length of the default list 'minutes' was measured with, so a run over N entries is (minutes - per_entry.minutes * entries) + per_entry.minutes * N.",
                        "required": ["variable", "minutes", "entries"],
                        "properties": {
                            "variable": {"type": "string"},
                            "minutes": {"type": "number", "minimum": 0},
                            "entries": {"type": "integer", "minimum": 1}
                        },
                        "additionalProperties": false
                    }
                },
                "additionalProperties": false
            }
        },
        "cost_drivers": {
            "description": "The variables that move this workflow's cost, by name - a frame count, a step count, a segment count, not a prompt or a seed. Runs of this workflow are bucketed by these values when the server reports what its own history observed, so a 141-frame run never informs a 124-frame figure. Each name must be a variable this workflow declares. Declaring none is not neutral: the observed figure then falls back to runs that overrode nothing at all, which most real runs do not.",
            "type": "array",
            "items": {"type": "string"},
            "uniqueItems": true
        },
        "variables": {
            "$ref": "#/$defs/arguments"
        },
        "variable_constraints": {
            "description": "What each variable's value is allowed to be, by variable name. A rule the engine could only enforce after the weights were loaded costs minutes to discover; declared here it is a free refusal at validation time and a line in the catalog beside the default.",
            "type": "object",
            "additionalProperties": {
                "$ref": "#/$defs/variable_constraint"
            }
        },
        "seed": {
            "description": "Default seed for the entire workflow. Accepts a 'variable:' reference.",
            "type": [
                "integer",
                "string"
            ],
            "pattern": "^variable:",
            "format": "int64"
        },
        "argument_template": {
            "description": "Engine-injected: the arguments a parent workflow passed to this one when it ran it as a sub-workflow. Written by create_step_action from the step's 'arguments' block, not authored - a workflow file carrying one is read, but a sub-workflow step is how they are meant to be supplied.",
            "type": "object"
        },
        "steps": {
            "type": "array",
            "minItems": 1,
            "items": {
                "$ref": "#/$defs/step"
            }
        }
    },
    "additionalProperties": false,
    "required": [
        "id",
        "steps"
    ],
    "$defs": {
        "variable_constraint": {
            "description": "A rule the author declares for one variable's value, in the same field names a chain step's 'frame_snap' uses, so a model's frame rule is written once. Checked before anything is queued and reported beside the variable's default, so a consumer reads the rule rather than guessing it (#96).",
            "type": "object",
            "properties": {
                "modulus": {
                    "type": "integer",
                    "minimum": 1
                },
                "remainder": {
                    "type": "integer",
                    "minimum": 0
                },
                "min_frames": {
                    "type": "integer",
                    "minimum": 1
                },
                "max_frames": {
                    "type": "integer",
                    "minimum": 1
                },
                "snap": {
                    "description": "What to do with a value the rule refuses. 'up' rounds to the next value the rule accepts, and warns that it did; absent, the value is refused.",
                    "enum": [
                        "up"
                    ]
                },
                "reason": {
                    "description": "Why the rule exists, in the author's words - quoted in the refusal and reported beside the default.",
                    "type": "string"
                }
            },
            "dependentRequired": {
                "modulus": [
                    "remainder"
                ],
                "remainder": [
                    "modulus"
                ]
            },
            "additionalProperties": false
        },
        "image": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "format": "uri"
                },
                "size": {
                    "type": "object",
                    "properties": {
                        "width": {
                            "type": "integer",
                            "format": "int16"
                        },
                        "height": {
                            "type": "integer",
                            "format": "int16"
                        }
                    }
                }
            },
            "required": [
                "location"
            ]
        },
        "step": {
            "type": "object",
            "additionalProperties": false,
            "$comment": "A step is closed: the engine reads only the properties above, so an invented control-flow key ('when', 'retry') or a mistyped real one ('relase_pipeline') is a hard error rather than a silent no-op.",
            "properties": {
                "name": {
                    "type": "string"
                },
                "for_each": {
                    "description": "Run this step once per entry of a list. A list, or a 'variable:' reference to one. Inside the step, 'item:' is the entry and 'item:field' one of its fields; a later step reads every member's result with 'gather:<step name>'. Members are named '<step name>@<entry name>' (or '@<index>' for an entry without a name), so '@' is reserved in step names.",
                    "type": ["array", "string"],
                    "pattern": "^variable:",
                    "minItems": 1,
                    "maxItems": 32
                },
                "seed": {
                    "description": "Default seed for the entire step. Accepts a 'variable:' reference.",
                    "type": [
                        "integer",
                        "string"
                    ],
                    "pattern": "^variable:",
                    "format": "int64"
                },
                "release_pipeline": {
                    "description": "Unload this step's pipeline once the step completes, freeing its memory for later steps. A later pipeline_reference to this step is an error, and the REPL's cross-run cache will not retain it.",
                    "type": "boolean"
                },
                "release_models": {
                    "description": "Unload every cached task model once the step completes, freeing their memory for later steps. Task models otherwise stay loaded for the life of the process; set this on a task or sub-workflow step whose model is not needed again, such as a prompt expander running ahead of a generation step. A later step using the same model reloads it.",
                    "type": "boolean"
                },
                "task": {
                    "$ref": "#/$defs/task"
                },
                "pipeline": {
                    "$ref": "#/$defs/pipeline"
                },
                "pipeline_reference": {
                    "$ref": "#/$defs/pipeline_reference"
                },
                "workflow": {
                    "$ref": "#/$defs/workflow_reference"
                },
                "result": {
                    "$ref": "#/$defs/result"
                }
            },
            "oneOf": [
                {
                    "required": [
                        "name",
                        "task"
                    ]
                },
                {
                    "required": [
                        "name",
                        "pipeline"
                    ]
                },
                {
                    "required": [
                        "name",
                        "pipeline_reference"
                    ]
                },
                {
                    "required": [
                        "name",
                        "workflow"
                    ]
                }
            ]
        },
        "arguments": {
            "type": "object",
            "additionalProperties": {
                "description": "null declares an argument that is optional - a workflow can expose a variable a caller may pass without inventing a sentinel value for its absence.",
                "type": [
                    "string",
                    "integer",
                    "number",
                    "object",
                    "array",
                    "boolean",
                    "null"
                ]
            }
        },
        "pipeline_reference": {
            "type": "object",
            "additionalProperties": false,
            "$comment": "Closed - see 'step'.",
            "properties": {
                "reference_name": {
                    "type": "string"
                },
                "chain": {
                    "$ref": "#/$defs/chain"
                },
                "arguments": {
                    "$ref": "#/$defs/arguments"
                }
            },
            "required": [
                "reference_name",
                "arguments"
            ]
        },
        "chain": {
            "description": "Run this pipeline repeatedly, carrying visual continuity from each segment into the next, and stitch the segments into one long video. Specify the length with exactly one of 'segments' or 'match_audio'.",
            "type": "object",
            "properties": {
                "segments": {
                    "description": "Number of segments to generate and stitch. Accepts a 'variable:' reference.",
                    "type": [
                        "integer",
                        "string"
                    ],
                    "minimum": 1
                },
                "match_audio": {
                    "description": "Derive the segment count from the duration of the audio reference in this step's arguments, slicing it into frame-aligned per-segment chunks; the final video is muxed with the original, unsliced audio track.",
                    "type": "boolean"
                },
                "continuity": {
                    "description": "How continuity is carried from one segment into the next. 'last_frame' carries the segment's final frame as the next one's keyframe. 'last_segment' carries the segment itself - its frames and the soundtrack generated with them - as a video reference, which keeps motion, camera and voice across the seam instead of appearance alone; it needs a 'segment_argument' holding a references list.",
                    "type": "string",
                    "enum": [
                        "last_frame",
                        "last_segment"
                    ],
                    "default": "last_frame"
                },
                "segment_argument": {
                    "description": "The pipeline argument the carry-over lands in - e.g. 'image' for image-to-video pipelines, or 'references' for reference-conditioned modular pipelines, where the carry-over is appended as an image or video reference.",
                    "type": "string",
                    "default": "image"
                },
                "carry_frames": {
                    "description": "'last_segment' only - carry just this many frames from the tail of each segment rather than all of them, cutting the reference's soundtrack to the same span. A shorter carry costs less sequence length and memory (MiniMax H3 conditions on reference clips of 2 seconds and up, i.e. 48 frames at its 24 fps). Accepts a 'variable:' reference.",
                    "type": [
                        "integer",
                        "string"
                    ],
                    "minimum": 1
                },
                "carry_audio": {
                    "description": "'last_segment' only - whether the carried video reference brings the soundtrack generated with it, which is what carries a voice across the seam. Turn it off when the segments are already conditioned on a supplied audio track, as in a 'match_audio' chain.",
                    "type": "boolean",
                    "default": true
                },
                "trim_frames": {
                    "description": "Frames removed from the head of every segment after the first (an image-to-video segment reproduces its keyframe as frame 0). Also bounds the audio crossfade window to trim_frames / fps seconds. Accepts a 'variable:' reference.",
                    "type": [
                        "integer",
                        "string"
                    ],
                    "minimum": 0,
                    "default": 1
                },
                "crossfade_ms": {
                    "description": "Equal-power crossfade applied to generated audio at segment boundaries, clamped to the trim_frames / fps window. Accepts a 'variable:' reference.",
                    "type": [
                        "number",
                        "string"
                    ],
                    "minimum": 0,
                    "default": 75
                },
                "fps": {
                    "description": "Frame rate used for the chain's audio math - trimming, crossfading, and match_audio planning. Defaults to the pipeline's 'frame_rate' argument when present; pipelines with a fixed rate (MiniMax H3: 24) need it set here. Accepts a 'variable:' reference.",
                    "type": [
                        "number",
                        "string"
                    ],
                    "exclusiveMinimum": 0
                },
                "frame_snap": {
                    "description": "Constraint the pipeline places on num_frames - counts must equal modulus * n + remainder within the bounds (MiniMax H3: modulus 17, remainder 5, min 124, max 345). Used to snap the final match_audio segment to a valid length. May instead be the string 'constraint:<variable>', naming an entry of the workflow's 'variable_constraints' - so the rule is stated once rather than twice in one file.",
                    "oneOf": [
                        {
                            "type": "object",
                            "properties": {
                                "modulus": {
                                    "type": "integer",
                                    "minimum": 1
                                },
                                "remainder": {
                                    "type": "integer",
                                    "minimum": 0
                                },
                                "min_frames": {
                                    "type": "integer",
                                    "minimum": 1
                                },
                                "max_frames": {
                                    "type": "integer",
                                    "minimum": 1
                                }
                            },
                            "required": [
                                "modulus",
                                "remainder"
                            ],
                            "additionalProperties": false
                        },
                        {
                            "type": "string",
                            "pattern": "^constraint:[a-zA-Z_][a-zA-Z0-9_-]*$"
                        }
                    ]
                },
                "prompts": {
                    "description": "Per-segment prompt overrides; segment i uses prompts[min(i, len(prompts) - 1)].",
                    "type": "array",
                    "items": {
                        "type": "string"
                    },
                    "minItems": 1
                },
                "save_segments": {
                    "description": "Write each completed segment to the output directory as a playable mp4 and free its frames, bounding memory to one segment - a crashed chain leaves the finished segments behind. The final video is streamed from the segment files. Requires PyAV and a frame rate.",
                    "type": "boolean",
                    "default": false
                },
                "keep_segments": {
                    "description": "Leave the segment files in place after the final video is written (default: they are removed once it saves successfully). Only meaningful with save_segments.",
                    "type": "boolean",
                    "default": false
                }
            },
            "oneOf": [
                {
                    "required": [
                        "segments"
                    ]
                },
                {
                    "required": [
                        "match_audio"
                    ]
                }
            ],
            "additionalProperties": false
        },
        "pipeline": {
            "type": "object",
            "properties": {
                "configuration": {
                    "$ref": "#/$defs/pipeline_configuration"
                },
                "shared_components": {
                    "$ref": "#/$defs/shared_components"
                },
                "reused_components": {
                    "$ref": "#/$defs/reused_components"
                },
                "scheduler": {
                    "$ref": "#/$defs/scheduler"
                },
                "audio_scheduler": {
                    "$ref": "#/$defs/scheduler"
                },
                "model": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "transformer": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "transformer_2": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "vae": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "unet": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "text_encoder": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "text_encoder_2": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "text_encoder_3": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "tokenizer": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "tokenizer_2": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "tokenizer_3": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "image_encoder": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "feature_extractor": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "prompt_enhancer_head": {
                    "$ref": "#/$defs/pipeline_component"
                },
                "controlnet": {
                    "$ref": "#/$defs/controlnet"
                },
                "loras": {
                    "type": "array",
                    "items": {
                        "$ref": "#/$defs/lora"
                    }
                },
                "ip_adapter": {
                    "$ref": "#/$defs/ip_adapter"
                },
                "from_pretrained_arguments": {
                    "$ref": "#/$defs/from_pretrained_arguments"
                },
                "remote_text_encoder": {
                    "description": "Encode prompts with a remote text-encoder service instead of loading the text encoder locally. The pipeline's text_encoder is set to None, the prompt is POSTed to the service (authenticated with the HuggingFace token), and the returned embeddings are passed to the pipeline as prompt_embeds. Mutually exclusive with prompt_weighting.",
                    "type": "object",
                    "properties": {
                        "url": {
                            "description": "URL of the remote text encoder endpoint, e.g. a HuggingFace inference endpoint.",
                            "type": "string"
                        }
                    },
                    "required": [
                        "url"
                    ]
                },
                "seed": {
                    "description": "The seed for this pipeline. Accepts a 'variable:' reference.",
                    "type": [
                        "integer",
                        "string"
                    ],
                    "pattern": "^variable:",
                    "format": "int64"
                },
                "chain": {
                    "$ref": "#/$defs/chain"
                },
                "arguments": {
                    "$ref": "#/$defs/arguments"
                }
            },
            "additionalProperties": {
                "description": "Any other key names a pipeline component to load. Diffusers grows component names faster than this schema does, so a key whose value is a component definition - an object carrying 'from_pretrained_arguments' - is loaded under that name. Anything else is a mistyped or misplaced key and is refused rather than ignored.",
                "unknownPropertyMessage": "the engine reads the properties this object declares, plus any other key whose value is a component definition (an object carrying 'from_pretrained_arguments') - anything else would be silently ignored",
                "type": "object",
                "required": [
                    "from_pretrained_arguments"
                ],
                "allOf": [
                    {
                        "$ref": "#/$defs/pipeline_component"
                    }
                ]
            },
            "required": [
                "configuration",
                "from_pretrained_arguments",
                "arguments"
            ]
        },
        "pipeline_configuration": {
            "type": "object",
            "properties": {
                "offload": {
                    "type": "string",
                    "enum": [
                        "model",
                        "sequential"
                    ]
                },
                "exclude_from_cpu_offload": {
                    "description": "Component names (e.g. 'vae', 'text_encoder') to keep resident on the accelerator instead of offloading. Only applies when offload is 'sequential'.",
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "group_offload": {
                    "$ref": "#/$defs/group_offload"
                },
                "device": {
                    "description": "The device to run this pipeline on, e.g. 'cuda', 'cuda:1', 'mps' or 'cpu'. Defaults to the device dw is running on and becomes the default for this pipeline's components. A backend this machine does not have is translated to the one it does, with a warning, so a workflow written on a CUDA box runs on a Mac and back again - the index is dropped in that translation. A 'cpu' device is never translated.",
                    "type": "string"
                },
                "component_type": {
                    "description": "The python type of pipeline to use in the format 'module.typename' module defaults to diffusers",
                    "type": "string"
                },
                "no_generator": {
                    "description": "Whether to use a generator for the pipeline. Some pipelines do not support generators.",
                    "type": "boolean"
                },
                "enable_attention_slicing": {
                    "description": "Whether to enable attention slicing for the pipeline to reduce memory usage.",
                    "type": "boolean"
                },
                "disable_attention_slicing": {
                    "description": "Whether to disable automatic attention slicing on MPS devices. Attention slicing is enabled by default on MPS to reduce memory usage.",
                    "type": "boolean"
                },
                "attention_backend": {
                    "description": "The attention backend to use for the pipeline.",
                    "type": "string"
                },
                "prompt_weighting": {
                    "description": "Enable A1111-style prompt weighting syntax: (word:1.5) for emphasis, [word] for de-emphasis, ((word)) for nested weighting. Also supports prompts longer than 77 tokens. Currently supports Flux pipelines. Mutually exclusive with remote_text_encoder.",
                    "type": "boolean"
                },
                "pre_load_modules": {
                    "description": "List of Python modules to import before loading the pipeline. Used for modules that register with diffusers on import (e.g., sdnq).",
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "load_components": {
                    "description": "Arguments passed to a modular pipeline's load_components() - modular pipelines load their component weights separately from their config. Use 'dtype' to set the component dtype and 'names' to load a subset of components.",
                    "type": "object",
                    "properties": {
                        "names": {
                            "description": "Names of the components to load. All components are loaded when omitted.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "dtype": {
                            "description": "The torch dtype to load components in, e.g. 'torch.bfloat16'",
                            "type": "string"
                        },
                        "quantization_config": {
                            "description": "Quantization configuration per component, keyed by component name (e.g. 'transformer', 'text_encoder'). A component not named here loads unquantized.",
                            "type": "object",
                            "additionalProperties": {
                                "$ref": "#/$defs/quantization_config"
                            }
                        }
                    }
                },
                "configs": {
                    "description": "Values a modular pipeline's blocks declare and read while they run - not components, and not call arguments. Keys are whatever the pipeline itself declares, so what may be set here depends on the model: MiniMax-H3 declares 'canvas_short_edge', 'canvas_max_pixels' and 'reference_image_short_edge'. A name the pipeline does not declare is an error rather than a setting that quietly did nothing.",
                    "type": "object",
                    "additionalProperties": {
                        "type": [
                            "string",
                            "integer",
                            "number",
                            "boolean",
                            "array",
                            "null"
                        ]
                    }
                },
                "components": {
                    "description": "Configuration applied to components once the pipeline has loaded them. This is where a modular pipeline's components are placed, since it pulls their weights itself. Keys name a component, optionally as a dotted path into one, e.g. 'text_encoder.model'.",
                    "type": "object",
                    "additionalProperties": {
                        "type": "object",
                        "properties": {
                            "group_offload": {
                                "$ref": "#/$defs/group_offload"
                            },
                            "device": {
                                "description": "The device to move this component to, e.g. 'cuda'. Only for components small enough to stay resident - the offloaded ones are placed by their own hooks.",
                                "type": "string"
                            },
                            "residency": {
                                "description": "Whether the component stays on its device for the whole run ('resident', the default) or rests in system memory and is moved to the device only while one of its own calls runs ('on_demand'). Use on_demand for a component that is large but called a handful of times, like a VAE that only encodes references and decodes the result - it frees the device for the rest of the run and, unlike group_offload, moves the model whole, so a tiled decode costs one pair of transfers rather than one per tile. Not for a component called every step, and cannot be combined with group_offload.",
                                "type": "string",
                                "enum": [
                                    "resident",
                                    "on_demand"
                                ]
                            },
                            "enable_tiling": {
                                "description": "Enable tiled decoding on this component, for a decoder that is not the one named 'vae' (which the pipeline-level 'vae' block covers) - LTX-2.5's 'diffusion_decoder', say, which otherwise decodes the whole video volume in one allocation. 'true' uses the model's own default tile size; an object passes tile and stride sizes through to enable_tiling(), which is what a card smaller than those defaults needs.",
                                "type": [
                                    "boolean",
                                    "object"
                                ]
                            },
                            "attention_backend": {
                                "description": "Pin this component's attention backend persistently via set_attention_backend, e.g. 'flash', 'sage', '_flash_3_hub'. Use this instead of the pipeline-level attention_backend when the component is compiled - the per-call context manager forces recompiles.",
                                "type": "string"
                            },
                            "attn_processor_type": {
                                "description": "The attention processor this component runs, by type name, constructed with no arguments and handed to set_attn_processor(). The pipeline-level 'unet' and 'transformer' blocks cover those two components; this covers any other one that carries attention - LTX-2.5's 'diffusion_decoder', whose default processor is a portable FlexAttention fallback rather than the NATTEN path the decoder was built around.",
                                "type": "string"
                            },
                            "truncate_layers": {
                                "description": "Drop the tail of a ModuleList inside this component that the run never reads, before any offload hooks are installed. Keys are dotted paths relative to the component, values the number of entries to keep. For an encoder used for its hidden states: MiniMax-H3 conditions on hidden_states[50] of its 64-layer Qwen3-VL, so { 'language_model.layers': 51 } drops the 13 layers whose output nothing consumes while leaving hidden_states[50] bit-identical (keeping only 50 would hand back the final-norm output instead, a different tensor).",
                                "type": "object",
                                "additionalProperties": {
                                    "type": "integer",
                                    "minimum": 1
                                }
                            },
                            "remove_modules": {
                                "description": "Dotted paths to modules inside this component that the run never calls, each replaced with an Identity before any offload hooks are installed - a language-model head on a model used as an encoder, say. The attribute survives for anything that looks it up; the weights are freed rather than held (and, offloaded, pinned) for a call that never comes.",
                                "type": "array",
                                "items": {
                                    "type": "string"
                                }
                            },
                            "compile": {
                                "$ref": "#/$defs/compile_config"
                            }
                        }
                    }
                },
                "preserve_device_placement": {
                    "description": "Whether to leave the component where it loaded rather than moving it to the device. Needed when the component is loaded already placed - by a 'device_map', or by a quantization that pins its tensors to one device. A 'components' block that group offloads already keeps the pipeline off the device on its own. Renamed from 'do_not_send_to_device', which is no longer recognized.",
                    "type": "boolean"
                },
                "components_manager": {
                    "description": "Attach a ComponentsManager to a modular pipeline. The manager tracks the pipeline's components and, with auto CPU offload enabled, keeps only the running ones on the device. It replaces 'offload', which modular pipelines do not support.",
                    "type": "object",
                    "properties": {
                        "enable_auto_cpu_offload": {
                            "description": "Move components between the device and system memory as the pipeline runs. Requires a device that reports free memory (CUDA). When enabled the manager owns device placement, so the pipeline is not moved to the device directly.",
                            "type": "boolean",
                            "default": false
                        },
                        "memory_reserve_margin": {
                            "description": "Device memory to keep free when deciding what to offload, e.g. '3GB'",
                            "type": "string",
                            "default": "3GB"
                        }
                    }
                },
                "sdnq_optimize": {
                    "description": "List of pipeline component names to apply SDNQ quantized matmul optimization to (e.g., ['transformer', 'text_encoder']). Requires sdnq package and CUDA/XPU hardware.",
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "cache": {
                    "description": "Enable diffusers built-in cache acceleration on the transformer. Mutually exclusive with teacache. Hooks auto-reset between inference runs.",
                    "type": "object",
                    "properties": {
                        "type": {
                            "description": "Cache algorithm: first_block (simplest, broadest support), faster (video-oriented, experimental), mag (magnitude-based, needs num_inference_steps), taylorseer (Taylor series approximation), text_kv (text key-value cache).",
                            "type": "string",
                            "enum": [
                                "first_block",
                                "faster",
                                "mag",
                                "taylorseer",
                                "text_kv"
                            ]
                        },
                        "threshold": {
                            "description": "Cache threshold for first_block and mag types. Higher = more speedup, more quality loss. first_block default: 0.05, mag default: 0.06. Accepts a 'variable:' reference.",
                            "type": [
                                "number",
                                "string"
                            ]
                        },
                        "num_inference_steps": {
                            "description": "Required for mag cache type. Must match the pipeline's num_inference_steps.",
                            "type": "integer"
                        },
                        "max_skip_steps": {
                            "description": "Max consecutive skippable steps for mag cache. Default: 3.",
                            "type": "integer"
                        },
                        "retention_ratio": {
                            "description": "Fraction of initial steps where skipping is disabled for mag cache. Default: 0.2.",
                            "type": "number"
                        },
                        "mag_ratios": {
                            "description": "Per-step magnitude ratios for mag cache. Required unless calibrate is true, and checkpoint-dependent. Either a preset name shipped by diffusers ('flux') or an explicit array of per-step ratios. Interpolated automatically when its length differs from num_inference_steps.",
                            "oneOf": [
                                {
                                    "type": "string"
                                },
                                {
                                    "type": "array",
                                    "items": {
                                        "type": "number"
                                    }
                                }
                            ]
                        },
                        "calibrate": {
                            "description": "Run mag cache in calibration mode: skip nothing, and log the magnitude ratios for this model at the end of the run so they can be pasted into mag_ratios. Default: false.",
                            "type": "boolean"
                        },
                        "cache_interval": {
                            "description": "Full computation every N steps for taylorseer cache. Default: 5.",
                            "type": "integer"
                        },
                        "max_order": {
                            "description": "Taylor series order for taylorseer cache. Higher = better approximation, more memory. Default: 1.",
                            "type": "integer"
                        }
                    },
                    "required": [
                        "type"
                    ]
                },
                "teacache": {
                    "description": "Enable TeaCache inference acceleration. Auto-detects transformer type. Caches intermediate computations and skips redundant steps. Requires num_inference_steps in pipeline arguments. Currently supports FluxTransformer2DModel. Mutually exclusive with cache.",
                    "type": "object",
                    "properties": {
                        "rel_l1_thresh": {
                            "description": "Cache threshold. Higher = more speedup, more quality loss. Model-specific defaults apply if omitted.",
                            "type": "number"
                        },
                        "coefficients": {
                            "description": "Polynomial coefficients for rescaling relative L1 distance. 5 floats for np.poly1d. If omitted, uses model-specific defaults.",
                            "type": "array",
                            "items": {
                                "type": "number"
                            },
                            "minItems": 5,
                            "maxItems": 5
                        },
                        "variant": {
                            "description": "Explicit model variant from teacache_models.json. Required for models with multiple variants (e.g., 'cogvideox_2b', 'wan2.1_t2v_1.3b'). If omitted, uses the class default.",
                            "type": "string"
                        }
                    }
                },
                "vae": {
                    "type": "object",
                    "properties": {
                        "enable_slicing": {
                            "description": "Decode the latent batch one sample at a time rather than all at once - the answer to a decode that runs out of memory on a batch the denoise itself fitted. Costs nothing but the loss of batched decode parallelism.",
                            "type": "boolean"
                        },
                        "enable_tiling": {
                            "description": "Decode in tiles rather than in one allocation, for a single sample too large to decode whole - a long or high-resolution video, where the peak is the decode rather than the denoise. Combines with 'enable_slicing'.",
                            "type": "boolean"
                        },
                        "channels_last": {
                            "type": "boolean"
                        },
                        "torch_dtype": {
                            "type": "string"
                        }
                    }
                },
                "unet": {
                    "type": "object",
                    "properties": {
                        "enable_forward_chunking": {
                            "type": "boolean"
                        },
                        "channels_last": {
                            "type": "boolean"
                        },
                        "torch_dtype": {
                            "type": "string"
                        },
                        "attn_processor_type": {
                            "type": "string"
                        }
                    }
                },
                "transformer": {
                    "type": "object",
                    "properties": {
                        "attn_processor_type": {
                            "description": "The type name of an attention processor",
                            "type": "string"
                        }
                    }
                },
                "text_encoder": {
                    "type": "object",
                    "properties": {
                        "torch_dtype": {
                            "type": "string"
                        }
                    }
                },
                "shared_components": {
                    "$ref": "#/$defs/shared_components"
                },
                "reused_components": {
                    "$ref": "#/$defs/reused_components"
                },
                "enable_layerwise_casting": {
                    "$ref": "#/$defs/enable_layerwise_casting"
                },
                "inversion": {
                    "description": "Run the pipeline's invert() rather than the pipeline itself, returning the inverted latents. Only for pipelines that have one.",
                    "type": "boolean"
                },
                "generate": {
                    "description": "Run the pipeline's generate() rather than the pipeline itself, returning the generated ids. Only for pipelines that have one, such as a conditioner used on its own.",
                    "type": "boolean"
                }
            },
            "additionalProperties": false,
            "required": [
                "component_type"
            ]
        },
        "shared_components": {
            "description": "The names of components this step loads and later steps may reuse. A modular pipeline is given them after it is built, so the components it shares are the ones it actually loaded.",
            "type": "array",
            "items": {
                "type": "string"
            }
        },
        "reused_components": {
            "description": "The names of components an earlier step shared, reused here instead of being loaded again. A reused component keeps the device placement the step that shared it gave it.",
            "type": "array",
            "items": {
                "type": "string"
            }
        },
        "scheduler": {
            "type": "object",
            "properties": {
                "configuration": {
                    "type": "object",
                    "properties": {
                        "scheduler_type": {
                            "type": "string"
                        }
                    },
                    "required": [
                        "scheduler_type"
                    ]
                },
                "from_config_args": {
                    "$ref": "#/$defs/arguments"
                },
                "shift": {
                    "description": "Exponential sigma shift applied to this scheduler's schedule, for schedulers that take one (MiniMax H3: 12.0 for video, 3.0 for audio in the released checkpoint). Lower it when running few steps - a high shift packs the whole grid near sigma 1 and leaves one enormous final step, which a short schedule cannot absorb. Accepts a 'variable:' reference.",
                    "type": [
                        "number",
                        "string"
                    ],
                    "exclusiveMinimum": 0
                }
            },
            "anyOf": [
                {
                    "required": [
                        "configuration"
                    ]
                },
                {
                    "required": [
                        "shift"
                    ]
                }
            ]
        },
        "pipeline_component": {
            "type": "object",
            "properties": {
                "configuration": {
                    "type": "object",
                    "properties": {
                        "device": {
                            "description": "The device to load this component onto, e.g. 'cuda', 'cuda:1', 'mps' or 'cpu'. Defaults to the device its pipeline runs on. A backend this machine does not have is translated to the one it does, with a warning.",
                            "type": "string"
                        },
                        "component_type": {
                            "description": "The python type of pipeline component to use in the format 'module.typename' module defaults to diffusers",
                            "type": "string"
                        }
                    },
                    "required": [
                        "component_type"
                    ]
                },
                "group_offload": {
                    "$ref": "#/$defs/group_offload"
                },
                "enable_layerwise_casting": {
                    "$ref": "#/$defs/enable_layerwise_casting"
                },
                "quantization_config": {
                    "$ref": "#/$defs/quantization_config"
                },
                "from_pretrained_arguments": {
                    "$ref": "#/$defs/from_pretrained_arguments"
                }
            },
            "required": [
                "configuration",
                "from_pretrained_arguments"
            ]
        },
        "quantization_config": {
            "type": "object",
            "properties": {
                "configuration": {
                    "type": "object",
                    "properties": {
                        "config_type": {
                            "type": "string"
                        }
                    },
                    "required": [
                        "config_type"
                    ]
                },
                "arguments": {
                    "$ref": "#/$defs/arguments"
                }
            },
            "required": [
                "configuration",
                "arguments"
            ]
        },
        "controlnet": {
            "type": "object",
            "properties": {
                "configuration": {
                    "$ref": "#/$defs/pipeline_configuration"
                },
                "from_pretrained_arguments": {
                    "$ref": "#/$defs/from_pretrained_arguments"
                }
            },
            "required": [
                "configuration",
                "from_pretrained_arguments"
            ]
        },
        "ip_adapter": {
            "type": "object",
            "properties": {
                "model_name": {
                    "description": "The huggingface hub name of the ip adadapter model to use.",
                    "type": "string"
                },
                "weight_name": {
                    "description": "The file name of the ip adapter weights.",
                    "type": "string"
                },
                "subfolder": {
                    "description": "The subfolder location of a model file within a larger model repository",
                    "type": [
                        "string",
                        "null"
                    ]
                },
                "scale": {
                    "description": "The scale factor of the ip adapter.",
                    "type": "number",
                    "format": "float"
                }
            },
            "required": [
                "model_name"
            ]
        },
        "lora": {
            "type": "object",
            "properties": {
                "model_name": {
                    "description": "The huggingface hub name of the lora.",
                    "type": "string"
                },
                "weight_name": {
                    "description": "The file name of the lora weights.",
                    "type": "string"
                },
                "subfolder": {
                    "description": "The subfolder location of a model file within a larger model repository",
                    "type": "string"
                },
                "scale": {
                    "description": "The scale factor of the lora when fusing. Accepts a 'variable:' reference.",
                    "type": [
                        "number",
                        "string"
                    ],
                    "format": "float"
                },
                "alpha": {
                    "description": "The network alpha to scale this lora by, overriding the one its checkpoint declares. peft scales an adapter by 'scale * alpha / rank', taking alpha from the file - a per-module '.alpha' tensor, else a '__metadata__' alpha where the loader honors one, else the rank itself. State it where the checkpoint's own figure is not the one it is meant to run at: the 768p MiniMax-H3 turbo LoRAs record alpha 8 at rank 128 while upstream runs them at 128. Accepts a 'variable:' reference.",
                    "type": [
                        "number",
                        "string",
                        "null"
                    ],
                    "exclusiveMinimum": 0
                },
                "adapter_name": {
                    "description": "The user defined name of the adapter to pass to set_adapters function",
                    "type": "string"
                }
            },
            "required": [
                "model_name"
            ]
        },
        "from_pretrained_arguments": {
            "type": "object",
            "description": "Arguments to pass to the from_pretrained function when creating the component. Names at most one source: 'model_name', 'from_single_file' or 'task'. A pipeline assembled entirely from components an earlier step shared and components declared beside it - LTX-2's latent upsampler, say - names none of them and is constructed directly from those components.",
            "properties": {
                "model_name": {
                    "description": "The huggingface hub name of the pretrained model to load",
                    "type": "string"
                },
                "from_single_file": {
                    "description": "Location of a checkpoint model from a single file",
                    "type": "string"
                },
                "task": {
                    "description": "The name of a task that transformers.Pipeline understands",
                    "type": "string"
                }
            },
            "additionalProperties": {
                "type": [
                    "string",
                    "number",
                    "object",
                    "array",
                    "boolean",
                    "null"
                ]
            },
            "oneOf": [
                {
                    "required": [
                        "model_name"
                    ]
                },
                {
                    "required": [
                        "from_single_file"
                    ]
                },
                {
                    "required": [
                        "task"
                    ]
                },
                {
                    "allOf": [
                        {
                            "not": {
                                "required": [
                                    "model_name"
                                ]
                            }
                        },
                        {
                            "not": {
                                "required": [
                                    "from_single_file"
                                ]
                            }
                        },
                        {
                            "not": {
                                "required": [
                                    "task"
                                ]
                            }
                        }
                    ]
                }
            ]
        },
        "task": {
            "type": "object",
            "additionalProperties": false,
            "$comment": "Closed - see 'step'. A task's own arguments are open; it is the task object itself that is fixed.",
            "properties": {
                "command": {
                    "type": "string"
                },
                "arguments": {
                    "$ref": "#/$defs/arguments"
                },
                "inputs": {
                    "type": "array",
                    "items": {
                        "type": [
                            "string",
                            "integer",
                            "number",
                            "object",
                            "boolean"
                        ]
                    }
                }
            },
            "oneOf": [
                {
                    "required": [
                        "command",
                        "arguments"
                    ]
                },
                {
                    "required": [
                        "command",
                        "inputs"
                    ]
                }
            ]
        },
        "workflow_reference": {
            "type": "object",
            "additionalProperties": false,
            "$comment": "Closed - see 'step'.",
            "properties": {
                "path": {
                    "description": "The workflow this step composes: a catalog name as list_workflows reports it (with or without '.json'), a path relative to the workflow that names it ('../models/x.json'), or 'builtin:name.json' for one of the packaged fragments. A name is resolved first beside the referencing file, then against this run's own workflows directory, then against each read-only source on the server's search path - so a stored template can be composed without copying it into the workspace. A path outside every source is refused. When the composing step declares a 'result', that is where the composed output is saved and the composed workflow's own last step does not save it again.",
                    "type": "string"
                },
                "arguments": {
                    "$ref": "#/$defs/arguments"
                }
            }
        },
        "result": {
            "type": "object",
            "properties": {
                "content_type": {
                    "description": "The content type of the result when serialized to disk. Audio can be written as 'audio/wav', 'audio/flac', 'audio/mpeg' (mp3), 'audio/ogg' or 'audio/opus'. Opus is written into an ogg container and only encodes sample rates of 8000, 12000, 16000, 24000 or 48000.",
                    "type": "string"
                },
                "save": {
                    "description": "Whether to save the result",
                    "type": "boolean",
                    "default": true
                },
                "file_base_name": {
                    "description": "The base name for saving result and metadata files. It replaces the name the engine would derive from the workflow and step - it is not a prefix on one - so a caller that sets it can predict the file name. That derived name is what makes two steps' files distinct, so give each step that sets one a different value, or the second collides and gets a '-2' counter. A name, not a path - it may not contain a separator; to place a step's files in a subfolder of the run directory set 'subfolder'. The file extension is determined by context and content_type.",
                    "type": "string"
                },
                "subfolder": {
                    "description": "A subfolder of the run directory this step's files are written into, as a relative path like 'final' or 'shots/act-1'. Optional: without it the files land at the root of the run directory as they always have. By convention a step whose output the user will be shown is 'final' and everything else is 'intermediate', which is how a consumer tells the deliverable from the scratch files without knowing the workflow; the engine treats no name specially. May be a 'variable:' or, inside a for_each step, an 'item:' reference. Each segment must start with a letter, digit or underscore; '..' and '\\' are refused.",
                    "type": "string"
                },
                "fps": {
                    "description": "Frames per second - only used when output is video. Defaults to the rate the frames themselves carry (a chain's 'fps', a join's own rate, the rate of the file a task read) and to 8 only when nothing knows better. Set it to write at a rate other than the source's - a deliberate slow motion - which the run then warns about.",
                    "type": "integer",
                    "default": 8
                },
                "sample_rate": {
                    "description": "Audio sample rate - only used when output is audio",
                    "type": "integer",
                    "default": 44100
                },
                "audio_sample_rate": {
                    "description": "Sample rate of the audio generated with a video, muxed into 'video/mp4' output. Defaults to the rate reported by the pipeline's vocoder - only set this to override it.",
                    "type": "integer"
                },
                "subtype": {
                    "description": "Audio encoding subtype, e.g. 'PCM_24' for wav and flac or 'VORBIS' for ogg. Defaults to the container's own default ('PCM_16' for wav and flac). Only used when output is audio.",
                    "type": "string"
                },
                "compression_level": {
                    "description": "Encoding compression level from 0.0 to 1.0 for compressed audio formats (flac, mp3, ogg). Higher means smaller files. Only used when output is audio.",
                    "type": "number",
                    "minimum": 0,
                    "maximum": 1
                },
                "bitrate_mode": {
                    "description": "Bitrate mode for compressed audio formats: 'CONSTANT', 'AVERAGE' or 'VARIABLE'. Only used when output is audio.",
                    "type": "string",
                    "enum": [
                        "CONSTANT",
                        "AVERAGE",
                        "VARIABLE"
                    ]
                },
                "embed_metadata": {
                    "description": "Whether to embed generation parameters as metadata in saved images (PNG info chunks or EXIF). Only applies to image content types.",
                    "type": "boolean",
                    "default": false
                },
                "format": {
                    "description": "Audio container format handed to the writer, e.g. 'WAV' or 'FLAC'. Derived from content_type unless set. Only used when output is audio.",
                    "type": "string"
                }
            },
            "additionalProperties": false,
            "required": [
                "content_type"
            ]
        },
        "enable_layerwise_casting": {
            "type": "object",
            "properties": {
                "storage_dtype": {
                    "type": "string"
                },
                "compute_dtype": {
                    "type": "string"
                }
            },
            "required": [
                "storage_dtype",
                "compute_dtype"
            ]
        },
        "group_offload": {
            "description": "Stream a model between system memory and the accelerator a group of layers at a time. Anything beyond the keys named here is passed through to apply_group_offloading, e.g. 'use_stream', 'num_blocks_per_group', 'low_cpu_mem_usage', 'offload_to_disk_path'.",
            "type": "object",
            "properties": {
                "onload_device": {
                    "type": "string"
                },
                "offload_device": {
                    "type": "string",
                    "default": "cpu"
                },
                "offload_type": {
                    "type": "string"
                }
            },
            "additionalProperties": true,
            "required": [
                "offload_type"
            ]
        },
        "compile_config": {
            "description": "Compile the component with torch.compile once it is fully configured. Best paired with a pinned attention_backend - the per-call context manager forces recompiles.",
            "type": "object",
            "properties": {
                "mode": {
                    "description": "torch.compile mode, e.g. 'default', 'reduce-overhead', 'max-autotune'.",
                    "type": "string"
                },
                "fullgraph": {
                    "description": "Require a single graph with no breaks. Fails fast on graph breaks instead of silently losing speedup.",
                    "type": "boolean"
                },
                "dynamic": {
                    "description": "Compile with dynamic shapes. Set true when resolutions or frame counts vary between runs to avoid recompiles.",
                    "type": "boolean"
                },
                "repeated_blocks": {
                    "description": "Compile only the model's repeated block classes (diffusers regional compilation) - near the same speedup as full compilation with a fraction of the cold-start cost.",
                    "type": "boolean"
                }
            }
        }
    }
}