Merge feat/multi-feature-pack into release Multi-feature enhancement pack: - SD settings presets & fallback with LLM profile switching - Custom wand entries for image generation - Connection manager quick-switch button - Summarize extension: connection profile + prompt role selection - Cache keepalive extension (per-profile, per-chat arming, drift guard) - SD/Summarize profile-switch reconnect-wait fix

75e9eadad17755ba15bd56be82054788ed0687d0

permissionBRICK <40219477+permissionBRICK@users.noreply.github.com>

Parents: 5a89e27aa4bcedfa629d8f3b176c6b6fa24fcdd3 cd3be6486e9ca988e7821634e09e245a326e3a56

public/scripts/extensions/connection-manager/index.js+136 -2 Viewed

 import { DOMPurify, Fuse, Popper } from '../../../lib.js';
 import { activateSendButtons, animation_duration, deactivateSendButtons, event_types, eventSource, main_api, online_status, saveSettingsDebounced } from '../../../script.js';
 import { extension_settings, getContext, renderExtensionTemplateAsync } from '../../extensions.js';
 import { callGenericPopup, Popup, POPUP_RESULT, POPUP_TYPE } from '../../popup.js';
 import { SlashCommand } from '../../slash-commands/SlashCommand.js';

+    }
+}
 +/**
 + * Adds a quick-switch connection profile button to the bottom-left of the chat bar.
 + * Clicking it opens a small popup listing all saved connection profiles; clicking a
 + * profile switches to it by driving the Connection Manager's #connection_profiles select.
 + */
 +function addQuickSwitchButton() {
 +    const leftSendForm = document.getElementById('leftSendForm');
 +    if (!leftSendForm) {
 +        console.warn('[Connection Manager] #leftSendForm not found, skipping quick-switch button');
 +        return;
 +    }
++
 +    // Avoid adding the button twice (e.g. on extension re-activation)
 +    if (document.getElementById('connection_profile_switcher')) {
 +        return;
 +    }
++
 +    const button = document.createElement('div');
 +    button.id = 'connection_profile_switcher';
 +    button.className = 'fa-solid fa-plug interactable';
 +    button.tabIndex = 0;
 +    button.title = t`Quick-switch connection profile`;
 +    button.setAttribute('data-i18n', '[title]Quick-switch connection profile');
 +    leftSendForm.appendChild(button);
++
 +    const menu = document.createElement('div');
 +    menu.id = 'connection_profile_switcher_menu';
 +    menu.style.display = 'none';
 +    const list = document.createElement('ul');
 +    list.id = 'connection_profile_switcher_list';
 +    list.className = 'list-group';
 +    menu.appendChild(list);
 +    document.body.appendChild(menu);
++
 +    const $menu = $(menu);
 +    const popper = Popper.createPopper(button, menu, {
 +        placement: 'top-start',
 +    });
++
 +    /**
 +     * Rebuilds the list of profiles from the current settings.
 +     */
 +    function rebuildList() {
 +        list.innerHTML = '';
 +        const profiles = extension_settings.connectionManager.profiles;
 +        const selectedProfile = extension_settings.connectionManager.selectedProfile;
++
 +        if (!Array.isArray(profiles) || profiles.length === 0) {
 +            const emptyItem = document.createElement('li');
 +            emptyItem.className = 'list-group-item disabled';
 +            emptyItem.textContent = t`No connection profiles saved`;
 +            emptyItem.setAttribute('data-i18n', 'No connection profiles saved');
 +            list.appendChild(emptyItem);
 +            return;
 +        }
++
 +        const sortedProfiles = profiles.slice().sort((a, b) => a.name.localeCompare(b.name));
 +        for (const profile of sortedProfiles) {
 +            const item = document.createElement('li');
 +            item.className = 'list-group-item interactable';
 +            item.dataset.profileId = profile.id;
 +            if (profile.id === selectedProfile) {
 +                item.classList.add('selected');
 +            }
 +            const icon = document.createElement('i');
 +            icon.className = profile.id === selectedProfile ? 'fa-fw fa-solid fa-check' : 'fa-fw fa-solid';
 +            const label = document.createElement('span');
 +            label.textContent = profile.name;
 +            item.appendChild(icon);
 +            item.appendChild(label);
 +            list.appendChild(item);
 +        }
 +    }
++
 +    button.addEventListener('click', (e) => {
 +        e.preventDefault();
 +        if ($menu.is(':visible')) {
 +            $menu.fadeOut(animation_duration);
 +            return;
 +        }
 +        rebuildList();
 +        $menu.fadeIn(animation_duration);
 +        popper.update();
 +    });
++
 +    // Switch profile when a list item is clicked (event delegation).
 +    list.addEventListener('click', (e) => {
 +        const item = e.target instanceof Element ? e.target.closest('li[data-profile-id]') : null;
 +        if (!item) {
 +            return;
 +        }
 +        const profileId = item.dataset.profileId;
 +        $menu.fadeOut(animation_duration);
 +        if (!profileId) {
 +            return;
 +        }
 +        /** @type {HTMLSelectElement} */
 +        // @ts-ignore
 +        const select = document.getElementById('connection_profiles');
 +        if (!select) {
 +            console.warn('[Connection Manager] #connection_profiles select not found');
 +            return;
 +        }
 +        if (!Array.from(select.options).some(o => o.value === profileId)) {
 +            console.warn(`[Connection Manager] Profile option not found in select: ${profileId}`);
 +            return;
 +        }
 +        select.value = profileId;
 +        select.dispatchEvent(new Event('change'));
 +    });
++
 +    // Close the menu when clicking outside of it or the button.
 +    document.addEventListener('click', (e) => {
 +        if (!$menu.is(':visible')) {
 +            return;
 +        }
 +        const target = e.target;
 +        if (target instanceof Node && (menu.contains(target) || button.contains(target) || button === target)) {
 +            return;
 +        }
 +        $menu.fadeOut(animation_duration);
 +    });
++
 +    // Keep the highlighted item up to date while the menu is open.
 +    eventSource.on(event_types.CONNECTION_PROFILE_LOADED, () => {
 +        if ($menu.is(':visible')) {
 +            rebuildList();
 +            popper.update();
 +        }
 +    });
 +}
++
 export async function init() {
     extension_settings.connectionManager = extension_settings.connectionManager || structuredClone(DEFAULT_SETTINGS);

     const profiles = document.getElementById('connection_profiles');
     renderConnectionProfiles(profiles);
 +    addQuickSwitchButton();
++
     function toggleProfileSpecificButtons() {
         const profileId = extension_settings.connectionManager.selectedProfile;
         const profileSpecificButtons = ['update_connection_profile', 'reload_connection_profile', 'delete_connection_profile'];

public/scripts/extensions/connection-manager/style.css+26 -0 Viewed

 #connection_profile_spinner {
     margin-left: 5px;
+}
++
 +#connection_profile_switcher {
 +    font-size: var(--bottomFormIconSize);
 +}
++
 +#connection_profile_switcher_menu {
 +    z-index: 30000;
 +    backdrop-filter: blur(var(--SmartThemeBlurStrength));
 +    -webkit-backdrop-filter: blur(var(--SmartThemeBlurStrength));
 +}
++
 +#connection_profile_switcher_list {
 +    max-height: calc(100vh - calc(2 * var(--bottomFormBlockSize) + 10px));
 +    max-height: calc(100dvh - calc(2 * var(--bottomFormBlockSize) + 10px));
 +    overflow-y: auto;
 +    min-width: 150px;
 +}
++
 +#connection_profile_switcher_list .list-group-item.selected {
 +    opacity: 1;
 +}
++
 +#connection_profile_switcher_list .list-group-item.disabled {
 +    cursor: default;
 +    opacity: 0.5;
 +}

public/scripts/extensions/keepalive/index.js+360 -0 Viewed

 +import { extension_settings, renderExtensionTemplateAsync } from '../../extensions.js';
 +import {
 +    activateSendButtons,
 +    deactivateSendButtons,
 +    eventSource,
 +    event_types,
 +    extension_prompt_roles,
 +    extension_prompt_types,
 +    generateQuietPrompt,
 +    isGenerating,
 +    saveSettingsDebounced,
 +    setExtensionPrompt,
 +    setSendButtonState,
 +    streamingProcessor,
 +} from '../../../script.js';
