smartbotic/nodes/sdcpp/sdcpp-txt2vid.js

/**
 * @node sdcpp-txt2vid
 * @name SD.cpp Text to Video
 * @category sdcpp
 * @version 1.0.0
 * @description Queue a video generation, for video models such as Wan, LTXAV and HunyuanVideo
 * @icon clapperboard
 */

// The credential this node wants, named so it can be found. It is stored as a
// plain basic credential - that is what decides how it is encrypted - and this
// only says which basic credential is the SD.cpp one. Anything that accepts a
// basic credential still accepts this, and this node still accepts a plain
// basic credential, because the shape is identical.
const credentialTypes = [
    {
        id: 'sdcpp',
        label: 'SD.cpp Server',
        baseType: 'basic',
        description: 'The username and password you sign in to sdcpp-restapi with. The node exchanges them for a token before every call',
        usernameLabel: 'Username',
        passwordLabel: 'Password'
    }
];

const configSchema = {
    type: 'object',
    // Generated from the server's own reference at /options/generation - see
    // scripts/gen-sdcpp-generation-options.py. Every field the endpoint accepts
    // has a setting here, grouped the way the server groups them.
    uiGroups: [
            {
                    "title": "Server",
                    "fields": [
                            "serverUrl",
                            "credentialId"
                    ]
            },
            {
                    "title": "Core",
                    "fields": [
                            "prompt",
                            "negativePrompt",
                            "width",
                            "height",
                            "steps",
                            "cfgScale",
                            "seed",
                            "sampler",
                            "scheduler"
                    ]
            },
            {
                    "title": "Cache Acceleration",
                    "fields": [
                            "cacheMode",
                            "spectrumW",
                            "spectrumM",
                            "spectrumLam",
                            "spectrumWindowSize",
                            "spectrumFlexWindow",
                            "spectrumWarmupSteps",
                            "spectrumStopPercent"
                    ]
            },
            {
                    "title": "Prompt Expansion",
                    "fields": [
                            "expandPrompt"
                    ]
            },
            {
                    "title": "Guidance",
                    "fields": [
                            "distilledGuidance",
                            "eta",
                            "shiftedTimestep",
                            "flowShift",
                            "clipSkip"
                    ]
            },
            {
                    "title": "Image Input (img2img / image-edit)",
                    "fields": [
                            "initImageBase64",
                            "strength",
                            "ipAdapterImageBase64",
                            "ipAdapterStrength"
                    ]
            },
            {
                    "title": "Skip Layer Guidance (SLG)",
                    "fields": [
                            "slgScale",
                            "skipLayers",
                            "slgStart",
                            "slgEnd",
                            "customSigmas"
                    ]
            },
            {
                    "title": "VAE Tiling (per-generation)",
                    "fields": [
                            "vaeTiling",
                            "vaeTileSizeX",
                            "vaeTileSizeY",
                            "vaeTileOverlap"
                    ]
            },
            {
                    "title": "Video (Wan)",
                    "fields": [
                            "videoFrames",
                            "fps",
                            "highNoiseSteps",
                            "highNoiseCfgScale",
                            "highNoiseDistilledGuidance",
                            "highNoiseSampler",
                            "highNoiseSlgScale",
                            "highNoiseSkipLayers",
                            "highNoiseSlgStart",
                            "highNoiseSlgEnd",
                            "moeBoundary",
                            "endImageBase64",
                            "controlFrames",
                            "vaceStrength",
                            "refAudios",
                            "refVideos"
                    ]
            },
            {
                    "title": "Job",
                    "fields": [
                            "title",
                            "extraOptions",
                            "timeout"
                    ]
            }
    ],
    prefill: {
            "label": "Take the architecture defaults",
            "description": "Fill these in from the preset for whichever model the server has loaded - the same values it would use if these were left empty",
            "node": "sdcpp-architecture",
            "needs": [
                    "serverUrl",
                    "credentialId"
            ],
            "map": {
                    "defaults.width": "width",
                    "defaults.height": "height",
                    "defaults.steps": "steps",
                    "defaults.cfgScale": "cfgScale",
                    "defaults.sampler": "sampler",
                    "defaults.scheduler": "scheduler",
                    "defaults.cacheMode": "cacheMode",
                    "defaults.distilledGuidance": "distilledGuidance",
                    "defaults.flowShift": "flowShift",
                    "defaults.negativePrompt": "negativePrompt",
                    "defaults.videoFrames": "videoFrames",
                    "defaults.fps": "fps"
            }
    },
    properties: {
        serverUrl: {
            type: 'string', title: 'Server URL',
            description: 'Base address of the sdcpp-restapi server',
            default: 'http://localhost:8077'
        },
        credentialId: {
            type: 'string', title: 'Credential',
            description: 'A basic credential holding the sdcpp-restapi username and password',
            dynamicOptions: { source: 'credentials', filter: { type: ['sdcpp', 'basic'] } }
        },
        cacheMode: { title: "Cache Mode", description: "DiT-model intermediate caching strategy. Skips redundant computation across consecutive sampler steps when the model's intermediate state hasn't changed enough to matter. `easycache` is the simplest; `spectrum` is the newest, generally best for Flux/SD3/Z-Image. Recommended: spectrum for Flux/SD3/Z-Image when generation is too slow. Off for SD1.5/SDXL (UNet is too small for caching to win). Leave empty for the architecture default.", type: "string", enum: ["", "off", "easycache", "ucache", "dbcache", "taylorseer", "cache_dit", "spectrum"], enumLabels: ["(architecture default, which may switch it on)", "Off - no caching, whatever the architecture prefers", "EasyCache - single threshold, simple", "UCache", "DBCache", "TaylorSeer", "Cache-DiT", "Spectrum - frequency-domain analysis (best quality/speed tradeoff)"], default: "" },
        cfgScale: { title: "CFG Scale", description: "Classifier-Free Guidance scale. Strength of pushing the cond toward the prompt vs the uncond. Higher = follows prompt more aggressively but can over-saturate. Set to 1.0 to disable CFG (skips the uncond pass - twice as fast). Recommended: SD1.5: 7. SDXL: 4-8. Flux Dev: 1 (CFG bypassed in flow models). Z-Image: 1. Schnell/Turbo: 1. Leave empty for the architecture default.", type: "number" },
        clipSkip: { title: "CLIP Skip", description: "Skip the last N layers of CLIP when encoding the prompt. -1 = use the model's recommended default. 2 is the classic anime-model setting. Recommended: -1 (auto). Set to 2 for anime/cartoon SD1.5 fine-tunes. Leave empty for the architecture default.", type: "number" },
        controlFrames: { title: "ControlNet Frames", description: "Per-frame control images for video generation. Length should match `video_frames` for full coverage. Recommended: Empty unless using video-ControlNet. Leave empty for the architecture default.", type: "array", items: {"type": "string"} },
        customSigmas: { title: "Custom Sigma Schedule", description: "Replace the scheduler's noise sigma sequence with a hand-tuned one. Bypasses `scheduler`. Empty array = use the chosen scheduler. Recommended: Empty unless you're hand-tuning per-step noise levels - niche. Leave empty for the architecture default.", type: "array", items: {"type": "number"} },
        distilledGuidance: { title: "Distilled Guidance", description: "Distilled-CFG scale for models that bake the CFG behavior into the diffusion model itself (Flux). Replaces the runtime CFG split. Recommended: Flux Dev: 3.5 (sd.cpp default). Other architectures: ignored. Leave empty for the architecture default.", type: "number" },
        endImageBase64: { title: "End Image (base64)", description: "Optional final-frame target for Wan 2.2 - forces the video to end on this image. Lets you bridge two stills with generated motion. Recommended: Empty unless doing image-to-image-bridged video. Leave empty for the architecture default.", type: "string" },
        eta: { title: "Eta", description: "Stochasticity parameter for DDIM-family samplers. 0 = deterministic, 1 = max stochasticity (matches DDPM noise schedule). Most other samplers ignore this. Recommended: 0 (deterministic, reproducible). Raise only with DDIM-trailing for some variation. Leave empty for the architecture default.", type: "number" },
        expandPrompt: { title: "Expand Prompt Template", description: "If true, parse `prompt` for a1111-style dynamic-prompts syntax (`{a|b|c}`, `{N$$a|b|c}`) and create one queue item per variation. The response then carries `group_id` + `variation_count` + `job_ids[]` instead of a single `job_id`. Hard cap: 200 variations per request. Recommended: Enable when your prompt actually contains `{…}` syntax. Leave empty for the architecture default.", type: "boolean" },
        flowShift: { title: "Flow Shift", description: "Per-generation flow-matching shift parameter for Flux / SD3 / Z-Image models. Higher values shift sampling toward larger noise levels longer. Per-call override; the load-time `flow_shift` is the default if this isn't set. Recommended: Flux Dev: 1.0. Z-Image: 3.0. SD3 Medium: 3.0. Leave empty for the architecture default.", type: "number" },
        fps: { title: "Output FPS", description: "Frames per second baked into the resulting MP4. Doesn't affect generation, just the encoded video's playback rate. Recommended: 16 for Wan 2.x. Leave empty for the architecture default.", type: "number" },
        height: { title: "Height (px)", description: "Output image height in pixels. Same divisibility constraint as `width`. Recommended: Match training resolution. For non-square: total pixel count close to native is more important than aspect ratio. Leave empty for the architecture default.", type: "number" },
        highNoiseCfgScale: { title: "High-noise CFG (MoE)", description: "CFG scale used during the high-noise expert phase of Wan 2.2 MoE. Recommended: Match `cfg_scale` unless tuning. Leave empty for the architecture default.", type: "number" },
        highNoiseDistilledGuidance: { title: "High-noise Distilled Guidance", description: "Distilled-guidance during the high-noise expert phase (Wan 2.2 MoE). Recommended: Match `distilled_guidance`. Leave empty for the architecture default.", type: "number" },
        highNoiseSampler: { title: "High-noise Sampler", description: "Sampler to use during the high-noise expert phase. Recommended: Empty (= same as `sampler`). Leave empty for the architecture default.", type: "string" },
        highNoiseSkipLayers: { title: "High-noise SLG Skip Layers", description: "SLG skip layers for the high-noise expert phase. Recommended: Empty. Leave empty for the architecture default.", type: "array", items: {"type": "number"} },
        highNoiseSlgEnd: { title: "High-noise SLG End", description: "SLG end fraction during the high-noise phase. Recommended: 0.2. Leave empty for the architecture default.", type: "number" },
        highNoiseSlgScale: { title: "High-noise SLG Scale", description: "SLG scale for the high-noise expert phase. Recommended: 0. Leave empty for the architecture default.", type: "number" },
        highNoiseSlgStart: { title: "High-noise SLG Start", description: "SLG start fraction during the high-noise phase. Recommended: 0.01. Leave empty for the architecture default.", type: "number" },
        highNoiseSteps: { title: "High-noise Steps (MoE)", description: "For Wan 2.2 MoE: how many steps the high-noise expert runs before handing off to the low-noise expert. 0 = let the model decide via `moe_boundary`. Recommended: 0 (auto). Leave empty for the architecture default.", type: "number" },
        initImageBase64: { title: "Init Image (base64)", description: "Base64-encoded source image for img2img / image-edit. Required for /img2img. Recommended: Required for img2img. Leave empty for the architecture default.", type: "string" },
        moeBoundary: { title: "MoE Expert Boundary", description: "For Wan 2.2 MoE: fraction of total steps at which to switch from high-noise to low-noise expert. 0 = use `high_noise_steps` directly. Recommended: 0.875 (Wan 2.2 default). Leave empty for the architecture default.", type: "number" },
        negativePrompt: { title: "Negative Prompt", description: "What to push the model away from. Has effect only when `cfg_scale > 1` (CFG is what compares cond vs uncond). Ignored on architectures that don't use CFG (most flow-matching models default to `cfg_scale = 1`). Recommended: Optional. Empty is a fine default for Flux / SD3 / Z-Image. Leave empty for the architecture default.", type: "string", format: "textarea" },
        prompt: { title: "Prompt", description: "Text prompt fed to the model's text encoder (CLIP / T5 / LLM). Supports inline `<lora:name:weight>` tags - these are auto-extracted into the LoRA list before being sent to the encoder. Supports a1111-style dynamic-prompts (`{a|b|c}`) when `expand_prompt: true` is set. Recommended: Required. Leave empty for the architecture default.", type: "string", format: "textarea" },
        sampler: { title: "Sampler", description: "Sampling algorithm. Different samplers can produce different images at the same seed; quality and speed differ too. Recommended: euler_a (general), dpmpp2m (SD1.5/SDXL), euler (Flux/SD3/Z-Image), lcm (LCM models). Leave empty for the architecture default.", type: "string", enum: ["", "euler", "euler_a", "heun", "dpm2", "dpm++2s_a", "dpm++2m", "dpm++2mv2", "ipndm", "ipndm_v", "lcm", "ddim_trailing", "tcd", "res_multistep", "res_2s", "er_sde", "euler_cfg_pp", "euler_a_cfg_pp", "euler_ge", "dpm++2m_sde", "dpm++2m_sde_bt", "lms"], enumLabels: ["(architecture default)", "Euler - simple, fast, deterministic", "Euler ancestral - adds noise each step (less reproducible, more variet", "Heun - 2nd-order, slower, sometimes higher quality", "DPM2 - 2nd-order, balanced", "dpm++2s_a", "dpm++2m", "dpm++2mv2", "IPNDM", "IPNDM-V", "LCM - for LCM-finetuned models (4-8 step generation)", "DDIM trailing - required for some fine-tunes", "TCD - for TCD-finetuned models", "RES multistep - flow-model variant", "RES 2S", "ER SDE - SDE sampler (added recently)", "euler_cfg_pp", "euler_a_cfg_pp", "euler_ge", "dpm++2m_sde", "dpm++2m_sde_bt", "lms"], default: "" },
        scheduler: { title: "Scheduler", description: "Determines the noise schedule (the timesteps the sampler walks through). Pairs with the sampler - some combinations (e.g. karras+dpmpp2m) are well-tested, others may be off. Recommended: discrete or karras for SD1.5/SDXL; simple for Flux/SD3; smoothstep for Z-Image. Leave empty for the architecture default.", type: "string", enum: ["", "discrete", "karras", "exponential", "ays", "gits", "sgm_uniform", "simple", "smoothstep", "kl_optimal", "lcm", "bong_tangent", "ltx2", "logit_normal", "flux", "flux2", "beta", "normal"], enumLabels: ["(architecture default)", "Discrete - uniform across model timesteps (default)", "Karras - concentrates more steps near the end, common for SDXL", "Exponential", "Align Your Steps (AYS) - auto-tuned", "GITS", "SGM uniform - for SGM-trained models", "Simple - used by Flux / SD3 flow models", "Smoothstep - Z-Image's recommended scheduler", "KL optimal", "LCM - for LCM samplers", "Bong Tangent", "ltx2", "logit_normal", "flux", "flux2", "beta", "normal"], default: "" },
        seed: { title: "Seed", description: "RNG seed for the initial noise tensor (and stochastic samplers). -1 = pick a random one each generation. Same seed + same prompt + same model = same image. Recommended: -1 for variety. Pin a specific number for A/B comparing prompt or sampler changes. Leave empty for the architecture default.", type: "number" },
        shiftedTimestep: { title: "Shifted Timestep", description: "Start the sampling schedule from a non-final timestep (used by NitroFusion and similar fast-sampling fine-tunes). 0 = standard schedule. 250-500 = NitroFusion's range. Recommended: 0 unless you're explicitly running a NitroFusion-style fine-tune. Leave empty for the architecture default.", type: "number" },
        skipLayers: { title: "SLG Skip Layers", description: "Which transformer layers to skip during the SLG unconditional pass. SD3.5 Medium uses [7, 8, 9]. Recommended: [7,8,9] for SD3.5 Medium. Other models: leave default, ignored when slg_scale=0. Leave empty for the architecture default.", type: "array", items: {"type": "number"} },
        slgEnd: { title: "SLG End (% of steps)", description: "Fraction of the sampler schedule at which SLG turns off. Recommended: 0.2 (early-cycle only - late-cycle SLG hurts quality). Leave empty for the architecture default.", type: "number" },
        slgScale: { title: "SLG Scale", description: "Skip Layer Guidance scale. Selectively zeros out a few diffusion layers when computing the unconditional pass - improves anatomy / coherence on SD3.5-medium and similar. 0 = disabled. Recommended: 0 for most models. 2.5 for SD3.5 Medium with the recommended skip layers. Leave empty for the architecture default.", type: "number" },
        slgStart: { title: "SLG Start (% of steps)", description: "Fraction of the sampler schedule (0.0-1.0) at which SLG kicks in. Recommended: 0.01 (almost from the start). Leave empty for the architecture default.", type: "number" },
        spectrumFlexWindow: { title: "Spectrum Cache: flex window", description: "Spectrum-cache flexibility window (0.0-1.0). Recommended: 0.5. Leave empty for the architecture default.", type: "number" },
        spectrumLam: { title: "Spectrum Cache: λ", description: "Spectrum-cache regularization λ. Recommended: 0.5. Leave empty for the architecture default.", type: "number" },
        spectrumM: { title: "Spectrum Cache: m", description: "Spectrum-cache moving-average length. Recommended: 5. Leave empty for the architecture default.", type: "number" },
        spectrumStopPercent: { title: "Spectrum Cache: stop percent", description: "Fraction of steps after which spectrum cache disengages (last steps recomputed). Recommended: 0.8. Leave empty for the architecture default.", type: "number" },
        spectrumW: { title: "Spectrum Cache: w", description: "Spectrum-cache `w` weight (frequency cutoff). Higher = retains more spectrum, less speedup. Recommended: 0.5 default. See sd.cpp PR #1322 for tuning. Leave empty for the architecture default.", type: "number" },
        spectrumWarmupSteps: { title: "Spectrum Cache: warmup steps", description: "Steps at the start of sampling before spectrum cache becomes active. Recommended: 2. Leave empty for the architecture default.", type: "number" },
        spectrumWindowSize: { title: "Spectrum Cache: window size", description: "Spectrum-cache analysis window size in steps. Recommended: 3. Leave empty for the architecture default.", type: "number" },
        steps: { title: "Sampling Steps", description: "Number of denoising steps the sampler runs. More steps = closer to the model's converged output, with diminishing returns. Distilled models (Flux Schnell, SDXL Turbo, Z-Image Turbo) need only 4-8. Recommended: 20-30 for SD1.5/SDXL, 20 for Flux Dev, 4-8 for *-Turbo or Schnell variants. Leave empty for the architecture default.", type: "number" },
        strength: { title: "Denoising Strength", description: "How much of the init image's noise to keep (0.0 = identical to init, 1.0 = ignore init entirely). Controls how aggressively img2img diverges from the input. Recommended: 0.5-0.75 for natural-looking edits. 0.9+ for radical reinterpretation. Leave empty for the architecture default.", type: "number" },
        vaceStrength: { title: "VACE Strength", description: "Strength of the VACE module (Wan 2.x video editing). 0 = disabled. Recommended: 1.0 when VACE is loaded. Leave empty for the architecture default.", type: "number" },
        vaeTileOverlap: { title: "VAE Tile Overlap", description: "Overlap fraction between VAE tiles for seam blending. Recommended: 0.5. Leave empty for the architecture default.", type: "number" },
        vaeTileSizeX: { title: "VAE Tile Width", description: "Width of VAE tiles when tiling is on. 0 = use load-time default. Recommended: 0. Leave empty for the architecture default.", type: "number" },
        vaeTileSizeY: { title: "VAE Tile Height", description: "Height of VAE tiles. 0 = use load-time default. Recommended: 0. Leave empty for the architecture default.", type: "number" },
        vaeTiling: { title: "VAE Tiling", description: "Per-generation override of the model-load `vae_tiling`. Process VAE encode/decode in tiles to reduce peak VRAM. Recommended: Enable for ≥2048 px outputs. Otherwise leave to the load-time default. Leave empty for the architecture default.", type: "boolean" },
        videoFrames: { title: "Video Frames", description: "Number of frames to generate (Wan / video models). Recommended: 33 for Wan 2.x (5-second clip @ 16 fps). Leave empty for the architecture default.", type: "number" },
        width: { title: "Width (px)", description: "Output image width in pixels. Must be divisible by the model's patch size (typically 8 or 16). Architectures have native resolutions they were trained at - going far off them can degrade quality. Recommended: Match the architecture's training resolution: SD1.5=512, SDXL=1024, Flux/SD3/Z-Image=1024, Wan video=832. Leave empty for the architecture default.", type: "number" },
        ipAdapterImageBase64: { title: "IP-Adapter Image (base64)", description: "A reference image whose style and subject guide the result, as base64. Needs an IP-Adapter loaded alongside the model - see the Load Model node. Recommended: Take it from a Download or Fetch Output node rather than pasting one in. Leave empty for the architecture default.", type: "string" },
        ipAdapterStrength: { title: "IP-Adapter Strength", description: "How strongly the reference image guides the result. Recommended: 1.0 is the upstream default. Lower it when the reference is overwhelming the prompt. Leave empty for the architecture default.", type: "number" },
        refAudios: { title: "Reference Audios", description: "Reference audio as base64-encoded WAV, mono or stereo PCM (i16/i24/i32/f32). Recommended: For models that take audio guidance. Leave empty for the architecture default.", type: "array", items: {"type": "string"} },
        refVideos: { title: "Reference Videos", description: "Reference videos. Each entry is an object with frames (base64 images), fps (default 24) and an optional audio_wav_base64. Recommended: Built by an earlier node rather than typed. Leave empty for the architecture default.", type: "array", items: {"type": "object"} },
        title: { type: "string", title: "Job Title", description: "Optional label stored with the job, useful for finding it again in the queue" },
        extraOptions: { type: "object", title: "Extra Options", description: "Any other generation field passed straight through. Everything the server documents already has a setting above, so this is only needed for a field a newer server has gained" },
        timeout: { type: "number", title: "Timeout (ms)", description: "Applies to queueing the job, not to the render. The call returns as soon as the job is accepted", default: 30000 }
    },
    required: ['credentialId']
};

