Stable Diffusion: primary/secondary settings presets with auto-fallback Reviewed-by: auto-review

5273c09fac552c7004b0f777c2d557a4202c6c1a

permissionBRICK <permissionBRICK@gmail.com>

Parents: 51ad27fb86d39a3daca3adaa970375c9670c12df

public/scripts/extensions/stable-diffusion/index.js+212 -40 Viewed

     google_api: 'makersuite',
     google_enhance: true,
     google_duration: 6,
+    // Settings presets & auto-fallback
+    settings_preset_primary: null,
+    settings_preset_secondary: null,
+    settings_fallback_enabled: false,
 };
+/**
+ * Keys that are NOT part of a settings preset snapshot.
+ * A preset captures backend/connection params (source, model, sampler, dimensions, etc.)
+ * but not the prompt library, styles, custom entries, or UI prefs.
+ * @type {string[]}
+ */
+const PRESET_EXCLUDE_KEYS = [
+    'settings_preset_primary',
+    'settings_preset_secondary',
+    'settings_fallback_enabled',
+    'prompts',
+    'character_prompts',
+    'character_negative_prompts',
+    'styles',
+    'custom_entries',
+    'interactive_visible',
+    'wand_visible',
+    'command_visible',
+    'tool_visible',
+    'expand',
+];
+/**
+ * Creates a deep clone snapshot of the settings keys that belong to a preset.
+ * @returns {object} Snapshot of the included settings keys.
+ */
+function snapshotSdSettings() {
+    const snapshot = {};
+    for (const key of Object.keys(extension_settings.sd)) {
+        if (PRESET_EXCLUDE_KEYS.includes(key)) {
+            continue;
+        }
+        snapshot[key] = structuredClone(extension_settings.sd[key]);
+    }
+    return snapshot;
+}
+/**
+ * Applies a settings snapshot to the live settings object (in-memory only; does NOT touch the DOM).
+ * @param {object} snapshot Snapshot previously created by snapshotSdSettings().
+ */
+function applySdSettingsSnapshot(snapshot) {
+    if (!snapshot || typeof snapshot !== 'object') {
+        return;
+    }
+    for (const key of Object.keys(snapshot)) {
+        extension_settings.sd[key] = structuredClone(snapshot[key]);
+    }
+}
+/**
+ * Checks whether a preset is configured (a non-null object with at least one key).
+ * @param {object} preset Preset to check.
+ * @returns {boolean} True if the preset is configured.
+ */
+function isPresetConfigured(preset) {
+    return !!preset && typeof preset === 'object' && Object.keys(preset).length > 0;
+}
+/**
+ * Refreshes all settings UI controls to reflect the current extension_settings.sd values.
+ * Used after loading a settings preset.
+ * @returns {Promise<void>}
+ */
+async function refreshSettingsUi() {
+    // loadSettings() appends to #sd_style without clearing it, so empty it first.
+    $('#sd_style').empty();
+    await loadSettings();
+}
 const writePromptFieldsDebounced = debounce(writePromptFields, debounce_timeout.relaxed);
 const isVideo = (/** @type {string} */ format) => VIDEO_EXTENSIONS.includes(String(format || '').trim().toLowerCase());

         extension_settings.sd.styles = defaultStyles;