++
 +export { init };
++
 +const MODULE = 'keepalive';
++
 +// Cap the keepalive completion to a single token. The full prompt prefix is
 +// still processed by the backend (which is what refreshes the server-side
 +// cache), but we never pay for a full completion.
 +const KEEPALIVE_RESPONSE_LENGTH = 1;
++
 +// Extension-prompt key used to inject the keepalive message as a USER message at depth 0.
 +const KEEPALIVE_INJECT_ID = 'keepalive_ping';
++
 +// Original default message; used to migrate untouched installs to the current default wording.
 +const LEGACY_DEFAULT_MESSAGE = 'Keep the cache warm.';
++
 +// Idle-tracking key used when no connection profile is active (manual API panel).
 +const NONE_KEY = '__none__';
++
 +// When the active profile is already past its timeout (e.g. you just switched back
 +// to a profile that went cold), wait this short grace before pinging so an imminent
 +// user message can pre-empt the keepalive.
 +const EXPIRED_GRACE_MS = 3000;
++
 +// If the idle timer fires more than this many ms later than it was scheduled to, assume the
 +// machine slept / the tab was throttled — far more wall-clock time passed than the interval,
 +// so the cache almost certainly lapsed. Skip the ping and go dormant rather than guess.
 +const MAX_TIMER_DRIFT_MS = 5000;
++
 +const defaultSettings = {
 +    enabled: false,
 +    timeoutSeconds: 295,
 +    message: '[Note: just reply with an empty response to keep the session alive]',
 +    // Per-profile enable map: { [profileId]: boolean }. Unlisted profiles default to enabled.
 +    profiles: {},
 +};
++
 +let idleTimer = null;
 +let keepaliveActive = false;
 +// Whether keepalive is "armed" for the CURRENT chat. It stays dormant until the user sends a new
 +// message in the open chat — on a freshly loaded or switched-to chat (even with history already
 +// present) we have no way to know whether its prompt is still cached server-side, so pinging would
 +// be pointless. Reset on page reload and whenever the chat changes.
 +let armed = false;
 +// Wall-clock time (Date.now() + delay) the pending idle timer is expected to fire, or null when
 +// none is scheduled. Used to detect a timer that fired far too late (sleep/throttle).
 +let scheduledFireTime = null;
 +// Per-profile "time since last message", keyed by connection profile id (or NONE_KEY).
 +// In-memory only: on reload every profile is treated as freshly active.
 +const lastActivity = {};
++
 +/**
 + * @returns {string} The active connection profile id, or NONE_KEY for a manual connection.
 + */
 +function getActiveProfileKey() {
 +    return extension_settings.connectionManager?.selectedProfile || NONE_KEY;
 +}
++
 +/**
 + * Whether keepalive should run for the CURRENTLY ACTIVE connection. Requires the global
 + * master switch; for a real profile it also requires that profile's per-profile toggle
 + * (default on). A manual connection (no profile selected) is governed by the master switch alone.
 + * @returns {boolean}
 + */
 +function isKeepaliveEnabledForActive() {
 +    const s = extension_settings[MODULE];
 +    if (!s.enabled) {
 +        return false;
 +    }
 +    const profileId = extension_settings.connectionManager?.selectedProfile;
 +    if (!profileId) {
 +        return true;
 +    }
 +    const perProfile = s.profiles?.[profileId];
 +    return perProfile === undefined ? true : !!perProfile;
 +}
++
 +/**
 + * Clears the pending idle timer, if any.
 + */
 +function clearIdleTimer() {
 +    if (idleTimer) {
 +        clearTimeout(idleTimer);
 +        idleTimer = null;
 +    }
 +}
++
 +/**
 + * (Re)schedules the keepalive for the ACTIVE profile based on how long it has been since
 + * that profile's last message. Does nothing (and leaves the timer cleared) until keepalive
 + * has been armed for the current chat, or when it is disabled for the active connection.
 + * Called on activity AND whenever the active profile changes, so each profile keeps its own
 + * independent idle clock.
 + */
 +function scheduleIdleTimer() {
 +    clearIdleTimer();
 +    if (!armed || !isKeepaliveEnabledForActive()) {
 +        scheduledFireTime = null;
 +        return;
 +    }
 +    const timeoutMs = Math.max(60, Number(extension_settings[MODULE].timeoutSeconds) || 295) * 1000;
 +    const last = lastActivity[getActiveProfileKey()] ?? Date.now();
 +    const remaining = timeoutMs - (Date.now() - last);
 +    const delay = remaining > 0 ? remaining : EXPIRED_GRACE_MS;
 +    scheduledFireTime = Date.now() + delay;
 +    idleTimer = setTimeout(fireKeepalive, delay);
 +}
++
 +/**
 + * Marks the active profile as just-used (resets its idle clock) and reschedules its keepalive.
 + */
 +function markActivity() {
 +    lastActivity[getActiveProfileKey()] = Date.now();
 +    scheduleIdleTimer();
 +}
++
 +/**
 + * The user sent a new message in the current chat — the ONLY thing that arms keepalive.
 + * Background/quiet generations, swipes, regenerations, and loading chat history deliberately do
 + * NOT arm it: none of those prove the user is actively continuing THIS chat from a known-cached
 + * prompt (GENERATION_STARTED in particular fires for every quiet/background generation too).
 + */
 +function onMessageSent() {
 +    armed = true;
 +    markActivity();
 +}
++
 +/**
 + * Opening or switching chats disarms keepalive: a freshly loaded chat is not proof its prompt is
 + * still cached server-side, so we wait for a new sent message in that chat before running again.
 + */
 +function onChatChanged() {
 +    armed = false;
 +    scheduleIdleTimer();
 +}
++
 +/**
 + * Fires a background ("quiet") generation against the active model to keep the
 + * server-side prompt cache warm. The full prompt prefix (current chat context +
 + * the keepalive message) is sent — which is what refreshes the cache — while the
 + * completion is capped to a single token (KEEPALIVE_RESPONSE_LENGTH) so we never
 + * pay for a real response.
 + *
 + * Only the CURRENTLY ACTIVE profile is ever pinged — keepalive never switches the
 + * connection in the background. Each profile's idle clock is tracked separately, so
 + * switching profiles re-targets the timer at whichever profile is now active.
 + *
 + * Quiet generations are forced non-streaming by the core (Generate excludes
 + * type === 'quiet' from the StreamingProcessor) and are never saved to chat, so the
 + * output is simply discarded. generateQuietPrompt's responseLength applies a *global*
 + * temporary response-length override for the duration of the request, so we hold the
 + * same generation lock the blocking summary path uses — setSendButtonState(true) flips
 + * `is_send_press` (which every user send entry point checks and bails on) and
 + * deactivateSendButtons() reflects the busy state — and release both in `finally`.
 + */
 +async function fireKeepalive() {
 +    if (!armed || !isKeepaliveEnabledForActive()) {
 +        return;
 +    }
++
 +    // If the timer fired much later than scheduled (machine sleep, background-tab throttling,
 +    // etc.), far more wall-clock time has elapsed than the idle interval, so the cache has
 +    // almost certainly expired. Don't ping on a stale assumption — go dormant until the next
 +    // sent message re-arms keepalive, exactly like a freshly opened chat.
 +    if (scheduledFireTime !== null && (Date.now() - scheduledFireTime) > MAX_TIMER_DRIFT_MS) {
 +        console.debug('[Keepalive] Idle timer fired', Date.now() - scheduledFireTime, 'ms late; skipping and disarming until next activity.');
 +        armed = false;
 +        clearIdleTimer();
 +        scheduledFireTime = null;
 +        return;
 +    }
++
 +    // Never start while any generation is in progress, or while a previous
 +    // keepalive is still running. Reschedule and bail.
 +    if (keepaliveActive || isGenerating() || streamingProcessor) {
 +        scheduleIdleTimer();
 +        return;
 +    }
++
 +    keepaliveActive = true;
 +    setSendButtonState(true);
 +    deactivateSendButtons();
++
 +    try {
 +        // Deliver the keepalive as a USER message at depth 0 (the quiet-prompt path forces a
 +        // system role — openai.js hardcodes role:'system' for it), using the same depth+role
 +        // injection Author's Note uses. The quiet prompt itself stays empty so the full chat
 +        // context is still assembled (which is what keeps the cached prefix warm).
 +        setExtensionPrompt(KEEPALIVE_INJECT_ID, extension_settings[MODULE].message, extension_prompt_types.IN_CHAT, 0, false, extension_prompt_roles.USER);
 +        await generateQuietPrompt({ quietPrompt: '', responseLength: KEEPALIVE_RESPONSE_LENGTH });
 +        // The ping kept this profile warm; treat it as fresh activity so the next
 +        // keepalive for it is a full timeout away.
 +        lastActivity[getActiveProfileKey()] = Date.now();
 +    } catch (error) {
 +        // Best-effort: any failure here is harmless and intentionally swallowed.
 +        console.debug('[Keepalive] Background generation ended:', error);
 +    } finally {
 +        setExtensionPrompt(KEEPALIVE_INJECT_ID, '', extension_prompt_types.IN_CHAT, 0, false, extension_prompt_roles.USER);
 +        setSendButtonState(false);
 +        activateSendButtons();
 +        keepaliveActive = false;
 +        scheduleIdleTimer();
 +    }
 +}