const inputSchema = { type: 'object', properties: { data: { type: 'any' } } };

const outputSchema = {
    type: 'object',
    properties: {
        jobId: { type: 'string', description: 'Id of the queued job, to pass to SD.cpp Wait For Job' },
        status: { type: 'string', description: 'Queue status when the job was accepted, normally pending' },
        position: { type: 'number', description: 'Place in the queue' },
        request: { type: 'object', description: 'The body actually sent, useful for seeing which defaults were left to the server' }
    }
};

function normalizeServer(url) {
    const value = String(url || '').trim();
    if (!value) {
        throw new Error('SD.cpp: a server URL is required, such as http://localhost:8077');
    }
    return value.replace(/\/+$/, '');
}

function readCredential(credentialId) {
    const auth = smartbotic.credentials.get(credentialId);
    if (!auth || auth.success !== true) {
        throw new Error('SD.cpp: could not read the credential: ' +
            ((auth && auth.error) || 'unknown error'));
    }

    const value = auth.headerValue || '';
    if (value.indexOf('Basic ') !== 0) {
        throw new Error('SD.cpp: the credential must be a basic one, holding the sdcpp-restapi ' +
            'username and password');
    }

    const decoded = smartbotic.utils.base64Decode(value.substring(6));
    const separator = decoded.indexOf(':');
    if (separator < 1) {
        throw new Error('SD.cpp: the credential is malformed, expected a username and a password');
    }

    return {
        username: decoded.substring(0, separator),
        password: decoded.substring(separator + 1)
    };
}

