Merge pull request #2922 from SillyTavern/send-commands-return-value Update various sending commands to return a value

be103534e4122ada55d1416f8cc802232de59aac

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

Signed

Parents: 4eee1cb2d0ac1ec59bb5c0f4aa61c82ad19419b9 33222191be5782c8503addd3d10a7fc9afecae08

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);

@@ -4832,6 +4832,8 @@ export async function sendMessageAsUser(messageText, messageBias, insertAt = nul
4832	4832	await eventSource.emit(event_types.USER_MESSAGE_RENDERED, chat_id);
4833	4833	await saveChatConditional();
4834	4834	}
	4835	+
	4836	+ return message;
4835	4837	}
4836	4838
4837	4839	/**

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/slash-commands.js+110 -55 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) {

 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/SlashCommandCommonEnumsProvider.js+1 -0 Viewed

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

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+47 -27 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);
+}
 /**

         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,