++
 +/**
 + * Renders the per-profile enable checkboxes from the current Connection Manager profiles.
 + */
 +function renderProfileToggles() {
 +    const container = $('#keepalive_profiles_list');
 +    if (!container.length) {
 +        return;
 +    }
 +    container.empty();
++
 +    const profiles = extension_settings.connectionManager?.profiles;
 +    if (!Array.isArray(profiles) || profiles.length === 0) {
 +        container.append(
 +            $('<small>')
 +                .attr('data-i18n', 'ext_keepalive_no_profiles')
 +                .text('No connection profiles found. Keepalive uses the active model, governed by the master toggle above.'),
 +        );
 +        return;
 +    }
++
 +    const perProfile = extension_settings[MODULE].profiles || {};
 +    const sorted = profiles.slice().sort((a, b) => String(a.name).localeCompare(String(b.name)));
 +    for (const profile of sorted) {
 +        const enabled = perProfile[profile.id] === undefined ? true : !!perProfile[profile.id];
 +        const label = $('<label>').addClass('checkbox_label');
 +        const input = $('<input>')
 +            .attr('type', 'checkbox')
 +            .addClass('keepalive_profile_toggle')
 +            .attr('data-profile-id', profile.id)
 +            .prop('checked', enabled);
 +        const span = $('<span>').text(profile.name);
 +        label.append(input, span);
 +        container.append(label);
 +    }
 +}
++
 +/**
 + * Loads settings into the global store and hydrates the UI controls.
 + */
 +function loadSettings() {
 +    if (extension_settings[MODULE] === undefined) {
 +        extension_settings[MODULE] = {};
 +    }
++
 +    for (const key of Object.keys(defaultSettings)) {
 +        if (extension_settings[MODULE][key] === undefined) {
 +            extension_settings[MODULE][key] = structuredClone(defaultSettings[key]);
 +        }
 +    }
++
 +    // Guard against a corrupted/legacy value for the per-profile map.
 +    if (typeof extension_settings[MODULE].profiles !== 'object' || extension_settings[MODULE].profiles === null) {
 +        extension_settings[MODULE].profiles = {};
 +    }
++
 +    // Migrate the original default message to the current default so installs that never
 +    // customized it pick up the improved wording (custom messages are left untouched).
 +    if (extension_settings[MODULE].message === LEGACY_DEFAULT_MESSAGE) {
 +        extension_settings[MODULE].message = defaultSettings.message;
 +        saveSettingsDebounced();
 +    }
++
 +    $('#keepalive_enabled').prop('checked', extension_settings[MODULE].enabled);
 +    $('#keepalive_timeout').val(extension_settings[MODULE].timeoutSeconds);
 +    $('#keepalive_message').val(extension_settings[MODULE].message);
 +    renderProfileToggles();
 +}
++
 +/**
 + * Wires up the settings UI control handlers.
 + */
 +function setupListeners() {
 +    $('#keepalive_enabled').on('change', function () {
 +        extension_settings[MODULE].enabled = !!$(this).prop('checked');
 +        saveSettingsDebounced();
 +        scheduleIdleTimer();
 +    });
++
 +    $('#keepalive_timeout').on('input', function () {
 +        extension_settings[MODULE].timeoutSeconds = Number($(this).val()) || 295;
 +        saveSettingsDebounced();
 +        scheduleIdleTimer();
 +    });
++
 +    $('#keepalive_message').on('input', function () {
 +        extension_settings[MODULE].message = String($(this).val());
 +        saveSettingsDebounced();
 +    });
++
 +    // Per-profile toggles are rendered dynamically; use a delegated handler.
 +    $('#keepalive_profiles_list').on('change', '.keepalive_profile_toggle', function () {
 +        const profileId = $(this).attr('data-profile-id');
 +        if (!profileId) {
 +            return;
 +        }
 +        extension_settings[MODULE].profiles[profileId] = !!$(this).prop('checked');
 +        saveSettingsDebounced();
 +        // If the toggled profile is the one currently active, reschedule immediately.
 +        if (profileId === extension_settings.connectionManager?.selectedProfile) {
 +            scheduleIdleTimer();
 +        }
 +    });
 +}
++
 +async function init() {
 +    const settingsHtml = await renderExtensionTemplateAsync(MODULE, 'settings');
 +    $('#extensions_settings2').append(settingsHtml);
++
 +    loadSettings();
 +    setupListeners();
++
 +    // Only the user sending a new message arms keepalive (for the current chat).
 +    eventSource.on(event_types.MESSAGE_SENT, onMessageSent);
++
 +    // These reset the active profile's idle clock (so generation time isn't counted as idle) but
 +    // never arm keepalive on their own — they also fire for background/quiet generations and while
 +    // a chat is loading. They only re-arm the timer if a sent message already armed it.
 +    const activityEvents = [
 +        event_types.MESSAGE_RECEIVED,
 +        event_types.GENERATION_STARTED,
 +        event_types.GENERATION_ENDED,
 +    ];
 +    for (const event of activityEvents) {
 +        eventSource.on(event, markActivity);
 +    }
++
 +    // Opening/switching a chat disarms keepalive — it must be re-armed by a new sent message.
 +    eventSource.on(event_types.CHAT_CHANGED, onChatChanged);
++
 +    // When the active profile changes, re-target the idle timer at the new profile using
 +    // ITS own last-activity time (do NOT mark activity — switching is not using it).
 +    eventSource.on(event_types.CONNECTION_PROFILE_LOADED, scheduleIdleTimer);
++
 +    // Keep the per-profile toggle list in sync with Connection Manager.
 +    eventSource.on(event_types.CONNECTION_PROFILE_CREATED, renderProfileToggles);
 +    eventSource.on(event_types.CONNECTION_PROFILE_UPDATED, renderProfileToggles);
 +    eventSource.on(event_types.CONNECTION_PROFILE_DELETED, renderProfileToggles);
++
 +    scheduleIdleTimer();
 +}

public/scripts/extensions/keepalive/manifest.json+14 -0 Viewed

 +{
 +    "display_name": "Cache Keepalive",
 +    "loading_order": 100,
 +    "requires": [],
 +    "optional": [],
 +    "js": "index.js",
 +    "css": "",
 +    "author": "SillyTavern",
 +    "version": "1.0.0",
 +    "homePage": "https://github.com/SillyTavern/SillyTavern",
 +    "hooks": {
 +        "activate": "init"
 +    }
 +}

public/scripts/extensions/keepalive/settings.html+28 -0 Viewed

 +<div id="keepalive_settings">
 +    <div class="inline-drawer">
 +        <div class="inline-drawer-toggle inline-drawer-header">
 +            <b data-i18n="ext_keepalive_title">Cache Keepalive</b>
 +            <div class="inline-drawer-icon fa-solid fa-circle-chevron-down down"></div>
 +        </div>
 +        <div class="inline-drawer-content">
 +            <label class="checkbox_label" for="keepalive_enabled">
 +                <input id="keepalive_enabled" type="checkbox" />
 +                <span data-i18n="ext_keepalive_enable">Enable cache keepalive (master switch)</span>
 +            </label>