function call(options) {
    const response = smartbotic.http.request(options);

    let body = response.data;
    if (typeof body === 'string' && body.length > 0) {
        try {
            body = JSON.parse(body);
        } catch (e) {
            const snippet = body.substring(0, 200).replace(/\s+/g, ' ');
            throw new Error('SD.cpp: ' + options.what + ' returned HTTP ' + response.status +
                ' with a body that is not JSON: ' + snippet);
        }
    }

    if (response.status < 200 || response.status >= 300) {
        const detail = (body && (body.message || body.error)) || ('HTTP ' + response.status);
        throw new Error('SD.cpp: ' + options.what + ' failed: ' + detail);
    }

    return body || {};
}

function login(server, credential, timeout) {
    const session = call({
        method: 'POST',
        url: server + '/auth/login',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
            username: credential.username,
            password: credential.password
        }),
        timeout: timeout,
        what: 'signing in'
    });

    if (!session.token) {
        throw new Error('SD.cpp: the server accepted the login but returned no token');
    }
    return session.token;
}

// /health is unauthenticated, and it is the only way to find out what is
// already loaded without asking for a token first.
function readHealth(server, timeout) {
    return call({
        method: 'GET',
        url: server + '/health',
        timeout: timeout,
        what: 'reading server health'
    });
}

