Merge branch 'staging' into swipe-nums-for-all-mes

77470502339c829640eeab9fe78ff66c7395acf5

Cohee <18619528+Cohee1207@users.noreply.github.com>

Parents: e32b70104518491bdd3da994835106a01007e0c7 be103534e4122ada55d1416f8cc802232de59aac

UpdateAndStart.bat+12 -3 Viewed

 pushd %~dp0
 git --version > nul 2>&1
 if %errorlevel% neq 0 (
     echo Git[91mGit is not installed on this system. Skipping update.[0m
 -    echo If you installed with a zip file, you will need to download the new zip and install it manually.
 +    echo Install it from https://git-scm.com/downloads
 +    goto end
 ) else (
 +    if not exist .git (
 +        echo [91mNot running from a Git repository. Reinstall using an officially supported method to get updates.[0m
 +        echo See: https://docs.sillytavern.app/installation/windows/
 +        goto end
 +    )
     call git pull --rebase --autostash
     if %errorlevel% neq 0 (
         REM incase there is still something wrong
         echo There[91mThere were errors while updating. Please download the latest version manually.[0m
 +        echo See the update FAQ at https://docs.sillytavern.app/usage/update/#common-update-problems
 +        goto end
+    )
+)
 set NODE_ENV=production
 call npm install --no-audit --no-fund --loglevel=error --no-progress --omit=dev
 node server.js %*
 +:end
 pause
 popd

UpdateForkAndStart.bat+10 -3 Viewed

 echo Checking Git installation
 git --version > nul 2>&1
 if %errorlevel% neq 0 (
     echo Git[91mGit is not installed on this system. Skipping update.[0m
 -    echo If you installed with a zip file, you will need to download the new zip and install it manually.
 +    echo Install it from https://git-scm.com/downloads
 +    goto end
 +)
++
 +if not exist .git (
 +    echo [91mNot running from a Git repository. Reinstall using an officially supported method to get updates.[0m
 +    echo See: https://docs.sillytavern.app/installation/windows/
     goto end
+)

 :install
 if %errorlevel% neq 0 (
     echo There[91mThere were errors while updating. Please check manually.[0m
 +    echo See the update FAQ at https://docs.sillytavern.app/usage/update/#common-update-problems
     goto end
+)

default/config.yaml+0 -1 Viewed

   classificationModel: Cohee/distilbert-base-uncased-go-emotions-onnx
   captioningModel: Xenova/vit-gpt2-image-captioning
   embeddingModel: Cohee/jina-embeddings-v2-base-en
 -  promptExpansionModel: Cohee/fooocus_expansion-onnx
   speechToTextModel: Xenova/whisper-small
   textToSpeechModel: Xenova/speecht5_tts
 # -- OPENAI CONFIGURATION --

public/script.js+3 -1 Viewed

  * @param {boolean} [compact] Send as a compact display message.
  * @param {string} [name] Name of the user sending the message. Defaults to name1.
  * @param {string} [avatar] Avatar of the user sending the message. Defaults to user_avatar.
  * @returns {Promise<voidany>} A promise that resolves whento the message when it is inserted.
  */
 export async function sendMessageAsUser(messageText, messageBias, insertAt = null, compact = false, name = name1, avatar = user_avatar) {
     messageText = getRegexedString(messageText, regex_placement.USER_INPUT);

@@ -4844,6 +4844,8 @@ export async function sendMessageAsUser(messageText, messageBias, insertAt = nul
4844	4844	await eventSource.emit(event_types.USER_MESSAGE_RENDERED, chat_id);
4845	4845	await saveChatConditional();
4846	4846	}
	4847	+
	4848	+ return message;
4847	4849	}
4848	4850
4849	4851	/**

public/scripts/extensions/expressions/index.js+33 -7 Viewed

 import { isFunctionCallingSupported } from '../../openai.js';
 import { SlashCommandEnumValue, enumTypes } from '../../slash-commands/SlashCommandEnumValue.js';
 import { commonEnumProviders } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
 +import { slashCommandReturnHelper } from '../../slash-commands/SlashCommandReturnHelper.js';
 +import { SlashCommandClosure } from '../../slash-commands/SlashCommandClosure.js';
 export { MODULE_NAME };
 const MODULE_NAME = 'expressions';

         name: 'classify-expressions',
         aliases: ['expressions'],
         callback: async (args) => {
 -            const list = await getExpressionsList();
 +            /** @type {import('../../slash-commands/SlashCommandReturnHelper.js').SlashCommandReturnType} */
 -            switch (String(args.format).toLowerCase()) {
 +            // @ts-ignore
 -                case 'json':
 +            let returnType = args.return;
 -                    return JSON.stringify(list);
++
 -                default:
 +            // Old legacy return type handling
 -                    return list.join(', ');
 +            if (args.format) {
 +                toastr.warning(`Legacy argument 'format' with value '${args.format}' is deprecated. Please use 'return' instead. Routing to the correct return type...`, 'Deprecation warning');
 +                const type = String(args?.format).toLowerCase().trim();
 +                switch (type) {
 +                    case 'json':
 +                        returnType = 'object';
 +                        break;
 +                    default:
 +                        returnType = 'pipe';
 +                        break;
 +                }
+            }
++
 +            // Now the actual new return type handling
 +            const list = await getExpressionsList();
++
 +            return await slashCommandReturnHelper.doReturn(returnType ?? 'pipe', list, { objectToStringFunc: list => list.join(', ') });
         },
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'pipe',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
 +            // TODO remove some day
 +            SlashCommandNamedArgument.fromProps({
                 name: 'format',
                 description: '!!! DEPRECATED - use "return" instead !!! The format to return the list in: comma-separated plain text or JSON array. Default is plain text.',
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumList: [
                     new SlashCommandEnumValue('plain', null, enumTypes.enum, ', '),

public/scripts/extensions/stable-diffusion/index.js+326 -59 Viewed

 } from '../../../script.js';
 import { getApiUrl, getContext, extension_settings, doExtrasFetch, modules, renderExtensionTemplateAsync, writeExtensionField } from '../../extensions.js';
 import { selected_group } from '../../group-chats.js';
 import { stringFormat, initScrollHeight, resetScrollHeight, getCharaFilename, saveBase64AsFile, getBase64Async, delay, isTrueBoolean, debounce, isFalseBoolean } from '../../utils.js';
 import { getMessageTimeStamp, humanizedDateTime } from '../../RossAscends-mods.js';
 import { SECRET_KEYS, secret_state, writeSecret } from '../../secrets.js';
 import { getNovelUnlimitedImageGeneration, getNovelAnlas, loadNovelSubscriptionData } from '../../nai-settings.js';

 import { debounce_timeout } from '../../constants.js';
 import { SlashCommandEnumValue } from '../../slash-commands/SlashCommandEnumValue.js';
 import { POPUP_RESULT, POPUP_TYPE, Popup, callGenericPopup } from '../../popup.js';
 +import { commonEnumProviders } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
 export { MODULE_NAME };
 const MODULE_NAME = 'sd';

     // Refine mode
     refine_mode: false,
 -    expand: false,
     interactive_mode: false,
     multimodal_captioning: false,
     snap: false,

     drawthings_auth: '',
     hr_upscaler: 'Latent',
     hr_scale: 21.0,
     hr_scale_min: 1.0,
     hr_scale_max: 4.0,
     hr_scale_step: 0.1,

     clip_skip: 1,
     // NovelAI settings
 -    novel_upscale_ratio_min: 1.0,
 -    novel_upscale_ratio_max: 4.0,
 -    novel_upscale_ratio_step: 0.1,
 -    novel_upscale_ratio: 1.0,
     novel_anlas_guard: false,
     novel_sm: false,
     novel_sm_dyn: false,

     $('#sd_hr_scale').val(extension_settings.sd.hr_scale).trigger('input');
     $('#sd_denoising_strength').val(extension_settings.sd.denoising_strength).trigger('input');
     $('#sd_hr_second_pass_steps').val(extension_settings.sd.hr_second_pass_steps).trigger('input');
 -    $('#sd_novel_upscale_ratio').val(extension_settings.sd.novel_upscale_ratio).trigger('input');
     $('#sd_novel_anlas_guard').prop('checked', extension_settings.sd.novel_anlas_guard);
     $('#sd_novel_sm').prop('checked', extension_settings.sd.novel_sm);
     $('#sd_novel_sm_dyn').prop('checked', extension_settings.sd.novel_sm_dyn);

     $('#sd_restore_faces').prop('checked', extension_settings.sd.restore_faces);
     $('#sd_enable_hr').prop('checked', extension_settings.sd.enable_hr);
     $('#sd_refine_mode').prop('checked', extension_settings.sd.refine_mode);
 -    $('#sd_expand').prop('checked', extension_settings.sd.expand);
     $('#sd_multimodal_captioning').prop('checked', extension_settings.sd.multimodal_captioning);
     $('#sd_auto_url').val(extension_settings.sd.auto_url);
     $('#sd_auto_auth').val(extension_settings.sd.auto_auth);

     saveSettingsDebounced();
+}
 -async function expandPrompt(prompt) {
 -    try {
 -        const response = await fetch('/api/sd/expand', {
 -            method: 'POST',
 -            headers: getRequestHeaders(),
 -            body: JSON.stringify({ prompt: prompt }),
 -        });
+-
 -        if (!response.ok) {
 -            throw new Error('API returned an error.');
 -        }
+-
 -        const data = await response.json();
 -        return data.prompt;
 -    } catch {
 -        return prompt;
 -    }
 -}
+-
 /**
  * Modifies prompt based on auto-expansion and user inputs.
  * @param {string} prompt Prompt to refine
 - * @param {boolean} allowExpand Whether to allow auto-expansion
  * @param {boolean} isNegative Whether the prompt is a negative one
  * @returns {Promise<string>} Refined prompt
  */
 async function refinePrompt(prompt, allowExpand, isNegative = false) {
 -    if (allowExpand && extension_settings.sd.expand) {
 -        prompt = await expandPrompt(prompt);
 -    }
+-
     if (extension_settings.sd.refine_mode) {
         const text = isNegative ? '<h3>Review and edit the <i>negative</i> prompt:</h3>' : '<h3>Review and edit the prompt:</h3>';
         const refinedPrompt = await callGenericPopup(text + 'Press "Cancel" to abort the image generation.', POPUP_TYPE.INPUT, prompt.trim(), { rows: 5, okButton: 'Continue' });

     return process(result);
+}
 -function onExpandInput() {
 -    extension_settings.sd.expand = !!$(this).prop('checked');
 -    saveSettingsDebounced();
 -}
+-
 function onRefineModeInput() {
     extension_settings.sd.refine_mode = !!$('#sd_refine_mode').prop('checked');
     saveSettingsDebounced();

     toastr.info(`Free image generation: ${unlimitedGeneration ? 'Yes' : 'No'}`, `Anlas: ${anlas}`);
+}
 -function onNovelUpscaleRatioInput() {
 -    extension_settings.sd.novel_upscale_ratio = Number($('#sd_novel_upscale_ratio').val());
 -    $('#sd_novel_upscale_ratio_value').val(extension_settings.sd.novel_upscale_ratio.toFixed(1));
 -    saveSettingsDebounced();
 -}
+-
 function onNovelAnlasGuardInput() {
     extension_settings.sd.novel_anlas_guard = !!$('#sd_novel_anlas_guard').prop('checked');
     saveSettingsDebounced();

+}
 /**
 + * Ensure that the selected option exists in the dropdown.
 + * @param {string} setting Setting key
 + * @param {string} selector Dropdown selector
 + * @returns {void}
 + */
 +function ensureSelectionExists(setting, selector) {
 +    /** @type {HTMLSelectElement} */
 +    const selectElement = document.querySelector(selector);
 +    if (!selectElement) {
 +        return;
 +    }
 +    const options = Array.from(selectElement.options);
 +    const value = extension_settings.sd[setting];
 +    if (selectElement.selectedOptions.length && !options.some(option => option.value === value)) {
 +        extension_settings.sd[setting] = selectElement.selectedOptions[0].value;
 +    }
 +}
++
 +/**
  * Generates an image based on the given trigger word.
  * @param {string} initiator The initiator of the image generation
  * @param {Record<string, object>} args Command arguments

         return;
+    }
 -    extension_settings.sd.sampler = $('#sd_sampler').find(':selected').val();
 +    ensureSelectionExists('sampler', '#sd_sampler');
 -    extension_settings.sd.model = $('#sd_model').find(':selected').val();
 +    ensureSelectionExists('model', '#sd_model');
     trigger = trigger.trim();
     const generationType = getGenerationType(trigger);

@@ -2441,7 +2419,7 @@ async function getPrompt(generationType, message, trigger, quietPrompt, combineN
2441	2419	}
2442	2420
2443	2421	if (generationType !== generationMode.FREE) {
2444	2422	prompt = await refinePrompt(prompt, truefalse);
2445	2423	}
2446	2424
2447	2425	return prompt;

@@ -2469,7 +2447,7 @@ function generateFreeModePrompt(trigger, combineNegatives) {
2469	2447	return message.original_avatar.replace(/\.[^/.]+$/, '');
2470	2448	}
2471	2449	}
2472		- throw new Error('No usable messages found.');
	2450	+ return '';
2473	2451	};
2474	2452
2475	2453	const key = getLastCharacterKey();

             width: width,
             height: height,
             negative_prompt: negativePrompt,
             upscale_ratio: extension_settings.sd.novel_upscale_ratiohr_scale,
             decrisper: extension_settings.sd.novel_decrisper,
             sm: sm,
             sm_dyn: sm_dyn,

     try {
         setBusyIcon(true);
         if (hasSavedImage) {
             const prompt = await refinePrompt(message.extra.title, false, false);
             const negative = hasSavedNegative ? await refinePrompt(message.extra.negative, false, true) : '';
             message.extra.title = prompt;
             const generationType = message?.extra?.generationType ?? generationMode.FREE;

                 eventSource.once(CUSTOM_STOP_EVENT, stopListener);
                 const callback = () => { };
                 const hasNegative = message.extra.negative;
                 const prompt = await refinePrompt(message.extra.title, false, false);
                 const negativePromptPrefix = hasNegative ? await refinePrompt(message.extra.negative, false, true) : '';
                 const characterName = context.groupId
                     ? context.groups[Object.keys(context.groups).filter(x => context.groups[x].id === context.groupId)[0]]?.id?.toString()
                     : context.characters[context.characterId]?.name;

     await context.saveChat();
+}
 +/**
 + * Applies the command arguments to the extension settings.
 + * @typedef {import('../../slash-commands/SlashCommand.js').NamedArguments} NamedArguments
 + * @typedef {import('../../slash-commands/SlashCommand.js').NamedArgumentsCapture} NamedArgumentsCapture
 + * @param {NamedArguments | NamedArgumentsCapture} args - Command arguments
 + * @returns {Record<string, any>} - Current settings before applying the command arguments
 + */
 +function applyCommandArguments(args) {
 +    const overrideSettings = {};
 +    const currentSettings = {};
 +    const settingMap = {
 +        'edit': 'refine_mode',
 +        'extend': 'free_extend',
 +        'multimodal': 'multimodal_captioning',
 +        'seed': 'seed',
 +        'width': 'width',
 +        'height': 'height',
 +        'steps': 'steps',
 +        'cfg': 'scale',
 +        'skip': 'clip_skip',
 +        'model': 'model',
 +        'sampler': 'sampler',
 +        'scheduler': 'scheduler',
 +        'vae': 'vae',
 +        'upscaler': 'hr_upscaler',
 +        'scale': 'hr_scale',
 +        'hires': 'enable_hr',
 +        'denoise': 'denoising_strength',
 +        '2ndpass': 'hr_second_pass_steps',
 +        'faces': 'restore_faces',
 +    };
++
 +    for (const [param, setting] of Object.entries(settingMap)) {
 +        if (args[param] === undefined || defaultSettings[setting] === undefined) {
 +            continue;
 +        }
 +        currentSettings[setting] = extension_settings.sd[setting];
 +        const value = String(args[param]);
 +        const type = typeof defaultSettings[setting];
 +        switch (type) {
 +            case 'boolean':
 +                overrideSettings[setting] = isTrueBoolean(value) || !isFalseBoolean(value);
 +                break;
 +            case 'number':
 +                overrideSettings[setting] = Number(value);
 +                break;
 +            default:
 +                overrideSettings[setting] = value;
 +                break;
 +        }
 +    }
++
 +    Object.assign(extension_settings.sd, overrideSettings);
 +    return currentSettings;
 +}
++
 jQuery(async () => {
     await addSDGenButtons();
 +    const getSelectEnumProvider = (id, text) => () => Array.from(document.querySelectorAll(`#${id} > [value]`)).map(x => new SlashCommandEnumValue(x.getAttribute('value'), text ? x.textContent : null));
++
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'imagine',
 -        callback: (args, trigger) => generatePicture(initiators.command, args, String(trigger)),
 +        returns: 'URL of the generated image, or an empty string if the generation failed',
 +        callback: async (args, trigger) => {
 +            const currentSettings = applyCommandArguments(args);
++
 +            try {
 +                return await generatePicture(initiators.command, args, String(trigger));
 +            } catch (error) {
 +                console.error('Failed to generate image:', error);
 +                return '';
 +            } finally {
 +                if (Object.keys(currentSettings).length) {
 +                    Object.assign(extension_settings.sd, currentSettings);
 +                    saveSettingsDebounced();
 +                }
 +            }
 +        },
         aliases: ['sd', 'img', 'image'],
         namedArgumentList: [
             new SlashCommandNamedArgument(

                 name: 'negative',
                 description: 'negative prompt prefix',
                 typeList: [ARGUMENT_TYPE.STRING],
 +                isRequired: false,
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'extend',
 +                description: 'auto-extend free mode prompts with the LLM',
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                enumProvider: commonEnumProviders.boolean('trueFalse'),
 +                isRequired: false,
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'edit',
 +                description: 'edit the prompt before generation',
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                enumProvider: commonEnumProviders.boolean('trueFalse'),
 +                isRequired: false,
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'multimodal',
 +                description: 'use multimodal captioning (for portraits only)',
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                enumProvider: commonEnumProviders.boolean('trueFalse'),
 +                isRequired: false,
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'snap',
 +                description: 'snap auto-adjusted dimensions to the nearest known resolution (portraits and backgrounds only)',
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                enumProvider: commonEnumProviders.boolean('trueFalse'),
 +                isRequired: false,
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'seed',
 +                description: 'random seed',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'width',
 +                description: 'image width',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'height',
 +                description: 'image height',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'steps',
 +                description: 'number of steps',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'cfg',
 +                description: 'CFG scale',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'skip',
 +                description: 'CLIP skip layers',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'model',
 +                description: 'model override',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                acceptsMultiple: false,
 +                forceEnum: true,
 +                enumProvider: getSelectEnumProvider('sd_model', true),
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'sampler',
 +                description: 'sampler override',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                acceptsMultiple: false,
 +                forceEnum: true,
 +                enumProvider: getSelectEnumProvider('sd_sampler', false),
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'scheduler',
 +                description: 'scheduler override',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                acceptsMultiple: false,
 +                forceEnum: true,
 +                enumProvider: getSelectEnumProvider('sd_scheduler', false),
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'vae',
 +                description: 'VAE name override',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                acceptsMultiple: false,
 +                forceEnum: true,
 +                enumProvider: getSelectEnumProvider('sd_vae', false),
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'upscaler',
 +                description: 'upscaler override',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                acceptsMultiple: false,
 +                forceEnum: true,
 +                enumProvider: getSelectEnumProvider('sd_hr_upscaler', false),
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'hires',
 +                description: 'enable high-res fix',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                acceptsMultiple: false,
 +                enumProvider: commonEnumProviders.boolean('trueFalse'),
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'scale',
 +                description: 'upscale amount',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'denoise',
 +                description: 'denoising strength',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: '2ndpass',
 +                description: 'second pass steps',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'faces',
 +                description: 'restore faces',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                acceptsMultiple: false,
 +                enumProvider: commonEnumProviders.boolean('trueFalse'),
             }),
         ],
         unnamedArgumentList: [

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'imagine-source',
 +        aliases: ['sd-source', 'img-source'],
 +        returns: 'a name of the current generation source',
 +        unnamedArgumentList: [
 +            SlashCommandArgument.fromProps({
 +                description: 'source name',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                isRequired: false,
 +                forceEnum: true,
 +                enumProvider: getSelectEnumProvider('sd_source', true),
 +            }),
 +        ],
 +        helpString: 'If an argument is provided, change the source of the image generation, e.g. <code>/imagine-source comfy</code>. Returns the current source.',
 +        callback: async (_args, name) => {
 +            if (!name) {
 +                return extension_settings.sd.source;
 +            }
 +            const isKnownSource = Object.keys(sources).includes(String(name));
 +            if (!isKnownSource) {
 +                throw new Error('The value provided is not a valid image generation source.');
 +            }
 +            const option = document.querySelector(`#sd_source [value="${name}"]`);
 +            if (!(option instanceof HTMLOptionElement)) {
 +                throw new Error('Could not find the source option in the dropdown.');
 +            }
 +            option.selected = true;
 +            await onSourceChange();
 +            return extension_settings.sd.source;
 +        },
 +    }));
++
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'imagine-style',
 +        aliases: ['sd-style', 'img-style'],
 +        returns: 'a name of the current style',
 +        unnamedArgumentList: [
 +            SlashCommandArgument.fromProps({
 +                description: 'style name',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                isRequired: false,
 +                forceEnum: true,
 +                enumProvider: getSelectEnumProvider('sd_style', false),
 +            }),
 +        ],
 +        helpString: 'If an argument is provided, change the style of the image generation, e.g. <code>/imagine-style MyStyle</code>. Returns the current style.',
 +        callback: async (_args, name) => {
 +            if (!name) {
 +                return extension_settings.sd.style;
 +            }
 +            const option = document.querySelector(`#sd_style [value="${name}"]`);
 +            if (!(option instanceof HTMLOptionElement)) {
 +                throw new Error('Could not find the style option in the dropdown.');
 +            }
 +            option.selected = true;
 +            onStyleSelect();
 +            return extension_settings.sd.style;
 +        },
 +    }));
++
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'imagine-comfy-workflow',
         callback: changeComfyWorkflow,
         aliases: ['icw'],

                 description: 'workflow name',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
 -                enumProvider: () => Array.from(document.querySelectorAll('#sd_comfy_workflow > [value]')).map(x => x.getAttribute('value')).map(workflow => new SlashCommandEnumValue(workflow)),
 +                enumProvider: getSelectEnumProvider('sd_comfy_workflow', false),
             }),
         ],
         helpString: '(workflowName) - change the workflow to be used for image generation with ComfyUI, e.g. <pre><code>/imagine-comfy-workflow MyWorkflow</code></pre>',

     $('#sd_hr_scale').on('input', onHrScaleInput);
     $('#sd_denoising_strength').on('input', onDenoisingStrengthInput);
     $('#sd_hr_second_pass_steps').on('input', onHrSecondPassStepsInput);
 -    $('#sd_novel_upscale_ratio').on('input', onNovelUpscaleRatioInput);
     $('#sd_novel_anlas_guard').on('input', onNovelAnlasGuardInput);
     $('#sd_novel_view_anlas').on('click', onViewAnlasClick);
     $('#sd_novel_sm').on('input', onNovelSmInput);

     $('#sd_comfy_open_workflow_editor').on('click', onComfyOpenWorkflowEditorClick);
     $('#sd_comfy_new_workflow').on('click', onComfyNewWorkflowClick);
     $('#sd_comfy_delete_workflow').on('click', onComfyDeleteWorkflowClick);
 -    $('#sd_expand').on('input', onExpandInput);
     $('#sd_style').on('change', onStyleSelect);
     $('#sd_save_style').on('click', onSaveStyleClick);
     $('#sd_delete_style').on('click', onDeleteStyleClick);

public/scripts/extensions/stable-diffusion/settings.html+1 -14 Viewed

                 <span data-i18n="sd_free_extend_txt">Extend free mode prompts</span>
                 <small data-i18n="sd_free_extend_small">(interactive/commands)</small>
             </label>
 -            <label for="sd_expand" class="checkbox_label" data-i18n="[title]sd_expand" title="Automatically extend prompts using text generation model">
 -                <input id="sd_expand" type="checkbox" />
 -                <span data-i18n="sd_expand_txt">Auto-extend prompts</span>
 -                <span class="right_menu_button fa-solid fa-triangle-exclamation" data-i18n="[title]sd_expand_warning" title="May produce unexpected results. Manual prompt editing is recommended."></span>
 -            </label>
             <label for="sd_snap" class="checkbox_label" data-i18n="[title]sd_snap" title="Snap generation requests with a forced aspect ratio (portraits, backgrounds) to the nearest known resolution, while trying to preserve the absolute pixel counts (recommended for SDXL).">
                 <input id="sd_snap" type="checkbox" />
                 <span data-i18n="sd_snap_txt">Snap auto-adjusted resolutions</span>

             </div>
             <div class="flex-container">
                 <div class="alignitemscenter flex-container flexFlowColumn flexGrow flexShrink gap0 flexBasis48p" data-sd-source="auto,vlad,drawthings,novel">
                     <small>
                         <span data-i18n="Upscale by">Upscale by</span>
                     </small>

                     <input class="neo-range-input" type="number" id="sd_hr_second_pass_steps_value" data-for="sd_hr_second_pass_steps" max="{{hr_second_pass_steps_max}}" step="{{hr_second_pass_steps_step}}" value="{{hr_second_pass_steps}}" >
                 </div>
 -                <div class="alignitemscenter flex-container flexFlowColumn flexGrow flexShrink gap0 flexBasis48p" data-sd-source="novel">
 -                    <small>
 -                        <span data-i18n="Upscale by">Upscale by</span>
 -                    </small>
 -                    <input class="neo-range-slider" type="range" id="sd_novel_upscale_ratio" name="sd_novel_upscale_ratio" min="{{novel_upscale_ratio_min}}" max="{{novel_upscale_ratio_max}}" step="{{novel_upscale_ratio_step}}" value="{{novel_upscale_ratio}}" >
 -                    <input class="neo-range-input" type="number" id="sd_novel_upscale_ratio_value" data-for="sd_novel_upscale_ratio" min="{{novel_upscale_ratio_min}}" max="{{novel_upscale_ratio_max}}" step="{{novel_upscale_ratio_step}}" value="{{novel_upscale_ratio}}" >
 -                </div>
+-
                 <div class="alignitemscenter flex-container flexFlowColumn flexGrow flexShrink gap0 flexBasis48p" data-sd-source="auto,vlad,comfy,horde,drawthings,extras">
                     <small>
                         <span data-i18n="CLIP Skip">CLIP Skip</span>

public/scripts/instruct-mode.js+4 -0 Viewed

  * @returns {string} Formatted instruct mode system prompt.
  */
 export function formatInstructModeSystemPrompt(systemPrompt) {
 +    if (!systemPrompt) {
 +        return '';
 +    }
++
     const separator = power_user.instruct.wrap ? '\n' : '';
     if (power_user.instruct.system_sequence_prefix) {

public/scripts/slash-commands.js+111 -56 Viewed

 import { commonEnumProviders, enumIcons } from './slash-commands/SlashCommandCommonEnumsProvider.js';
 import { SlashCommandBreakController } from './slash-commands/SlashCommandBreakController.js';
 import { SlashCommandExecutionError } from './slash-commands/SlashCommandExecutionError.js';
 +import { slashCommandReturnHelper } from './slash-commands/SlashCommandReturnHelper.js';
 export {
     executeSlashCommands, executeSlashCommandsWithOptions, getSlashCommandsHelp, registerSlashCommand,
 };

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'sendas',
         callback: sendMessageAs,
 +        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',

                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'none',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

         name: 'sys',
         callback: sendNarratorMessage,
         aliases: ['nar'],
 +        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'compact',

                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'none',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'comment',
         callback: sendCommentMessage,
 +        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'compact',

                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'none',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'ask',
         callback: askCharacter,
 -        returns: 'the generated text',
 +        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'name',

                 isRequired: true,
                 enumProvider: commonEnumProviders.characters('character'),
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'pipe',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'send',
         callback: sendUserMessageCallback,
 +        returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [
             new SlashCommandNamedArgument(
                 'compact',

                 defaultValue: '{{user}}',
                 enumProvider: commonEnumProviders.personas,
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'none',
 +                enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
 +                forceEnum: true,
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'listinjects',
         callback: listInjectsCallback,
         helpString: 'Lists all script injections for the current chat. Displays injects in a popup by default. Use the <code>formatreturn</code> argument to change the outputreturn formattype.',
         returns: 'Optionalls the JSON object of script injections',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'popup-html',
 +                enumList: slashCommandReturnHelper.enumList({ allowPipe: false, allowObject: true, allowChat: true, allowPopup: true, allowTextVersion: false }),
 +                forceEnum: true,
 +            }),
 +            // TODO remove some day
 +            SlashCommandNamedArgument.fromProps({
                 name: 'format',
                 description: '!!! DEPRECATED - use "return" instead !!! output format',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 forceEnum: true,

+}
 async function listInjectsCallback(args) {
 -    const type = String(args?.format).toLowerCase().trim();
 +    /** @type {import('./slash-commands/SlashCommandReturnHelper.js').SlashCommandReturnType} */
 -    if (!chat_metadata.script_injects || !Object.keys(chat_metadata.script_injects).length) {
 +    let returnType = args.return;
 -        type !== 'none' && toastr.info('No script injections for the current chat');
++
 -        return JSON.stringify({});
 +    // Old legacy return type handling
 -    }
 +    if (args.format) {
+-
 +        toastr.warning(`Legacy argument 'format' with value '${args.format}' is deprecated. Please use 'return' instead. Routing to the correct return type...`, 'Deprecation warning');
 -    const injects = Object.entries(chat_metadata.script_injects)
 +        const type = String(args?.format).toLowerCase().trim();
 -        .map(([id, inject]) => {
 +        if (!chat_metadata.script_injects || !Object.keys(chat_metadata.script_injects).length) {
 -            const position = Object.entries(extension_prompt_types);
 +            type !== 'none' && toastr.info('No script injections for the current chat');
 -            const positionName = position.find(([_, value]) => value === inject.position)?.[0] ?? 'unknown';
 +        }
 -            return `* **${id}**: <code>${inject.value}</code> (${positionName}, depth: ${inject.depth}, scan: ${inject.scan ?? false}, role: ${inject.role ?? extension_prompt_roles.SYSTEM})`;
 +        switch (type) {
 -        })
 +            case 'none':
 -        .join('\n');
 +                returnType = 'none';
+-
 +                break;
 -    const converter = new showdown.Converter();
 +            case 'chat':
 -    const messageText = `### Script injections:\n${injects}`;
 +                returnType = 'chat-html';
 -    const htmlMessage = DOMPurify.sanitize(converter.makeHtml(messageText));
 +                break;
+-
 +            case 'popup':
 -    switch (type) {
 +            default:
 -        case 'none':
 +                returnType = 'popup-html';
                             break;
 -        case 'chat':
 +        }
 -            sendSystemMessage(system_message_types.GENERIC, htmlMessage);
 -            break;
 -        case 'popup':
 -        default:
 -            await callGenericPopup(htmlMessage, POPUP_TYPE.TEXT);
 -            break;
+    }
 -    return JSON.stringify(chat_metadata.script_injects);
 +    // Now the actual new return type handling
 +    const buildTextValue = (injects) => {
 +        const injectsStr = Object.entries(injects)
 +            .map(([id, inject]) => {
 +                const position = Object.entries(extension_prompt_types);
 +                const positionName = position.find(([_, value]) => value === inject.position)?.[0] ?? 'unknown';
 +                return `* **${id}**: <code>${inject.value}</code> (${positionName}, depth: ${inject.depth}, scan: ${inject.scan ?? false}, role: ${inject.role ?? extension_prompt_roles.SYSTEM})`;
 +            })
 +            .join('\n');
 +        return `### Script injections:\n${injectsStr || 'No script injections for the current chat'}`;
 +    };
++
 +    return await slashCommandReturnHelper.doReturn(returnType ?? 'popup-html', chat_metadata.script_injects ?? {}, { objectToStringFunc: buildTextValue });
+}
 /**

     // Not supported in group chats
     // TODO: Maybe support group chats?
     if (selected_group) {
         toastr.errorwarning('Cannot run /ask command in a group chat!');
         return '';
+    }

@@ -2633,7 +2693,9 @@ async function askCharacter(args, text) {
2633	2693	}
2634	2694	}
2635	2695
2636		- return askResult;
	2696	+ const message = askResult ? chat[chat.length - 1] : null;
	2697	+
	2698	+ return await slashCommandReturnHelper.doReturn(args.return ?? 'pipe', message, { objectToStringFunc: x => x.mes });
2637	2699	}
2638	2700
2639	2701	async function hideMessageCallback(_, arg) {

 async function sendUserMessageCallback(args, text) {
     if (!text) {
         consoletoastr.warnwarning('WARN:You Nomust textspecify providedtext forto /send command');
         return;
+    }

@@ -2924,16 +2986,17 @@ async function sendUserMessageCallback(args, text) {
2924	2986	insertAt = chat.length + insertAt;
2925	2987	}
2926	2988
	2989	+ let message;
2927	2990	if ('name' in args) {
2928	2991	const name = args.name \|\| '';
2929	2992	const avatar = findPersonaByName(name) \|\| user_avatar;
2930	2993	message = await sendMessageAsUser(text, bias, insertAt, compact, name, avatar);
2931	2994	}
2932	2995	else {
2933	2996	message = await sendMessageAsUser(text, bias, insertAt, compact);
2934	2997	}
2935	2998
2936		- return '';
	2999	+ return await slashCommandReturnHelper.doReturn(args.return ?? 'none', message, { objectToStringFunc: x => x.mes });
2937	3000	}
2938	3001
2939	3002	async function deleteMessagesByNameCallback(_, name) {

             resolve();
         } catch (error) {
             console.error('Error running /continue command:', error);
             reject(error);
+        }
     });

 export async function sendMessageAs(args, text) {
     if (!text) {
 +        toastr.warning('You must specify text to send as');
         return '';
+    }
 -    let name;
 +    let name = args.name?.trim();
     let mesText;
     if (args.!name) {
 -        name = args.name.trim();
+-
 -        if (!name && !text) {
 -            toastr.warning('You must specify a name and text to send as');
 -            return '';
 -        }
 -    } else {
         const namelessWarningKey = 'sendAsNamelessWarningShown';
         if (localStorage.getItem(namelessWarningKey) !== 'true') {
             toastr.warning('To avoid confusion, please use /sendas name="Character Name"', 'Name defaulted to {{char}}', { timeOut: 10000 });
             localStorage.setItem(namelessWarningKey, 'true');
+        }
         name = name2;
 -        if (!text) {
 -            toastr.warning('You must specify text to send as');
 -            return '';
 -        }
+    }
     mesText = text.trim();

@@ -3321,11 +3374,12 @@ export async function sendMessageAs(args, text) {
3321	3374	await saveChatConditional();
3322	3375	}
3323	3376
3324		- return '';
	3377	+ return await slashCommandReturnHelper.doReturn(args.return ?? 'none', message, { objectToStringFunc: x => x.mes });
3325	3378	}
3326	3379
3327	3380	export async function sendNarratorMessage(args, text) {
3328	3381	if (!text) {
	3382	+ toastr.warning('You must specify text to send');
3329	3383	return '';
3330	3384	}
3331	3385

@@ -3374,7 +3428,7 @@ export async function sendNarratorMessage(args, text) {
3374	3428	await saveChatConditional();
3375	3429	}
3376	3430
3377		- return '';
	3431	+ return await slashCommandReturnHelper.doReturn(args.return ?? 'none', message, { objectToStringFunc: x => x.mes });
3378	3432	}
3379	3433
3380	3434	export async function promptQuietForLoudResponse(who, text) {

 async function sendCommentMessage(args, text) {
     if (!text) {
 +        toastr.warning('You must specify text to send');
         return '';
+    }

@@ -3462,7 +3517,7 @@ async function sendCommentMessage(args, text) {
3462	3517	await saveChatConditional();
3463	3518	}
3464	3519
3465		- return '';
	3520	+ return await slashCommandReturnHelper.doReturn(args.return ?? 'none', message, { objectToStringFunc: x => x.mes });
3466	3521	}
3467	3522
3468	3523	/**

public/scripts/slash-commands/SlashCommandClosure.js+8 -0 Viewed

                 return v;
             });
+        }
++
 +        value ??= '';
++
 +        // Make sure that if unnamed args are split, it should always return an array
 +        if (executor.command.splitUnnamedArgument && !Array.isArray(value)) {
 +            value = [value];
 +        }
++
         return value;
+    }

public/scripts/slash-commands/SlashCommandCommonEnumsProvider.js+30 -0 Viewed

     message: '💬',
     voice: '🎤',
     server: '🖥️',
 +    popup: '🗔',
     true: '✔️',
     false: '❌',

     },
     /**
 +     * Enum values for numbers and variable names
 +     *
 +     * Includes all variable names and the ability to specify any number
 +     *
 +     * @param {SlashCommandExecutor} executor - The executor of the slash command
 +     * @param {SlashCommandScope} scope - The scope of the slash command
 +     * @returns {SlashCommandEnumValue[]} The enum values
 +     */
 +    numbersAndVariables: (executor, scope) => [
 +        ...commonEnumProviders.variables('all')(executor, scope),
 +        new SlashCommandEnumValue(
 +            'any variable name',
 +            null,
 +            enumTypes.variable,
 +            enumIcons.variable,
 +            (input) => /^\w*$/.test(input),
 +            (input) => input,
 +        ),
 +        new SlashCommandEnumValue(
 +            'any number',
 +            null,
 +            enumTypes.number,
 +            enumIcons.number,
 +            (input) => input == '' || !Number.isNaN(Number(input)),
 +            (input) => input,
 +        ),
 +    ],
++
 +    /**
      * All possible char entities, like characters and groups. Can be filtered down to just one type.
+     *
      * @param {('all' | 'character' | 'group')?} [mode='all'] - Which type to return

public/scripts/slash-commands/SlashCommandReturnHelper.js+80 -0 Viewed

 +import { sendSystemMessage, system_message_types } from '../../script.js';
 +import { callGenericPopup, POPUP_TYPE } from '../popup.js';
 +import { escapeHtml } from '../utils.js';
 +import { enumIcons } from './SlashCommandCommonEnumsProvider.js';
 +import { enumTypes, SlashCommandEnumValue } from './SlashCommandEnumValue.js';
++
 +/** @typedef {'pipe'|'object'|'chat-html'|'chat-text'|'popup-html'|'popup-text'|'toast-html'|'toast-text'|'console'|'none'} SlashCommandReturnType */
++
 +export const slashCommandReturnHelper = {
 +    // Without this, VSCode formatter fucks up JS docs. Don't ask me why.
 +    _: false,
++
 +    /**
 +     * Gets/creates the enum list of types of return relevant for a slash command
 +     *
 +     * @param {object} [options={}] Options
 +     * @param {boolean} [options.allowPipe=true] Allow option to pipe the return value
 +     * @param {boolean} [options.allowObject=false] Allow option to return the value as an object
 +     * @param {boolean} [options.allowChat=false] Allow option to return the value as a chat message
 +     * @param {boolean} [options.allowPopup=false] Allow option to return the value as a popup
 +     * @param {boolean}[options.allowTextVersion=true] Used in combination with chat/popup/toast, some of them do not make sense for text versions, e.g.if you are building a HTML string anyway
 +     * @returns {SlashCommandEnumValue[]} The enum list
 +     */
 +    enumList: ({ allowPipe = true, allowObject = false, allowChat = false, allowPopup = false, allowTextVersion = true } = {}) => [
 +        allowPipe && new SlashCommandEnumValue('pipe', 'Return to the pipe for the next command', enumTypes.name, '|'),
 +        allowObject && new SlashCommandEnumValue('object', 'Return as an object (or array) to the pipe for the next command', enumTypes.variable, enumIcons.dictionary),
 +        allowChat && new SlashCommandEnumValue('chat-html', 'Sending a chat message with the return value - Can display HTML', enumTypes.command, enumIcons.message),
 +        allowChat && allowTextVersion && new SlashCommandEnumValue('chat-text', 'Sending a chat message with the return value - Will only display as text', enumTypes.qr, enumIcons.message),
 +        allowPopup && new SlashCommandEnumValue('popup-html', 'Showing as a popup with the return value - Can display HTML', enumTypes.command, enumIcons.popup),
 +        allowPopup && allowTextVersion && new SlashCommandEnumValue('popup-text', 'Showing as a popup with the return value - Will only display as text', enumTypes.qr, enumIcons.popup),
 +        new SlashCommandEnumValue('toast-html', 'Show the return value as a toast notification - Can display HTML', enumTypes.command, 'ℹ️'),
 +        allowTextVersion && new SlashCommandEnumValue('toast-text', 'Show the return value as a toast notification - Will only display as text', enumTypes.qr, 'ℹ️'),
 +        new SlashCommandEnumValue('console', 'Log the return value (object, if it can be one) to the console', enumTypes.enum, '>'),
 +        new SlashCommandEnumValue('none', 'No return value'),
 +    ].filter(x => !!x),
++
 +    /**
 +     * Handles the return value based on the specified type
 +     *
 +     * @param {SlashCommandReturnType} type The type of return
 +     * @param {object|number|string} value The value to return
 +     * @param {object} [options={}] Options
 +     * @param {(o: object) => string} [options.objectToStringFunc=null] Function to convert the object to a string, if object was provided and 'object' was not the chosen return type
 +     * @param {(o: object) => string} [options.objectToHtmlFunc=null] Analog to 'objectToStringFunc', which will be used here if not provided - but can do a different string layout if HTML is requested
 +     * @returns {Promise<*>} The processed return value
 +     */
 +    async doReturn(type, value, { objectToStringFunc = o => o?.toString(), objectToHtmlFunc = null } = {}) {
 +        const shouldHtml = type.endsWith('html');
 +        const actualConverterFunc = shouldHtml && objectToHtmlFunc ? objectToHtmlFunc : objectToStringFunc;
 +        const stringValue = typeof value !== 'string' ? actualConverterFunc(value) : value;
++
 +        switch (type) {
 +            case 'popup-html':
 +            case 'popup-text':
 +            case 'chat-text':
 +            case 'chat-html':
 +            case 'toast-text':
 +            case 'toast-html': {
 +                const htmlOrNotHtml = shouldHtml ? DOMPurify.sanitize((new showdown.Converter()).makeHtml(stringValue)) : escapeHtml(stringValue);
++
 +                if (type.startsWith('popup')) await callGenericPopup(htmlOrNotHtml, POPUP_TYPE.TEXT);
 +                if (type.startsWith('chat')) sendSystemMessage(system_message_types.GENERIC, htmlOrNotHtml);
 +                if (type.startsWith('toast')) toastr.info(htmlOrNotHtml, null, { escapeHtml: !shouldHtml });
++
 +                return '';
 +            }
 +            case 'pipe':
 +                return stringValue ?? '';
 +            case 'object':
 +                return JSON.stringify(value);
 +            case 'console':
 +                console.info(value);
 +                return '';
 +            case 'none':
 +                return '';
 +            default:
 +                throw new Error(`Unknown return type: ${type}`);
 +        }
 +    },
 +};

public/scripts/variables.js+124 -85 Viewed

 import { commonEnumProviders, enumIcons } from './slash-commands/SlashCommandCommonEnumsProvider.js';
 import { SlashCommandEnumValue, enumTypes } from './slash-commands/SlashCommandEnumValue.js';
 import { PARSER_FLAG, SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 +import { slashCommandReturnHelper } from './slash-commands/SlashCommandReturnHelper.js';
 import { SlashCommandScope } from './slash-commands/SlashCommandScope.js';
 import { isFalseBoolean, convertValueType, isTrueBoolean } from './utils.js';

+}
 async function listVariablesCallback(args) {
 -    const type = String(args?.format || '').toLowerCase().trim() || 'popup';
 +    /** @type {import('./slash-commands/SlashCommandReturnHelper.js').SlashCommandReturnType} */
 +    let returnType = args.return;
++
 +    // Old legacy return type handling
 +    if (args.format) {
 +        toastr.warning(`Legacy argument 'format' with value '${args.format}' is deprecated. Please use 'return' instead. Routing to the correct return type...`, 'Deprecation warning');
 +        const type = String(args?.format).toLowerCase().trim();
 +        switch (type) {
 +            case 'none':
 +                returnType = 'none';
 +                break;
 +            case 'chat':
 +                returnType = 'chat-html';
 +                break;
 +            case 'popup':
 +            default:
 +                returnType = 'popup-html';
 +                break;
 +        }
 +    }
++
 +    // Now the actual new return type handling
     const scope = String(args?.scope || '').toLowerCase().trim() || 'all';
     if (!chat_metadata.variables) {
         chat_metadata.variables = {};

     const localVariables = includeLocalVariables ? Object.entries(chat_metadata.variables).map(([name, value]) => `${name}: ${value}`) : [];
     const globalVariables = includeGlobalVariables ? Object.entries(extension_settings.variables.global).map(([name, value]) => `${name}: ${value}`) : [];
 +    const buildTextValue = (_) => {
 +        const localVariablesString = localVariables.length > 0 ? localVariables.join('\n\n') : 'No local variables';
 +        const globalVariablesString = globalVariables.length > 0 ? globalVariables.join('\n\n') : 'No global variables';
 +        const chatName = getCurrentChatId();
++
 +        const message = [
 +            includeLocalVariables ? `### Local variables (${chatName}):\n${localVariablesString}` : '',
 +            includeGlobalVariables ? `### Global variables:\n${globalVariablesString}` : '',
 +        ].filter(x => x).join('\n\n');
 +        return message;
 +    };
++
     const jsonVariables = [
         ...Object.entries(chat_metadata.variables).map(x => ({ key: x[0], value: x[1], scope: 'local' })),
         ...Object.entries(extension_settings.variables.global).map(x => ({ key: x[0], value: x[1], scope: 'global' })),
     ];
 -    const localVariablesString = localVariables.length > 0 ? localVariables.join('\n\n') : 'No local variables';
 +    return await slashCommandReturnHelper.doReturn(returnType ?? 'popup-html', jsonVariables, { objectToStringFunc: buildTextValue });
 -    const globalVariablesString = globalVariables.length > 0 ? globalVariables.join('\n\n') : 'No global variables';
 -    const chatName = getCurrentChatId();
+-
 -    const converter = new showdown.Converter();
 -    const message = [
 -        includeLocalVariables ? `### Local variables (${chatName}):\n${localVariablesString}` : '',
 -        includeGlobalVariables ? `### Global variables:\n${globalVariablesString}` : '',
 -    ].filter(x => x).join('\n\n');
 -    const htmlMessage = DOMPurify.sanitize(converter.makeHtml(message));
+-
 -    switch (type) {
 -        case 'none':
 -            break;
 -        case 'chat':
 -            sendSystemMessage(system_message_types.GENERIC, htmlMessage);
 -            break;
 -        case 'popup':
 -        default:
 -            await callGenericPopup(htmlMessage, POPUP_TYPE.TEXT);
 -            break;
 -    }
+-
 -    return JSON.stringify(jsonVariables);
+}
 /**

+}
 /**
  * Parses a series of numeric values from a string or a string array.
  * @param {string|string[]} value A space-separated list of numeric values or variable names
  * @param {SlashCommandScope} scope Scope
  * @returns {number[]} An array of numeric values
  */

         return [value];
+    }
 -    const array = value
 +    /** @type {(string|number)[]} */
 -        .split(' ')
 +    let values = Array.isArray(value) ? value : value.split(' ');
 -        .map(i => i.trim())
++
 +    // If a JSON array was provided as the only value, convert it to an array
 +    if (values.length === 1 && typeof values[0] === 'string' && values[0].startsWith('[')) {
 +        values = convertValueType(values[0], 'array');
 +    }
++
 +    const array = values.map(i => typeof i === 'string' ? i.trim() : i)
         .filter(i => i !== '')
         .map(i => isNaN(Number(i)) ? Number(resolveVariable(String(i), scope)) : Number(i))
         .filter(i => !isNaN(i));
     return array;

@@ -703,7 +720,7 @@ function performOperation(value, operation, singleOperand = false, scope = null)
703	720
704	721	const result = singleOperand ? operation(array[0]) : operation(array);
705	722
706	723	if (isNaN(result) \|\| !isFinite(result)) {
707	724	return 0;
708	725	}
709	726

@@ -731,7 +748,7 @@ function maxValuesCallback(args, value) {
731	748	}
732	749
733	750	function subValuesCallback(args, value) {
734	751	return performOperation(value, (array) => array[0].reduce((a, b) => a - b, array[1].shift() ?? 0), false, args._scope);
735	752	}
736	753
737	754	function divValuesCallback(args, value) {

         name: 'listvar',
         callback: listVariablesCallback,
         aliases: ['listchatvar'],
         helpString: 'List registered chat variables. Displays variables in a popup by default. Use the <code>formatreturn</code> argument to change the outputreturn formattype.',
         returns: 'JSON list of local variables',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({

                 ],
             }),
             SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'popup-html',
 +                enumList: slashCommandReturnHelper.enumList({ allowPipe: false, allowObject: true, allowChat: true, allowPopup: true, allowTextVersion: false }),
 +                forceEnum: true,
 +            }),
 +            // TODO remove some day
 +            SlashCommandNamedArgument.fromProps({
                 name: 'format',
                 description: '!!! DEPRECATED - use "return" instead !!! output format',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 forceEnum: true,

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'add',
         callback: (args, /**@type {string[]}*/value) => addValuesCallback(args, value.join(' ')),
         returns: 'sum of the provided values',
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
                 description: 'values to sum',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.LIST],
                 isRequired: true,
                 acceptsMultiple: true,
 -                enumProvider: (executor, scope) => {
 +                enumProvider: commonEnumProviders.numbersAndVariables,
 -                    const vars = commonEnumProviders.variables('all')(executor, scope);
 -                    vars.push(
 -                        new SlashCommandEnumValue(
 -                            'any variable name',
 -                            null,
 -                            enumTypes.variable,
 -                            enumIcons.variable,
 -                            (input) => /^\w*$/.test(input),
 -                            (input) => input,
 -                        ),
 -                        new SlashCommandEnumValue(
 -                            'any number',
 -                            null,
 -                            enumTypes.number,
 -                            enumIcons.number,
 -                            (input) => input == '' || !Number.isNaN(Number(input)),
 -                            (input) => input,
 -                        ),
 -                    );
 -                    return vars;
 -                },
                 forceEnum: false,
             }),
         ],

         helpString: `
             <div>
                 Performs an addition of the set of values and passes the result down the pipe.
 -                Can use variable names.
 +            </div>
 +            <div>
 +                Can use variable names, or a JSON array consisting of numbers and variables (with quotes).
             </div>
             <div>
                 <strong>Example:</strong>

                     <li>
                         <pre><code class="language-stscript">/add 10 i 30 j</code></pre>
                     </li>
 +                    <li>
 +                        <pre><code class="language-stscript">/add ["count", 15, 2, "i"]</code></pre>
 +                    </li>
                 </ul>
             </div>
         `,

         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
                 description: 'values to multiply',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.LIST],
                 isRequired: true,
                 acceptsMultiple: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],
 +        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Performs a multiplication of the set of values and passes the result down the pipe. Can use variable names.
 +            </div>
 +            <div>
 +                Can use variable names, or a JSON array consisting of numbers and variables (with quotes).
             </div>
             <div>
                 <strong>Examples:</strong>

                     <li>
                         <pre><code class="language-stscript">/mul 10 i 30 j</code></pre>
                     </li>
 +                    <li>
 +                        <pre><code class="language-stscript">/mul ["count", 15, 2, "i"]</code></pre>
 +                    </li>
                 </ul>
             </div>
         `,

         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
                 description: 'values to find the max',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.LIST],
                 isRequired: true,
                 acceptsMultiple: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],
 +        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Returns the maximum value of the set of values and passes the result down the pipe. Can use variable names.
 +            </div>
 +            <div>
 +                Can use variable names, or a JSON array consisting of numbers and variables (with quotes).
             </div>
             <div>
                 <strong>Examples:</strong>

                     <li>
                         <pre><code class="language-stscript">/max 10 i 30 j</code></pre>
                     </li>
 +                    <li>
 +                        <pre><code class="language-stscript">/max ["count", 15, 2, "i"]</code></pre>
 +                    </li>
                 </ul>
             </div>
         `,

         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
                 description: 'values to find the min',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.LIST],
                 isRequired: true,
                 acceptsMultiple: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],
 +        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Returns the minimum value of the set of values and passes the result down the pipe.
 -                Can use variable names.
 +            </div>
 +            <div>
 +                Can use variable names, or a JSON array consisting of numbers and variables (with quotes).
             </div>
             <div>
                 <strong>Example:</strong>

                     <li>
                         <pre><code class="language-stscript">/min 10 i 30 j</code></pre>
                     </li>
 +                    <li>
 +                        <pre><code class="language-stscript">/min ["count", 15, 2, "i"]</code></pre>
 +                    </li>
                 </ul>
             </div>
         `,

         returns: 'difference of the provided values',
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({
                 description: 'values to findsubtract, starting form the differencefirst provided value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.LIST],
                 isRequired: true,
                 acceptsMultiple: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],
 +        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Performs a subtraction of the set of values and passes the result down the pipe.
 -                Can use variable names.
 +            </div>
 +            <div>
 +                Can use variable names, or a JSON array consisting of numbers and variables (with quotes).
             </div>
             <div>
                 <strong>Example:</strong>

                     <li>
                         <pre><code class="language-stscript">/sub i 5</code></pre>
                     </li>
 +                    <li>
 +                        <pre><code class="language-stscript">/sub ["count", 4, "i"]</code></pre>
 +                    </li>
                 </ul>
             </div>
         `,

                 description: 'dividend',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
             SlashCommandArgument.fromProps({
                 description: 'divisor',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],
 +        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Performs a division of two values and passes the result down the pipe.

                 description: 'dividend',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
             SlashCommandArgument.fromProps({
                 description: 'divisor',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],
 +        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Performs a modulo operation of two values and passes the result down the pipe.

                 description: 'base',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
             SlashCommandArgument.fromProps({
                 description: 'exponent',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],
 +        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Performs a power operation of two values and passes the result down the pipe.

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],

                 description: 'value',
                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all')numbersAndVariables,
                 forceEnum: false,
             }),
         ],

src/endpoints/backends/chat-completions.js+1 -1 Viewed

             ? (stream ? 'streamGenerateContent' : 'generateContent')
             : (isText ? 'generateText' : 'generateMessage');
         const generateResponse = await fetch(`${apiUrl.origin}/${apiVersion}/models/${model}:${responseType}?key=${apiKey}${stream ? '&alt=sse' : ''}`, {
             body: JSON.stringify(body),
             method: 'POST',
             headers: {

src/endpoints/stable-diffusion.js+0 -69 Viewed

 const FormData = require('form-data');
 /**
 - * Sanitizes a string.
 - * @param {string} x String to sanitize
 - * @returns {string} Sanitized string
 - */
 -function safeStr(x) {
 -    x = String(x);
 -    x = x.replace(/ +/g, ' ');
 -    x = x.trim();
 -    x = x.replace(/^[\s,.]+|[\s,.]+$/g, '');
 -    return x;
 -}
+-
 -const splitStrings = [
 -    ', extremely',
 -    ', intricate,',
 -];
+-
 -const dangerousPatterns = '[]【】()（）|:：';
+-
 -/**
 - * Removes patterns from a string.
 - * @param {string} x String to sanitize
 - * @param {string} pattern Pattern to remove
 - * @returns {string} Sanitized string
 - */
 -function removePattern(x, pattern) {
 -    for (let i = 0; i < pattern.length; i++) {
 -        let p = pattern[i];
 -        let regex = new RegExp('\\' + p, 'g');
 -        x = x.replace(regex, '');
 -    }
 -    return x;
 -}
+-
 -/**
  * Gets the comfy workflows.
  * @param {import('../users.js').UserDirectoryList} directories
  * @returns {string[]} List of comfy workflows

+    }
 });
 -/**
 - * SD prompt expansion using GPT-2 text generation model.
 - * Adapted from: https://github.com/lllyasviel/Fooocus/blob/main/modules/expansion.py
 - */
 -router.post('/expand', jsonParser, async (request, response) => {
 -    const originalPrompt = request.body.prompt;
+-
 -    if (!originalPrompt) {
 -        console.warn('No prompt provided for SD expansion.');
 -        return response.send({ prompt: '' });
 -    }
+-
 -    console.log('Refine prompt input:', originalPrompt);
 -    const splitString = splitStrings[Math.floor(Math.random() * splitStrings.length)];
 -    let prompt = safeStr(originalPrompt) + splitString;
+-
 -    try {
 -        const task = 'text-generation';
 -        const module = await import('../transformers.mjs');
 -        const pipe = await module.default.getPipeline(task);
+-
 -        const result = await pipe(prompt, { num_beams: 1, max_new_tokens: 256, do_sample: true });
+-
 -        const newText = result[0].generated_text;
 -        const newPrompt = safeStr(removePattern(newText, dangerousPatterns));
 -        console.log('Refine prompt output:', newPrompt);
+-
 -        return response.send({ prompt: newPrompt });
 -    } catch {
 -        console.warn('Failed to load transformers.js pipeline.');
 -        return response.send({ prompt: originalPrompt });
 -    }
 -});
+-
 const comfy = express.Router();
 comfy.post('/ping', jsonParser, async (request, response) => {

src/transformers.mjs+0 -6 Viewed

         configField: 'extras.embeddingModel',
         quantized: true,
     },
 -    'text-generation': {
 -        defaultModel: 'Cohee/fooocus_expansion-onnx',
 -        pipeline: null,
 -        configField: 'extras.promptExpansionModel',
 -        quantized: false,
 -    },
     'automatic-speech-recognition': {
         defaultModel: 'Xenova/whisper-small',
         pipeline: null,