++
 +            <label for="keepalive_timeout" data-i18n="ext_keepalive_timeout">Idle timeout (seconds)</label>
 +            <input id="keepalive_timeout" class="text_pole" type="number" min="60" step="1" />
++
 +            <label for="keepalive_message" data-i18n="ext_keepalive_message">Keepalive message</label>
 +            <input id="keepalive_message" class="text_pole" type="text" />
++
 +            <small data-i18n="ext_keepalive_help">After this many seconds without activity on the active connection profile, the current chat plus this message (sent as a hidden user message) is submitted to that profile to keep its server-side prompt cache warm. The completion is capped to a single token and is never saved to the chat. Sending is briefly locked while it runs. Only the profile you're currently using is pinged; each profile has its own idle timer. Keepalive stays off until you send a new message in the current chat (opening, switching to, or reloading a chat isn't proof its prompt is still cached), and it also skips a ping if its timer fired far later than scheduled (e.g. after the machine slept).</small>
++
 +            <hr>
++
 +            <label data-i18n="ext_keepalive_profiles_label">Keepalive per connection profile</label>
 +            <small data-i18n="ext_keepalive_profiles_desc">Turn keepalive on only for the profiles whose providers support prompt caching (leave the others off so you don't waste requests). The master switch above must be enabled. Profiles default to on.</small>
 +            <div id="keepalive_profiles_list" class="keepalive_profiles_list"></div>
 +        </div>
 +    </div>
 +</div>

public/scripts/extensions/memory/index.js+215 -47 Viewed

     extension_prompt_types,
     generateQuietPrompt,
     is_send_press,
 +    online_status,
     saveSettingsDebounced,
     substituteParamsExtended,
     generateRaw,

 import { SlashCommand } from '../../slash-commands/SlashCommand.js';
 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from '../../slash-commands/SlashCommandArgument.js';
 import { macros, MacroCategory } from '../../macros/macro-system.js';
 import { ConnectionManagerRequestService, countWebLlmTokens, generateWebLlmChatPrompt, getWebLlmContextSize, isWebLlmSupported } from '../shared.js';
 import { commonEnumProviders } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
 import { removeReasoningFromString } from '../../reasoning.js';
 import { MacrosParser } from '/scripts/macros.js';

     maxMessagesPerRequestMax: 250,
     maxMessagesPerRequestStep: 1,
     prompt_builder: prompt_builders.DEFAULT,
 +    summaryPromptRole: extension_prompt_roles.SYSTEM,
 +    summaryConnectionProfile: '',
 };
 +/**
 + * Resolve the configured role for the summarization request prompt.
 + * Only SYSTEM and USER are supported; anything else falls back to SYSTEM.
 + * @returns {number} One of extension_prompt_roles.SYSTEM or extension_prompt_roles.USER
 + */
 +function getSummaryPromptRole() {
 +    return Number(extension_settings.memory.summaryPromptRole) === extension_prompt_roles.USER
 +        ? extension_prompt_roles.USER
 +        : extension_prompt_roles.SYSTEM;
 +}
++
 +let summaryConnectionProfileDropdownInitialized = false;
++
 +/**
 + * Populates the dedicated summarization connection profile dropdown.
 + * Only initializes once to avoid attaching duplicate Connection Manager event listeners
 + * when loadSettings() is called again (e.g. after loading a settings preset).
 + */
 +function initSummaryConnectionProfileDropdown() {
 +    if (summaryConnectionProfileDropdownInitialized) {
 +        return;
 +    }
++
 +    try {
 +        ConnectionManagerRequestService.handleDropdown(
 +            '#memory_summary_connection_profile',
 +            extension_settings.memory.summaryConnectionProfile,
 +            (profile) => {
 +                extension_settings.memory.summaryConnectionProfile = profile?.id ?? '';
 +                saveSettingsDebounced();
 +            },
 +        );
 +        summaryConnectionProfileDropdownInitialized = true;
 +    } catch (error) {
 +        // Connection Manager may be unavailable/disabled; leave the dropdown empty in that case.
 +        console.warn('Summarize: could not populate summary connection profile dropdown', error);
 +    }
 +}