function putIfSet(target, key, value) {
    if (value === undefined || value === null || value === '') {
        return;
    }
    target[key] = value;
}

// Every generation field the server documents, and the setting it comes
// from. Generated alongside the schema above so the two cannot drift.
const GENERATION_OPTIONS = [
    { setting: "cacheMode", server: "cache_mode" },
    { setting: "cfgScale", server: "cfg_scale" },
    { setting: "clipSkip", server: "clip_skip" },
    { setting: "controlFrames", server: "control_frames" },
    { setting: "customSigmas", server: "custom_sigmas" },
    { setting: "distilledGuidance", server: "distilled_guidance" },
    { setting: "endImageBase64", server: "end_image_base64" },
    { setting: "eta", server: "eta" },
    { setting: "expandPrompt", server: "expand_prompt" },
    { setting: "flowShift", server: "flow_shift" },
    { setting: "fps", server: "fps" },
    { setting: "height", server: "height" },
    { setting: "highNoiseCfgScale", server: "high_noise_cfg_scale" },
    { setting: "highNoiseDistilledGuidance", server: "high_noise_distilled_guidance" },
    { setting: "highNoiseSampler", server: "high_noise_sampler" },
    { setting: "highNoiseSkipLayers", server: "high_noise_skip_layers" },
    { setting: "highNoiseSlgEnd", server: "high_noise_slg_end" },
    { setting: "highNoiseSlgScale", server: "high_noise_slg_scale" },
    { setting: "highNoiseSlgStart", server: "high_noise_slg_start" },
    { setting: "highNoiseSteps", server: "high_noise_steps" },
    { setting: "initImageBase64", server: "init_image_base64" },
    { setting: "moeBoundary", server: "moe_boundary" },
    { setting: "negativePrompt", server: "negative_prompt" },
    { setting: "prompt", server: "prompt" },
    { setting: "sampler", server: "sampler" },
    { setting: "scheduler", server: "scheduler" },
    { setting: "seed", server: "seed" },
    { setting: "shiftedTimestep", server: "shifted_timestep" },
    { setting: "skipLayers", server: "skip_layers" },
    { setting: "slgEnd", server: "slg_end" },
    { setting: "slgScale", server: "slg_scale" },
    { setting: "slgStart", server: "slg_start" },
    { setting: "spectrumFlexWindow", server: "spectrum_flex_window" },
    { setting: "spectrumLam", server: "spectrum_lam" },
    { setting: "spectrumM", server: "spectrum_m" },
    { setting: "spectrumStopPercent", server: "spectrum_stop_percent" },
    { setting: "spectrumW", server: "spectrum_w" },
    { setting: "spectrumWarmupSteps", server: "spectrum_warmup_steps" },
    { setting: "spectrumWindowSize", server: "spectrum_window_size" },
    { setting: "steps", server: "steps" },
    { setting: "strength", server: "strength" },
    { setting: "vaceStrength", server: "vace_strength" },
    { setting: "vaeTileOverlap", server: "vae_tile_overlap" },
    { setting: "vaeTileSizeX", server: "vae_tile_size_x" },
    { setting: "vaeTileSizeY", server: "vae_tile_size_y" },
    { setting: "vaeTiling", server: "vae_tiling" },
    { setting: "videoFrames", server: "video_frames" },
    { setting: "width", server: "width" },
    { setting: "ipAdapterImageBase64", server: "ip_adapter_image_base64" },
    { setting: "ipAdapterStrength", server: "ip_adapter_strength" },
    { setting: "refAudios", server: "ref_audios" },
    { setting: "refVideos", server: "ref_videos" }
];