+    }
+    // Settings presets & auto-fallback
+    if (extension_settings.sd.settings_preset_primary === undefined) {
+        extension_settings.sd.settings_preset_primary = null;
+    }
+    if (extension_settings.sd.settings_preset_secondary === undefined) {
+        extension_settings.sd.settings_preset_secondary = null;
+    }
+    if (extension_settings.sd.settings_fallback_enabled === undefined) {
+        extension_settings.sd.settings_fallback_enabled = false;
+    }
     // Preserve an original seed if exists
     if (extension_settings.sd.original_seed >= 0) {
         extension_settings.sd.seed = extension_settings.sd.original_seed;

     $('#sd_google_api').val(extension_settings.sd.google_api);
     $('#sd_google_enhance').prop('checked', extension_settings.sd.google_enhance);
     $('#sd_google_duration').val(extension_settings.sd.google_duration);
+    $('#sd_fallback_enabled').prop('checked', extension_settings.sd.settings_fallback_enabled);
     for (const style of extension_settings.sd.styles) {
         const option = document.createElement('option');

     saveSettingsDebounced();
+}
+function onSavePresetPrimaryClick() {
+    extension_settings.sd.settings_preset_primary = snapshotSdSettings();
+    saveSettingsDebounced();
+    toastr.success(t`Primary settings preset saved.`, t`Image Generation`);
+}
+function onSavePresetSecondaryClick() {
+    extension_settings.sd.settings_preset_secondary = snapshotSdSettings();
+    saveSettingsDebounced();
+    toastr.success(t`Secondary settings preset saved.`, t`Image Generation`);
+}
+async function onLoadPresetPrimaryClick() {
+    if (!isPresetConfigured(extension_settings.sd.settings_preset_primary)) {
+        toastr.info(t`No primary settings preset has been saved yet.`, t`Image Generation`);
+        return;
+    }
+    applySdSettingsSnapshot(extension_settings.sd.settings_preset_primary);
+    saveSettingsDebounced();
+    await refreshSettingsUi();
+    toastr.success(t`Primary settings preset loaded.`, t`Image Generation`);
+}
+async function onLoadPresetSecondaryClick() {
+    if (!isPresetConfigured(extension_settings.sd.settings_preset_secondary)) {
+        toastr.info(t`No secondary settings preset has been saved yet.`, t`Image Generation`);
+        return;
+    }
+    applySdSettingsSnapshot(extension_settings.sd.settings_preset_secondary);
+    saveSettingsDebounced();
+    await refreshSettingsUi();
+    toastr.success(t`Secondary settings preset loaded.`, t`Image Generation`);
+}
+function onFallbackEnabledChange() {
+    extension_settings.sd.settings_fallback_enabled = !!$(this).prop('checked');
+    saveSettingsDebounced();
+}
 /**
  * Modifies prompt based on user inputs.
  * @param {string} prompt Prompt to refine

     const skipCharPrefix = !ignoreNoCharForSwipe && noCharPrefix.includes(generationType);
-    const prefix = skipCharPrefix
+    /**
-        ? extension_settings.sd.prompt_prefix
+     * Performs a single image generation attempt against the live extension_settings.sd config.
-        : combinePrefixes(extension_settings.sd.prompt_prefix, getCharacterPrefix());
+     * Reads settings live so it can be retried after applying a fallback preset.
+     * @param {AbortSignal} attemptSignal Abort signal to cancel the request.
-    const negativePrefix = skipCharPrefix
+     * @returns {Promise<{result: {format: string, data: string}, prefixedPrompt: string}>}
-        ? extension_settings.sd.negative_prompt
+     * @throws {Error} On failure or when the endpoint returns no image data.
-        : combinePrefixes(extension_settings.sd.negative_prompt, getCharacterNegativePrefix());
+     */
+    async function attemptImageGeneration(attemptSignal) {
+        const prefix = skipCharPrefix
+            ? extension_settings.sd.prompt_prefix
+            : combinePrefixes(extension_settings.sd.prompt_prefix, getCharacterPrefix());
-    const prefixedPrompt = substituteParams(combinePrefixes(prefix, prompt, '{prompt}'));
+        const negativePrefix = skipCharPrefix
-    const negativePrompt = substituteParams(combinePrefixes(additionalNegativePrefix, negativePrefix));
+            ? extension_settings.sd.negative_prompt
+            : combinePrefixes(extension_settings.sd.negative_prompt, getCharacterNegativePrefix());
-    let result = { format: '', data: '' };
+        const prefixedPrompt = substituteParams(combinePrefixes(prefix, prompt, '{prompt}'));
-    const currentChatId = getCurrentChatId();
+        const negativePrompt = substituteParams(combinePrefixes(additionalNegativePrefix, negativePrefix));
-    try {
+        let result = { format: '', data: '' };
         switch (extension_settings.sd.source) {
             case sources.extras:
-                result = await generateExtrasImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateExtrasImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.horde:
-                result = await generateHordeImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateHordeImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.vlad:
-                result = await generateAutoImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateAutoImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.drawthings:
-                result = await generateDrawthingsImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateDrawthingsImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.auto:
-                result = await generateAutoImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateAutoImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.sdcpp:
-                result = await generateSdcppImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateSdcppImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.novel:
-                result = await generateNovelImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateNovelImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.openai:
-                result = await generateOpenAiImage(prefixedPrompt, signal);
+                result = await generateOpenAiImage(prefixedPrompt, attemptSignal);
                 break;
             case sources.aimlapi:
-                result = await generateAimlapiImage(prefixedPrompt, signal);
+                result = await generateAimlapiImage(prefixedPrompt, attemptSignal);
                 break;
             case sources.comfy:
                 switch (extension_settings.sd.comfy_type) {
                     case comfyTypes.runpod_serverless:
-                        result = await generateComfyRunPodImage(prefixedPrompt, negativePrompt, signal);
+                        result = await generateComfyRunPodImage(prefixedPrompt, negativePrompt, attemptSignal);
                         break;
                     case comfyTypes.standard:
-                        result = await generateComfyImage(prefixedPrompt, negativePrompt, signal);
+                        result = await generateComfyImage(prefixedPrompt, negativePrompt, attemptSignal);
                         break;
                     default:
                         throw new Error('Unknown comfyUI server type.');
+                }
                 break;
             case sources.togetherai:
-                result = await generateTogetherAIImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateTogetherAIImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.pollinations:
-                result = await generatePollinationsImage(prefixedPrompt, negativePrompt, signal);
+                result = await generatePollinationsImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.stability:
-                result = await generateStabilityImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateStabilityImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.huggingface:
-                result = await generateHuggingFaceImage(prefixedPrompt, signal);
+                result = await generateHuggingFaceImage(prefixedPrompt, attemptSignal);
                 break;
             case sources.chutes:
-                result = await generateChutesImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateChutesImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.electronhub:
-                result = await generateElectronHubImage(prefixedPrompt, signal);
+                result = await generateElectronHubImage(prefixedPrompt, attemptSignal);
                 break;
             case sources.nanogpt:
-                result = await generateNanoGPTImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateNanoGPTImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.bfl:
-                result = await generateBflImage(prefixedPrompt, signal);
+                result = await generateBflImage(prefixedPrompt, attemptSignal);
                 break;
             case sources.falai:
-                result = await generateFalaiImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateFalaiImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.xai:
-                result = await generateXAIImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateXAIImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.google:
-                result = await generateGoogleImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateGoogleImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
             case sources.zai:
-                result = await generateZaiImage(prefixedPrompt, signal);
+                result = await generateZaiImage(prefixedPrompt, attemptSignal);
                 break;
             case sources.openrouter:
-                result = await generateOpenRouterImage(prefixedPrompt, signal);
+                result = await generateOpenRouterImage(prefixedPrompt, attemptSignal);
                 break;
             case sources.workersai:
-                result = await generateWorkersAIImage(prefixedPrompt, negativePrompt, signal);
+                result = await generateWorkersAIImage(prefixedPrompt, negativePrompt, attemptSignal);
                 break;
+        }
         if (!result.data) {
             throw new Error('Endpoint did not return image data.');
+        }
+        return { result, prefixedPrompt };
+    }
+    const currentChatId = getCurrentChatId();
+    let genOutput;
+    try {
+        genOutput = await attemptImageGeneration(signal);
     } catch (err) {
         // Check if this was an intentional abort by user
         if (signal?.aborted) {

             return;
+        }
-        console.error('Image generation request error: ', err);
+        if (extension_settings.sd.settings_fallback_enabled && isPresetConfigured(extension_settings.sd.settings_preset_secondary)) {
-        toastr.error('Image generation failed. Please try again.' + '\n\n' + String(err), 'Image Generation');
+            console.warn('SD: primary generation failed, falling back to secondary preset', err);
-        return;
+            toastr.warning('Primary image generation failed. Retrying with secondary settings…', 'Image Generation');
+            const restore = snapshotSdSettings();
+            try {
+                applySdSettingsSnapshot(extension_settings.sd.settings_preset_secondary);
+                genOutput = await attemptImageGeneration(signal);
+            } catch (err2) {
+                applySdSettingsSnapshot(restore);
+                if (signal?.aborted) {
+                    console.log('SD: Image generation aborted by user');
+                    toastr.info('Image generation stopped.', 'Image Generation');
+                    return;
+                }
+                console.error('SD: secondary generation also failed', err2);
+                toastr.error('Image generation failed (primary and secondary).' + '\n\n' + String(err2), 'Image Generation');
+                return;
+            }
+            // Restore live (primary) settings after a successful fallback attempt.
+            applySdSettingsSnapshot(restore);
+        } else {
+            console.error('Image generation request error: ', err);
+            toastr.error('Image generation failed. Please try again.' + '\n\n' + String(err), 'Image Generation');
+            return;
+        }
+    }
+    const { result, prefixedPrompt } = genOutput;
     if (currentChatId !== getCurrentChatId()) {
         console.warn('Chat changed, aborting SD result saving');
         toastr.warning('Chat changed, generated image discarded.', 'Image Generation');

     $('#sd_save_style').on('click', onSaveStyleClick);
     $('#sd_rename_style').on('click', onRenameStyleClick);
     $('#sd_delete_style').on('click', onDeleteStyleClick);
+    $('#sd_save_preset_primary').on('click', onSavePresetPrimaryClick);
+    $('#sd_save_preset_secondary').on('click', onSavePresetSecondaryClick);
+    $('#sd_load_preset_primary').on('click', onLoadPresetPrimaryClick);
+    $('#sd_load_preset_secondary').on('click', onLoadPresetSecondaryClick);
+    $('#sd_fallback_enabled').on('change', onFallbackEnabledChange);
     $('#sd_character_prompt_block').hide();
     $('#sd_interactive_mode').on('input', onInteractiveModeInput);
     $('#sd_openai_style').on('change', onOpenAiStyleSelect);

public/scripts/extensions/stable-diffusion/settings.html+15 -0 Viewed

                 <input id="sd_minimal_prompt_processing" type="checkbox" />
                 <span data-i18n="sd_minimal_prompt_processing_txt">Minimal response prompt processing</span>
             </label>
+            <hr>
+            <h4 data-i18n="Settings Presets & Fallback">Settings Presets &amp; Fallback</h4>
+            <small data-i18n="sd_settings_presets_small">Save the current backend/connection settings (source, model, sampler, dimensions, etc.) as Primary or Secondary presets and load them back later. Prompt templates, styles, and custom entries are not included.</small>
+            <div class="flex-container marginTopBot5 flexWrap">
+                <div id="sd_save_preset_primary" class="menu_button" data-i18n="Save as Primary">Save as Primary</div>
+                <div id="sd_load_preset_primary" class="menu_button" data-i18n="Load Primary">Load Primary</div>
+                <div id="sd_save_preset_secondary" class="menu_button" data-i18n="Save as Secondary">Save as Secondary</div>
+                <div id="sd_load_preset_secondary" class="menu_button" data-i18n="Load Secondary">Load Secondary</div>
+            </div>
+            <label for="sd_fallback_enabled" class="checkbox_label" data-i18n="[title]sd_fallback_enabled" title="If an image generation fails, automatically retry the same prompt using the Secondary preset's settings.">
+                <input id="sd_fallback_enabled" type="checkbox" />
+                <span data-i18n="sd_fallback_enabled_txt">Auto-fallback to Secondary on failure</span>
+            </label>
+            <small data-i18n="sd_fallback_enabled_small">When enabled, a failed generation is retried once with the Secondary preset before reporting an error.</small>
+            <hr>
             <label for="sd_source" data-i18n="Source">Source</label>
             <select id="sd_source" class="text_pole">
                 <option value="aimlapi">AI/ML API</option>