++
 function loadSettings() {
     if (Object.keys(extension_settings.memory).length === 0) {
         Object.assign(extension_settings.memory, defaultSettings);

     $('#memory_template').val(extension_settings.memory.template).trigger('input');
     $('#memory_depth').val(extension_settings.memory.depth).trigger('input');
     $('#memory_role').val(extension_settings.memory.role).trigger('input');
 +    $('#memory_summary_prompt_role').val(extension_settings.memory.summaryPromptRole).trigger('input');
 +    initSummaryConnectionProfileDropdown();
     $(`input[name="memory_position"][value="${extension_settings.memory.position}"]`).prop('checked', true).trigger('input');
     $('#memory_prompt_words_force').val(extension_settings.memory.promptForceWords).trigger('input');
     $(`input[name="memory_prompt_builder"][value="${extension_settings.memory.prompt_builder}"]`).prop('checked', true).trigger('input');

     saveSettingsDebounced();
+}
 +function onMemorySummaryPromptRoleInput() {
 +    const value = $(this).val();
 +    extension_settings.memory.summaryPromptRole = Number(value);
 +    saveSettingsDebounced();
 +}
++
 function onMemoryPositionChange(e) {
     const value = e.target.value;
     extension_settings.memory.position = value;

     const source = args.source || extension_settings.memory.source;
     const prompt = substituteParamsExtended((args.prompt || extension_settings.memory.prompt), { words: extension_settings.memory.promptWords });
 +    const useUserRole = getSummaryPromptRole() === extension_prompt_roles.USER;
     try {
         switch (source) {
             case summary_sources.extras:
                 return await callExtrasSummarizeAPI(text);
             case summary_sources.main: {
 -                return removeReasoningFromString(await generateRaw({ prompt: text, systemPrompt: prompt, responseLength: extension_settings.memory.overrideResponseLength }));
 +                // When the instruction should be a USER message, combine it into the
 +                // user content and clear the system prompt. Otherwise keep it as system.
 +                const rawPrompt = useUserRole ? [prompt, text].filter(x => x).join('\n\n') : text;
 +                const systemPrompt = useUserRole ? '' : prompt;
 +                return removeReasoningFromString(await generateRaw({ prompt: rawPrompt, systemPrompt: systemPrompt, responseLength: extension_settings.memory.overrideResponseLength }));
 +            }
             case summary_sources.webllm: {
 -                const messages = [{ role: 'system', content: prompt }, { role: 'user', content: text }].filter(m => m.content);
 +                const promptRole = useUserRole ? 'user' : 'system';
 +                const messages = [{ role: promptRole, content: prompt }, { role: 'user', content: text }].filter(m => m.content);
                 const params = extension_settings.memory.overrideResponseLength > 0 ? { max_tokens: extension_settings.memory.overrideResponseLength } : {};
                 return await generateWebLlmChatPrompt(messages, params);
+            }

         return null;
+    }
 +    const promptRole = getSummaryPromptRole() === extension_prompt_roles.USER ? 'user' : 'system';
     const messages = [
         { role: 'system'promptRole, content: prompt },
         { role: 'user', content: rawPrompt },
     ];

+    }
+}
 +// Warn at most once per session if a summary connection profile is selected but cannot be
 +// applied because there is no active connection profile to restore afterward.
 +let summaryProfileWarnedNoBaseProfile = false;
++
 +/**
 + * Runs a callback with a specific Connection Manager profile temporarily active, then restores
 + * the previously active profile. This lets the summary be generated by the chosen LLM using the
 + * full summarization pipeline (generateQuietPrompt/generateRaw) under that connection, instead of
 + * a context-free Connection Manager request that some providers run with the wrong model.
 + *
 + * The switch is only performed when a real connection profile is currently active (so it can be
 + * reliably restored). When none is active — i.e. the user drives the API panel manually —
 + * switching to a profile could not be undone without clobbering those manual settings, so we leave
 + * the active model in place and warn once.
 + *
 + * @param {string} targetProfileId Profile to activate for the duration of the callback.
 + * @param {() => Promise<any>} callback Work to run while the target profile is active.
 + * @returns {Promise<any>} The callback's result.
 + */
 +async function withConnectionProfile(targetProfileId, callback) {
 +    const select = /** @type {HTMLSelectElement} */ (document.getElementById('connection_profiles'));
 +    const connectionManager = extension_settings.connectionManager;
 +    const currentProfileId = connectionManager?.selectedProfile;
++
 +    const canSwitch = !!select
 +        && !!connectionManager
 +        && Array.isArray(connectionManager.profiles)
 +        && connectionManager.profiles.some(p => p.id === targetProfileId)
 +        && Array.from(select.options).some(o => o.value === targetProfileId)
 +        && !!currentProfileId // a real profile is active, so it can be restored afterwards
 +        && currentProfileId !== targetProfileId;
++
 +    if (!canSwitch) {
 +        // Selected but no base profile to restore from -> use the active model and warn once.
 +        if (targetProfileId && !currentProfileId && !summaryProfileWarnedNoBaseProfile) {
 +            summaryProfileWarnedNoBaseProfile = true;
 +            toastr.info('The summary connection profile is only applied while a connection profile is active (so the original can be restored). Using the current model.', 'Summarize');
 +        }
 +        return await callback();
 +    }
++
 +    const switchToProfile = async (profileId) => {
 +        const loaded = new Promise(resolve => eventSource.once(event_types.CONNECTION_PROFILE_LOADED, resolve));
 +        const timeout = new Promise(resolve => setTimeout(resolve, 10000));
 +        const index = Array.from(select.options).findIndex(o => o.value === profileId);
 +        select.selectedIndex = index >= 0 ? index : 0;
 +        select.dispatchEvent(new Event('change'));
 +        // Wait for the profile's commands to finish applying (don't hang forever if the event never fires).
 +        await Promise.race([loaded, timeout]);
 +        // Applying a profile reconnects the API asynchronously; generating before it is
 +        // re-established fails instantly, so wait for the connection to come back up
 +        // (mirrors the built-in /profile command). rejectOnTimeout:false -> proceed anyway after the timeout.
 +        await waitUntilCondition(() => online_status !== 'no_connection', 10000, 100, { rejectOnTimeout: false });
 +    };
++
 +    await switchToProfile(targetProfileId);
 +    try {
 +        return await callback();
 +    } finally {
 +        try {
 +            await switchToProfile(currentProfileId);
 +        } catch (err) {
 +            console.error('Summarize: failed to restore the previous connection profile after summarization', err);
 +        }
 +    }
 +}
++
 async function summarizeChatMain(context, force, skipWIAN) {
     const prompt = await getSummaryPromptForNow(context, force);

+    }
     console.log('sending summary prompt');
 -    let summary = '';
 -    let index = null;
 -    if (prompt_builders.DEFAULT === extension_settings.memory.prompt_builder) {
 +    // Runs the configured summary builder (DEFAULT or RAW) against whatever connection is
 -        try {
 +    // currently active. Returns { summary, index }, or null when there is nothing to summarize.
 -            inApiCall = true;
 +    const runConfiguredSummary = async () => {
 -            /** @type {import('../../../script.js').GenerateQuietPromptParams} */
 +        let summary = '';
 -            const params = {
 +        let index = null;
 -                quietPrompt: prompt,
++
 -                skipWIAN: skipWIAN,
 +        if (prompt_builders.DEFAULT === extension_settings.memory.prompt_builder) {
 -                responseLength: extension_settings.memory.overrideResponseLength,
 +            // generateQuietPrompt always injects the instruction as a SYSTEM message
 -            };
 +            // (the QUIET_PROMPT extension prompt has no exposed role parameter).
 -            summary = await generateQuietPrompt(params);
 +            // When a USER role is requested, assemble the chat transcript ourselves
 -        } finally {
 +            // (same source as the raw builder) and deliver the instruction as USER
 -            inApiCall = false;
 +            // content via generateRaw, so the model still receives the chat to
 +            // summarize instead of just the bare instruction.
 +            if (getSummaryPromptRole() === extension_prompt_roles.USER) {
 +                const { rawPrompt } = await getRawSummaryPrompt(context, prompt);
 +                /** @type {import('../../../script.js').GenerateRawParams} */
 +                const params = {
 +                    prompt: [prompt, rawPrompt].filter(x => x).join('\n\n'),
 +                    systemPrompt: '',
 +                    responseLength: extension_settings.memory.overrideResponseLength,
 +                };
 +                summary = removeReasoningFromString(await generateRaw(params));
 +            } else {
 +                /** @type {import('../../../script.js').GenerateQuietPromptParams} */
 +                const params = {
 +                    quietPrompt: prompt,
 +                    skipWIAN: skipWIAN,
 +                    responseLength: extension_settings.memory.overrideResponseLength,
 +                };
 +                summary = await generateQuietPrompt(params);
 +            }
+        }
 -    }
             if ([prompt_builders.RAW_BLOCKING, prompt_builders.RAW_NON_BLOCKING].includes(extension_settings.memory.prompt_builder)) {
                     const lock = extension_settings.memory.prompt_builder === prompt_builders.RAW_BLOCKING;
                     try {
 -            inApiCall = true;
 +                if (lock) {
 -            if (lock) {
 +                    deactivateSendButtons();
 -                deactivateSendButtons();
 +                }
 -            }
                             const { rawPrompt, lastUsedIndex } = await getRawSummaryPrompt(context, prompt);
                             if (lastUsedIndex === null || lastUsedIndex === -1) {
                                     if (force) {
                                             toastr.info('To try again, remove the latest summary.', 'No messages found to summarize');
+                                    }
                                     return null;
+                            }
 -            /** @type {import('../../../script.js').GenerateRawParams} */
 +                // When the summary instruction should be a USER message, deliver it as
 -            const params = {
 +                // user content and leave the system prompt empty. Otherwise keep the
 -                prompt: rawPrompt,
 +                // existing behavior of sending it as the system prompt.
 -                systemPrompt: prompt,
 +                const useUserRole = getSummaryPromptRole() === extension_prompt_roles.USER;
 -                responseLength: extension_settings.memory.overrideResponseLength,
 +                /** @type {import('../../../script.js').GenerateRawParams} */
 -            };
 +                const params = {
 -            const rawSummary = await generateRaw(params);
 +                    prompt: useUserRole ? [prompt, rawPrompt].filter(x => x).join('\n\n') : rawPrompt,
 -            summary = removeReasoningFromString(rawSummary);
 +                    systemPrompt: useUserRole ? '' : prompt,
 -            index = lastUsedIndex;
 +                    responseLength: extension_settings.memory.overrideResponseLength,
 -        } finally {
 +                };
 -            inApiCall = false;
 +                const rawSummary = await generateRaw(params);
 -            if (lock) {
 +                summary = removeReasoningFromString(rawSummary);
 -                activateSendButtons();
 +                index = lastUsedIndex;
 +            } finally {
 +                if (lock) {
 +                    activateSendButtons();
 +                }
+            }
+        }
++
 +        return { summary, index };
 +    };
++
 +    // A dedicated connection profile generates the summary with the chosen LLM by temporarily
 +    // switching the active connection profile (so the full summarization pipeline runs under it),
 +    // then restoring the previous profile. Falls back to the active model when no profile is set
 +    // or no base profile is active to restore.
 +    const summaryConnectionProfile = extension_settings.memory.summaryConnectionProfile;
 +    let result;
 +    try {
 +        inApiCall = true;
 +        result = summaryConnectionProfile
 +            ? await withConnectionProfile(summaryConnectionProfile, runConfiguredSummary)
 +            : await runConfiguredSummary();
 +    } finally {
 +        inApiCall = false;
+    }
 +    if (result === null) {
 +        return null;
 +    }
++
 +    const { summary, index } = result;
++
     if (!summary) {
         console.warn('Empty summary received');
         return;

     $('#memory_template').off('input').on('input', onMemoryTemplateInput);
     $('#memory_depth').off('input').on('input', onMemoryDepthInput);
     $('#memory_role').off('input').on('input', onMemoryRoleInput);
 +    $('#memory_summary_prompt_role').off('input').on('input', onMemorySummaryPromptRoleInput);
     $('input[name="memory_position"]').off('change').on('change', onMemoryPositionChange);
     $('#memory_prompt_words_force').off('input').on('input', onMemoryPromptWordsForceInput);
     $('#memory_prompt_builder_default').off('input').on('input', onMemoryPromptBuilderInput);

public/scripts/extensions/memory/settings.html+9 -0 Viewed

                             </div>
                         </label>
                         <textarea id="memory_prompt" class="text_pole textarea_compact" rows="6" data-i18n="[placeholder]ext_sum_prompt_placeholder" placeholder="This prompt will be sent to AI to request the summary generation. &lcub;&lcub;words&rcub;&rcub; will resolve to the 'Number of words' parameter."></textarea>
 +                        <label for="memory_summary_prompt_role" data-i18n="ext_sum_prompt_role">Summary Prompt Role</label>
 +                        <select id="memory_summary_prompt_role" class="text_pole">
 +                            <option value="0" data-i18n="System">System</option>
 +                            <option value="1" data-i18n="User">User</option>
 +                        </select>
 +                        <small data-i18n="ext_sum_prompt_role_desc">The role used to send the summary request instruction to the model.</small>
 +                        <label for="memory_summary_connection_profile" data-i18n="ext_sum_connection_profile">Summary Connection Profile</label>
 +                        <select id="memory_summary_connection_profile" class="text_pole"></select>
 +                        <small data-i18n="ext_sum_connection_profile_desc">Summarize with a specific connection profile instead of the active model. Leave empty to use the active model.</small>
                         <label for="memory_prompt_words"><span data-i18n="ext_sum_target_length_1">Target summary length</span> <span data-i18n="ext_sum_target_length_2">(</span><span id="memory_prompt_words_value"></span><span data-i18n="ext_sum_target_length_3"> words)</span></label>
                         <input id="memory_prompt_words" type="range" value="{{defaultSettings.promptWords}}" min="{{defaultSettings.promptMinWords}}" max="{{defaultSettings.promptMaxWords}}" step="{{defaultSettings.promptWordsStep}}" />
                         <label for="memory_override_response_length">

public/scripts/extensions/stable-diffusion/index.js+573 -44 Viewed

     getCurrentChatId,
     getRequestHeaders,
     getUserAvatar,
 +    online_status,
     saveSettingsDebounced,
     substituteParams,
     substituteParamsExtended,

     resetScrollHeight,
     saveBase64AsFile,
     stringFormat,
 +    waitUntilCondition,
 } from '../../utils.js';
 import { getMessageTimeStamp, humanizedDateTime } from '../../RossAscends-mods.js';
 import { SECRET_KEYS, secret_state } from '../../secrets.js';
 import { getNovelAnlas, getNovelUnlimitedImageGeneration, loadNovelSubscriptionData } from '../../nai-settings.js';
 import { ConnectionManagerRequestService, getMultimodalCaption } from '../shared.js';
 import { SlashCommandParser } from '../../slash-commands/SlashCommandParser.js';
 import { SlashCommand } from '../../slash-commands/SlashCommand.js';
 import {

     USER_MULTIMODAL: 9,
     FACE_MULTIMODAL: 10,
     FREE_EXTENDED: 11,
 +    CUSTOM: 12,
 };
 const multimodalMap = {

     [generationMode.FACE_MULTIMODAL]: 'Portrait (Multimodal Mode)',
     [generationMode.USER_MULTIMODAL]: 'User (Multimodal Mode)',
     [generationMode.FREE_EXTENDED]: 'Free Mode (LLM-Extended)',
 +    [generationMode.CUSTOM]: 'Custom',
 };
 const triggerWords = {

     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,
++
 +    // Dedicated LLM connection profile for image-prompt generation ('' = use active model)
 +    prompt_generation_profile: '',
++
 +    // User-defined custom wand dropdown entries ({ id, title, prompt })
 +    custom_entries: [],
 };
 +/**
 + * 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',
 +    // The image-prompt LLM profile is independent of the image backend, so it must
 +    // never be captured/swapped by image-generation presets or the fallback retry.
 +    'prompt_generation_profile',
 +    '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)) {
 +        // Skip excluded keys so older presets that were saved before a key was
 +        // excluded (e.g. prompt_generation_profile) can't clobber it on load.
 +        if (PRESET_EXCLUDE_KEYS.includes(key)) {
 +            continue;
 +        }
 +        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());

     });
+}
 +let promptGenerationProfileDropdownInitialized = false;
 +// Warn at most once per session if a prompt-gen profile is selected but cannot be
 +// applied because there is no active connection profile to restore afterward.
 +let promptProfileWarnedNoBaseProfile = false;
++
 +/**
 + * Populates the dedicated prompt-generation connection profile dropdown.
 + * Only initializes once to avoid attaching duplicate Connection Manager event listeners
 + * when loadSettings() is called again (e.g. after loading a settings preset).
 + */
 +function initPromptGenerationProfileDropdown() {
 +    if (promptGenerationProfileDropdownInitialized) {
 +        return;
 +    }
++
 +    try {
 +        ConnectionManagerRequestService.handleDropdown(
 +            '#sd_prompt_generation_profile',
 +            extension_settings.sd.prompt_generation_profile,
 +            (profile) => {
 +                extension_settings.sd.prompt_generation_profile = profile?.id ?? '';
 +                saveSettingsDebounced();
 +            },
 +        );
 +        promptGenerationProfileDropdownInitialized = true;
 +    } catch (error) {
 +        // Connection Manager may be unavailable/disabled; leave the dropdown empty in that case.
 +        console.warn('SD: could not populate prompt-generation profile dropdown', error);
 +    }
 +}
++
 async function loadSettings() {
     // Initialize settings
     if (Object.keys(extension_settings.sd).length === 0) {

         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;
 +    }
++
 +    if (!Array.isArray(extension_settings.sd.custom_entries)) {
 +        extension_settings.sd.custom_entries = [];
 +    }
++
     // 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');

     const resolutionId = getClosestKnownResolution();
     $('#sd_resolution').val(resolutionId);
 +    initPromptGenerationProfileDropdown();
++
     toggleSourceControls();
     addPromptTemplates();
 +    renderCustomEntriesList();
 +    renderCustomDropdownEntries();
     registerFunctionTool();
     await loadSettingOptions();

     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();
 +}
++
 +/**
 + * Rebuilds the custom wand entries list in the settings UI.
 + */
 +function renderCustomEntriesList() {
 +    const container = $('#sd_custom_entries_list');
 +    if (!container.length) {
 +        return;
 +    }
++
 +    container.empty();
++
 +    const entries = Array.isArray(extension_settings.sd.custom_entries) ? extension_settings.sd.custom_entries : [];
++
 +    if (entries.length === 0) {
 +        const empty = $('<small></small>')
 +            .attr('data-i18n', 'No custom entries yet.')
 +            .text('No custom entries yet.');
 +        container.append(empty);
 +        return;
 +    }
++
 +    for (const entry of entries) {
 +        const preview = String(entry.prompt || '').replace(/\s+/g, ' ').trim();
 +        const truncated = preview.length > 80 ? preview.slice(0, 80) + '…' : preview;
++
 +        const titleEl = $('<div></div>').addClass('sd_custom_entry_title').text(entry.title);
 +        const previewEl = $('<small></small>').addClass('sd_custom_entry_preview').text(truncated);
 +        const textBlock = $('<div></div>').addClass('flex1 flexFlowColumn').append(titleEl).append(previewEl);
++
 +        const editButton = $('<div></div>')
 +            .addClass('menu_button menu_button_icon fa-solid fa-pencil')
 +            .attr('data-entry-id', entry.id)
 +            .attr('data-action', 'edit')
 +            .attr('title', 'Edit')
 +            .attr('data-i18n', '[title]Edit');
 +        const deleteButton = $('<div></div>')
 +            .addClass('menu_button menu_button_icon fa-solid fa-trash-can')
 +            .attr('data-entry-id', entry.id)
 +            .attr('data-action', 'delete')
 +            .attr('title', 'Delete')
 +            .attr('data-i18n', '[title]Delete');
++
 +        const row = $('<div></div>')
 +            .addClass('flex-container alignItemsCenter marginTopBot5 sd_custom_entry_row')
 +            .append(textBlock)
 +            .append(editButton)
 +            .append(deleteButton);
++
 +        container.append(row);
 +    }
 +}
++
 +/**
 + * Generates a unique id for a custom entry.
 + * @returns {string} A unique identifier.
 + */
 +function getUniqueCustomEntryId() {
 +    return crypto.randomUUID?.() ?? ('ce_' + Date.now() + '_' + Math.floor(Math.random() * 1e6));
 +}
++
 +/**
 + * Opens a popup to create/edit a custom entry and returns the entered values.
 + * @param {string} title Initial title value.
 + * @param {string} prompt Initial prompt value.
 + * @returns {Promise<{title: string, prompt: string} | null>} Entered values, or null if cancelled.
 + */
 +async function showCustomEntryPopup(title, prompt) {
 +    const form = $('<div></div>').addClass('flex-container flexFlowColumn');
 +    const titleLabel = $('<label></label>').attr('data-i18n', 'Title').text('Title');
 +    const titleInput = $('<input>')
 +        .addClass('text_pole')
 +        .attr('type', 'text')
 +        .attr('id', 'sd_custom_entry_title_input')
 +        .val(title || '');
 +    const promptLabel = $('<label></label>').attr('data-i18n', 'Prompt').text('Prompt');
 +    const promptInput = $('<textarea></textarea>')
 +        .addClass('text_pole textarea_compact')
 +        .attr('id', 'sd_custom_entry_prompt_input')
 +        .attr('rows', 5)
 +        .val(prompt || '');
++
 +    form.append(titleLabel).append(titleInput).append(promptLabel).append(promptInput);
++
 +    const popup = new Popup(form, POPUP_TYPE.CONFIRM, '', { okButton: t`Save`, cancelButton: t`Cancel` });
 +    const result = await popup.show();
++
 +    if (!result) {
 +        return null;
 +    }
++
 +    return {
 +        title: String(titleInput.val() ?? '').trim(),
 +        prompt: String(promptInput.val() ?? '').trim(),
 +    };
 +}
++
 +async function onAddCustomEntryClick() {
 +    const values = await showCustomEntryPopup('', '');
++
 +    if (!values) {
 +        return;
 +    }
++
 +    if (!values.title || !values.prompt) {
 +        toastr.warning(t`Both a title and a prompt are required.`, t`Image Generation`);
 +        return;
 +    }
++
 +    if (!Array.isArray(extension_settings.sd.custom_entries)) {
 +        extension_settings.sd.custom_entries = [];
 +    }
++
 +    extension_settings.sd.custom_entries.push({
 +        id: getUniqueCustomEntryId(),
 +        title: values.title,
 +        prompt: values.prompt,
 +    });
++
 +    saveSettingsDebounced();
 +    renderCustomEntriesList();
 +    renderCustomDropdownEntries();
 +}
++
 +async function onEditCustomEntryClick(id) {
 +    const entries = Array.isArray(extension_settings.sd.custom_entries) ? extension_settings.sd.custom_entries : [];
 +    const entry = entries.find(e => e.id === id);
++
 +    if (!entry) {
 +        return;
 +    }
++
 +    const values = await showCustomEntryPopup(entry.title, entry.prompt);
++
 +    if (!values) {
 +        return;
 +    }
++
 +    if (!values.title || !values.prompt) {
 +        toastr.warning(t`Both a title and a prompt are required.`, t`Image Generation`);
 +        return;
 +    }
++
 +    entry.title = values.title;
 +    entry.prompt = values.prompt;
++
 +    saveSettingsDebounced();
 +    renderCustomEntriesList();
 +    renderCustomDropdownEntries();
 +}
++
 +async function onDeleteCustomEntryClick(id) {
 +    const entries = Array.isArray(extension_settings.sd.custom_entries) ? extension_settings.sd.custom_entries : [];
 +    const index = entries.findIndex(e => e.id === id);
++
 +    if (index === -1) {
 +        return;
 +    }
++
 +    const confirmed = await callGenericPopup(t`Are you sure you want to delete the entry "${entries[index].title}"?`, POPUP_TYPE.CONFIRM, '', { okButton: t`Delete`, cancelButton: t`Cancel` });
++
 +    if (!confirmed) {
 +        return;
 +    }
++
 +    entries.splice(index, 1);
 +    saveSettingsDebounced();
 +    renderCustomEntriesList();
 +    renderCustomDropdownEntries();
 +}
++
 /**
  * Modifies prompt based on user inputs.
  * @param {string} prompt Prompt to refine

+}
 function getGenerationType(prompt) {
 +    // Custom wand entries use the trigger convention 'custom_<id>' and bypass
 +    // the multimodal/free_extend transforms applied to the built-in triggers.
 +    const trimmedPrompt = String(prompt).trim();
 +    if (Array.isArray(extension_settings.sd.custom_entries)) {
 +        const customEntry = extension_settings.sd.custom_entries.find(e => ('custom_' + e.id) === trimmedPrompt);
 +        if (customEntry) {
 +            return generationMode.CUSTOM;
 +        }
 +    }
++
     let mode = generationMode.FREE;
     for (const [key, values] of Object.entries(triggerWords)) {

+}
 function getQuietPrompt(mode, trigger) {
 +    if (mode === generationMode.CUSTOM) {
 +        const entry = Array.isArray(extension_settings.sd.custom_entries)
 +            ? extension_settings.sd.custom_entries.find(e => ('custom_' + e.id) === String(trigger).trim())
 +            : undefined;
 +        return entry ? entry.prompt : trigger;
 +    }
++
     if (mode === generationMode.FREE) {
         return trigger;
+    }

  */
 async function generatePrompt(quietPrompt) {
     const toast = toastr.info('Generating image prompt with an LLM...', 'Image Generation');
 -    const reply = await generateQuietPrompt({ quietPrompt });
 +    const profileId = extension_settings.sd.prompt_generation_profile;
 +    let reply;
++
 +    try {
 +        reply = profileId
 +            ? await withConnectionProfile(profileId, () => generateQuietPrompt({ quietPrompt }))
 +            : await generateQuietPrompt({ quietPrompt });
 +    } finally {
 +        toastr.clear(toast);
 +    }
++
     const processedReply = processReply(reply);
 -    toastr.clear(toast);
     if (!processedReply) {
         toastr.error('Prompt generation produced no text. Make sure you\'re using a valid instruct template and try again', 'Image Generation');

+}
 /**
 + * Runs a callback with a specific Connection Manager profile temporarily active,
 + * then restores the previously active profile. This lets the image prompt be
 + * generated by the chosen LLM *with the full chat context* (via generateQuietPrompt),
 + * instead of a context-free one-off request.
 + *
 + * The switch is only performed when a real connection profile is currently active
 + * (so it can be reliably restored). When no profile is active — i.e. the user drives
 + * the API panel manually — switching to a profile could not be undone without
 + * clobbering those manual settings, so we leave the active model in place and warn once.
 + *
 + * @param {string} targetProfileId Profile to activate for the duration of the callback.
 + * @param {() => Promise<any>} callback Work to run while the target profile is active.
 + * @returns {Promise<any>} The callback's result.
 + */
 +async function withConnectionProfile(targetProfileId, callback) {
 +    const select = /** @type {HTMLSelectElement} */ (document.getElementById('connection_profiles'));
 +    const connectionManager = extension_settings.connectionManager;
 +    const currentProfileId = connectionManager?.selectedProfile;
++
 +    const canSwitch = !!select
 +        && !!connectionManager
 +        && Array.isArray(connectionManager.profiles)
 +        && connectionManager.profiles.some(p => p.id === targetProfileId)
 +        && Array.from(select.options).some(o => o.value === targetProfileId)
 +        && !!currentProfileId // a real profile is active, so it can be restored afterwards
 +        && currentProfileId !== targetProfileId;
++
 +    if (!canSwitch) {
 +        // Selected but no base profile to restore from -> use the active model and warn once.
 +        if (targetProfileId && !currentProfileId && !promptProfileWarnedNoBaseProfile) {
 +            promptProfileWarnedNoBaseProfile = true;
 +            toastr.info('The image-prompt LLM profile is only applied while a connection profile is active (so the original can be restored). Using the current model.', 'Image Generation');
 +        }
 +        return await callback();
 +    }
++
 +    const switchToProfile = async (profileId) => {
 +        const loaded = new Promise(resolve => eventSource.once(event_types.CONNECTION_PROFILE_LOADED, resolve));
 +        const index = Array.from(select.options).findIndex(o => o.value === profileId);
 +        select.selectedIndex = index >= 0 ? index : 0;
 +        select.dispatchEvent(new Event('change'));
 +        // Wait for the profile's commands to finish applying (don't hang forever if the event never fires).
 +        await Promise.race([loaded, delay(10000)]);
 +        // Applying a profile reconnects the API, which is asynchronous. Generating before the
 +        // connection is re-established fails instantly, so wait for it to come back up
 +        // (mirrors the built-in /profile command). rejectOnTimeout:false -> proceed anyway after the timeout.
 +        await waitUntilCondition(() => online_status !== 'no_connection', 10000, 100, { rejectOnTimeout: false });
 +    };
++
 +    await switchToProfile(targetProfileId);
 +    try {
 +        return await callback();
 +    } finally {
 +        try {
 +            await switchToProfile(currentProfileId);
 +        } catch (err) {
 +            console.error('SD: failed to restore the previous connection profile after image-prompt generation', err);
 +        }
 +    }
 +}
++
 +/**
  * Sends a request to image generation endpoint and processes the result.
  * @param {number} generationType Type of image generation
  * @param {string} prompt Prompt to be used for image generation

     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 currentChatIdnegativePrompt = getCurrentChatIdsubstituteParams(combinePrefixes(additionalNegativePrefix, negativePrefix));
 -    try {
 +        let result = { format: '', data: '' };
         switch (extension_settings.sd.source) {
             case sources.extras:
                 result = await generateExtrasImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.horde:
                 result = await generateHordeImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.vlad:
                 result = await generateAutoImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.drawthings:
                 result = await generateDrawthingsImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.auto:
                 result = await generateAutoImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.sdcpp:
                 result = await generateSdcppImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.novel:
                 result = await generateNovelImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.openai:
                 result = await generateOpenAiImage(prefixedPrompt, signalattemptSignal);
                 break;
             case sources.aimlapi:
                 result = await generateAimlapiImage(prefixedPrompt, signalattemptSignal);
                 break;
             case sources.comfy:
                 switch (extension_settings.sd.comfy_type) {
                     case comfyTypes.runpod_serverless:
                         result = await generateComfyRunPodImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                         break;
                     case comfyTypes.standard:
                         result = await generateComfyImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                         break;
                     default:
                         throw new Error('Unknown comfyUI server type.');
+                }
                 break;
             case sources.togetherai:
                 result = await generateTogetherAIImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.pollinations:
                 result = await generatePollinationsImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.stability:
                 result = await generateStabilityImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.huggingface:
                 result = await generateHuggingFaceImage(prefixedPrompt, signalattemptSignal);
                 break;
             case sources.chutes:
                 result = await generateChutesImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.electronhub:
                 result = await generateElectronHubImage(prefixedPrompt, signalattemptSignal);
                 break;
             case sources.nanogpt:
                 result = await generateNanoGPTImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.bfl:
                 result = await generateBflImage(prefixedPrompt, signalattemptSignal);
                 break;
             case sources.falai:
                 result = await generateFalaiImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.xai:
                 result = await generateXAIImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.google:
                 result = await generateGoogleImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 break;
             case sources.zai:
                 result = await generateZaiImage(prefixedPrompt, signalattemptSignal);
                 break;
             case sources.openrouter:
                 result = await generateOpenRouterImage(prefixedPrompt, signalattemptSignal);
                 break;
             case sources.workersai:
                 result = await generateWorkersAIImage(prefixedPrompt, negativePrompt, signalattemptSignal);
                 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_dropdown [id]').on('click', function () {
 +    renderCustomDropdownEntries();
++
 +    // Use event delegation so dynamically-added custom entries also respond to clicks.
 +    $('#sd_dropdown').on('click', 'li[id]', function () {
         dropdown.fadeOut(animation_duration);
         const id = $(this).attr('id');
         const idParamMap = {

         if (param) {
             console.log('doing /sd ' + param);
             generatePicture(initiators.wand, {}, param);
 +            return;
 +        }
++
 +        if (id && id.startsWith('sd_custom_')) {
 +            const entryId = id.slice('sd_custom_'.length);
 +            console.log('doing /sd custom_' + entryId);
 +            generatePicture(initiators.wand, {}, 'custom_' + entryId);
+        }
     });
+}
 +/**
 + * Renders the user-defined custom entries into the wand dropdown.
 + * Removes any previously rendered custom entries first.
 + */
 +function renderCustomDropdownEntries() {
 +    const list = $('#sd_dropdown ul.list-group');
 +    if (!list.length) {
 +        return;
 +    }
++
 +    list.find('li.sd_custom_entry').remove();
++
 +    const entries = Array.isArray(extension_settings.sd.custom_entries) ? extension_settings.sd.custom_entries : [];
 +    for (const entry of entries) {
 +        const li = $('<li></li>')
 +            .addClass('list-group-item sd_custom_entry')
 +            .attr('id', 'sd_custom_' + entry.id)
 +            .text(entry.title);
 +        list.append(li);
 +    }
 +}
++
 function isValidState() {
     switch (extension_settings.sd.source) {
         case sources.extras:

     $('#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_custom_entry_add').on('click', onAddCustomEntryClick);
 +    $('#sd_custom_entries_list').on('click', '[data-action]', function () {
 +        const id = $(this).attr('data-entry-id');
 +        const action = $(this).attr('data-action');
 +        if (action === 'edit') {
 +            onEditCustomEntryClick(id);
 +        } else if (action === 'delete') {
 +            onDeleteCustomEntryClick(id);
 +        }
 +    });
     $('#sd_character_prompt_block').hide();
     $('#sd_interactive_mode').on('input', onInteractiveModeInput);
     $('#sd_openai_style').on('change', onOpenAiStyleSelect);

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

                 <input id="sd_minimal_prompt_processing" type="checkbox" />
                 <span data-i18n="sd_minimal_prompt_processing_txt">Minimal response prompt processing</span>
             </label>
 +            <label for="sd_prompt_generation_profile" data-i18n="Prompt generation connection profile">Prompt generation connection profile</label>
 +            <select id="sd_prompt_generation_profile" class="text_pole"></select>
 +            <small data-i18n="sd_prompt_generation_profile_small">Connection profile always used to generate the image prompt text. Leave empty to use the currently active model.</small>
 +            <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>

         <div id="sd_prompt_templates" class="inline-drawer-content">
         </div>
     </div>
 +    <div class="inline-drawer">
 +        <div class="inline-drawer-toggle inline-drawer-header">
 +            <b data-i18n="Custom Wand Entries">Custom Wand Entries</b>
 +            <div class="inline-drawer-icon fa-solid fa-circle-chevron-down down"></div>
 +        </div>
 +        <div class="inline-drawer-content">
 +            <small data-i18n="sd_custom_entries_small">Add your own entries to the image generation wand dropdown. Clicking an entry uses its prompt as the LLM instruction, just like the built-in entries.</small>
 +            <div class="flex-container marginTopBot5">
 +                <div id="sd_custom_entry_add" class="menu_button menu_button_icon">
 +                    <i class="fa-solid fa-plus"></i>
 +                    <span data-i18n="Add entry">Add entry</span>
 +                </div>
 +            </div>
 +            <div id="sd_custom_entries_list"></div>
 +        </div>
 +    </div>
 </div>

public/scripts/extensions/stable-diffusion/style.css+14 -0 Viewed

     top: 0;
     transform: translateX(-50%);
+}
++
 +.sd_custom_entry_row .sd_custom_entry_title {
 +    font-weight: bold;
 +    overflow: hidden;
 +    text-overflow: ellipsis;
 +    white-space: nowrap;
 +}
++
 +.sd_custom_entry_row .sd_custom_entry_preview {
 +    opacity: 0.7;
 +    overflow: hidden;
 +    text-overflow: ellipsis;
 +    white-space: nowrap;
 +}