// What the server accepts for each choice, as it described them when this
// file was generated. See scripts/gen-sdcpp-generation-options.py.
const KNOWN_CHOICES = {
    "cacheMode": ["easycache", "spectrum"],
    "sampler": ["ddim_trailing", "dpm2", "dpmpp2m", "dpmpp2mv2", "dpmpp2s_a", "er_sde", "euler", "euler_a", "heun", "ipndm", "ipndm_v", "lcm", "res_2s", "res_multistep", "tcd"],
    "scheduler": ["ays", "bong_tangent", "discrete", "exponential", "gits", "karras", "kl_optimal", "lcm", "sgm_uniform", "simple", "smoothstep"]
};

async function execute(config, input, context) {
    const server = normalizeServer(config.serverUrl);
    const timeout = config.timeout || 30000;

    const credential = readCredential(config.credentialId);
    const token = login(server, credential, timeout);

    const body = {};

    // Built from the table above rather than field by field, so a setting the
    // server documents cannot be quietly missing from the request. A setting
    // left empty is left out of the body entirely: the server fills an absent
    // field from the loaded model's architecture preset, and sending an empty
    // box as 0 would override that preset with nonsense. The test is emptiness,
    // never truthiness - seed 0 and clip_skip 0 are legitimate values.
    for (let i = 0; i < GENERATION_OPTIONS.length; i++) {
        const option = GENERATION_OPTIONS[i];
        const value = config[option.setting];
        if (Array.isArray(value)) {
            // A list setting is usually filled with one entry holding an
            // expression for a whole list from an earlier node, which arrives
            // as a list inside a list. Left alone, the inner list is sent as a
            // single item and the server sees one nonsense value instead of
            // several - the same way a batch of two images once became one file
            // named "a.png,b.png".
            let flat = [];
            for (let j = 0; j < value.length; j++) {
                if (Array.isArray(value[j])) {
                    flat = flat.concat(value[j]);
                } else if (value[j] !== undefined && value[j] !== null && value[j] !== '') {
                    flat.push(value[j]);
                }
            }
            if (flat.length > 0) {
                body[option.server] = flat;
            }
        } else if (option.server === 'cache_mode' && value === 'off') {
            // The server reads an absent cache_mode as "use the architecture's
            // preference" and an empty one as "off". A dropdown cannot express
            // both with the same empty string, so "off" is sent as the explicit
            // empty the server wants - which is the only way to stop a preset
            // that switches caching on.
            body.cache_mode = '';
        } else {
            putIfSet(body, option.server, value);
        }
    }
    putIfSet(body, 'title', config.title);

    if (!body.prompt) {
        throw new Error('SD.cpp: txt2vid needs a prompt');
    }

    // Anything else the API accepts, passed through, so a new server field does
    // not need a node change to be reachable.
    const extra = config.extraOptions;
    if (extra && typeof extra === 'object') {
        const keys = Object.keys(extra);
        for (let i = 0; i < keys.length; i++) {
            putIfSet(body, keys[i], extra[keys[i]]);
        }
    }

    const queued = call({
        method: 'POST',
        url: server + '/txt2vid',
        headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
        body: JSON.stringify(body),
        timeout: timeout,
        what: 'queueing the txt2vid job'
    });

    if (!queued.job_id) {
        throw new Error('SD.cpp: the job was accepted but no job id came back');
    }

    smartbotic.log.info('SD.cpp: queued txt2vid job ' + queued.job_id);

    return {
        jobId: queued.job_id,
        status: queued.status || 'pending',
        position: queued.position !== undefined ? queued.position : -1,
        request: body
    };
}

module.exports = { configSchema, inputSchema, outputSchema, execute };