Merge pull request #3035 from SillyTavern/macro-1.5 Totally not a new macro engine

237381ac3d0db93bbc6d0c8a963813546afa2f73

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

Signed

Parents: b837c482fc4ddff38055c55b0807083768931d47 48c3e81f429dbd3094b8c37c10029c9510f869d2

public/script.js+6 -4 Viewed

  * Substitutes {{macro}} parameters in a string.
  * @param {string} content - The string to substitute parameters in.
  * @param {Record<string,any>} additionalMacro - Additional environment variables for substitution.
 + * @param {(x: string) => string} [postProcessFn] - Post-processing function for each substituted macro.
  * @returns {string} The string with substituted parameters.
  */
 export function substituteParamsExtended(content, additionalMacro = {}, postProcessFn = (x) => x) {
     return substituteParams(content, undefined, undefined, undefined, undefined, true, additionalMacro, postProcessFn);
+}
 /**

  * @param {string} [_group] - The group members list for {{group}} substitution.
  * @param {boolean} [_replaceCharacterCard] - Whether to replace character card macros.
  * @param {Record<string,any>} [additionalMacro] - Additional environment variables for substitution.
 + * @param {(x: string) => string} [postProcessFn] - Post-processing function for each substituted macro.
  * @returns {string} The string with substituted parameters.
  */
 export function substituteParams(content, _name1, _name2, _original, _group, _replaceCharacterCard = true, additionalMacro = {}, postProcessFn = (x) => x) {
     if (!content) {
         return '';
+    }

@@ -2597,7 +2599,7 @@ export function substituteParams(content, _name1, _name2, _original, _group, _re
2597	2599	Object.assign(environment, additionalMacro);
2598	2600	}
2599	2601
2600	2602	return evaluateMacros(content, environment, postProcessFn);
2601	2603	}
2602	2604
2603	2605

public/scripts/extensions/regex/engine.js+27 -2 Viewed

 import { characters, substituteParams, substituteParamsExtended, this_chid } from '../../../script.js';
 import { extension_settings } from '../../extensions.js';
 import { regexFromString } from '../../utils.js';
 export {

     WORLD_INFO: 5,
 };
 +function sanitizeRegexMacro(x) {
 +    return (x && typeof x === 'string') ?
 +        x.replaceAll(/[\n\r\t\v\f\0.^$*+?{}[\]\\/|()]/gs, function (s) {
 +            switch (s) {
 +                case '\n':
 +                    return '\\n';
 +                case '\r':
 +                    return '\\r';
 +                case '\t':
 +                    return '\\t';
 +                case '\v':
 +                    return '\\v';
 +                case '\f':
 +                    return '\\f';
 +                case '\0':
 +                    return '\\0';
 +                default:
 +                    return '\\' + s;
 +            }
 +        }) : x;
 +}
++
 function getScopedRegex() {
     const isAllowed = extension_settings?.character_allowed_regex?.includes(characters?.[this_chid]?.avatar);

         return newString;
+    }
 -    const findRegex = regexFromString(regexScript.substituteRegex ? substituteParams(regexScript.findRegex) : regexScript.findRegex);
 +    const regexString = regexScript.substituteRegex
 +        ? substituteParamsExtended(regexScript.findRegex, {}, sanitizeRegexMacro)
 +        : regexScript.findRegex;
 +    const findRegex = regexFromString(regexString);
     // The user skill issued. Return with nothing.
     if (!findRegex) {

public/scripts/instruct-mode.js+14 -22 Viewed

 /**
  * Replaces instruct mode macros in the given input string.
 - * @param {string} input Input string.
  * @param {Object<string, *>} env - Map of macro names to the values they'll be substituted with. If the param
  * values are functions, those functions will be called and their return values are used.
 - * @returns {string} String with macros replaced.
 + * @returns {import('./macros.js').Macro[]} Macro objects.
  */
 export function replaceInstructMacrosgetInstructMacros(input, env) {
 -    if (!input) {
 -        return '';
 -    }
+-
 -    const syspromptMacros = {
 -        'systemPrompt': (power_user.prefer_character_prompt && env.charPrompt ? env.charPrompt : power_user.sysprompt.content),
 -        'defaultSystemPrompt|instructSystem|instructSystemPrompt': power_user.sysprompt.content,
 -    };
+-
     const instructMacros = {
 +        // Instruct template macros
         'instructSystemPromptPrefix': power_user.instruct.system_sequence_prefix,
         'instructSystemPromptSuffix': power_user.instruct.system_sequence_suffix,
         'instructInput|instructUserPrefix': power_user.instruct.input_sequence,

         'instructSystemInstructionPrefix': power_user.instruct.last_system_sequence,
         'instructFirstInput|instructFirstUserPrefix': power_user.instruct.first_input_sequence || power_user.instruct.input_sequence,
         'instructLastInput|instructLastUserPrefix': power_user.instruct.last_input_sequence || power_user.instruct.input_sequence,
 +        // System prompt macros
 +        'systemPrompt': (power_user.prefer_character_prompt && env.charPrompt ? env.charPrompt : power_user.sysprompt.content),
 +        'defaultSystemPrompt|instructSystem|instructSystemPrompt': power_user.sysprompt.content,
 +        // Context template macros
 +        'chatSeparator': power_user.context.example_separator,
 +        'chatStart': power_user.context.chat_start,
     };
 -    for (const [placeholder, value] of Object.entries(instructMacros)) {
 +    const macros = [];
 -        const regex = new RegExp(`{{(${placeholder})}}`, 'gi');
 -        input = input.replace(regex, power_user.instruct.enabled ? value : '');
 -    }
     for (const [placeholder, value] of Object.entries(syspromptMacrosinstructMacros)) {
         const regex = new RegExp(`{{(${placeholder})}}`, 'gi');
         inputconst replace = input.replace(regex,) => power_user.syspromptinstruct.enabled ? value : '');
 +        macros.push({ regex, replace });
+    }
 -    input = input.replace(/{{exampleSeparator}}/gi, power_user.context.example_separator);
 +    return macros;
 -    input = input.replace(/{{chatStart}}/gi, power_user.context.chat_start);
+-
 -    return input;
+}
 jQuery(() => {

public/scripts/macros.js+124 -95 Viewed

 import { chat, chat_metadata, main_api, getMaxContextSize, getCurrentChatId, substituteParams } from '../script.js';
 import { timestampToMoment, isDigitsOnly, getStringHash, escapeRegex, uuidv4 } from './utils.js';
 import { textgenerationwebui_banned_in_macros } from './textgen-settings.js';
 import { replaceInstructMacrosgetInstructMacros } from './instruct-mode.js';
 import { replaceVariableMacrosgetVariableMacros } from './variables.js';
++
 +/**
 + * @typedef Macro
 + * @property {RegExp} regex - Regular expression to match the macro
 + * @property {(substring: string, ...args: any[]) => string} replace - Function to replace the macro
 + */
 // Register any macro that you want to leave in the compiled story string
 Handlebars.registerHelper('trim', () => '{{trim}}');

 /**
  * Replaces banned words in macros with an empty string.
  * Adds them to textgenerationwebui ban list.
 - * @param {string} inText Text to replace banned words in
 + * @returns {Macro}
 - * @returns {string} Text without the "banned" macro
  */
 function bannedWordsReplacegetBannedWordsMacro(inText) {
 -    if (!inText) {
 -        return '';
 -    }
+-
     const banPattern = /{{banned "(.*)"}}/gi;
+-
 +    const banReplace = (match, bannedWord) => {
         if (main_api == 'textgenerationwebui') {
 -        const bans = inText.matchAll(banPattern);
 +            console.log('Found banned word in macros: ' + bannedWord);
 -        if (bans) {
 +            textgenerationwebui_banned_in_macros.push(bannedWord);
 -            for (const banCase of bans) {
 -                console.log('Found banned words in macros: ' + banCase[1]);
 -                textgenerationwebui_banned_in_macros.push(banCase[1]);
 -            }
 -        }
+        }
 +        return '';
 +    };
 -    inText = inText.replaceAll(banPattern, '');
 +    return { regex: banPattern, replace: banReplace };
 -    return inText;
+}
 function getTimeSinceLastMessage() {

     return 'just now';
+}
 -function randomReplace(input, emptyListPlaceholder = '') {
 +/**
 + * Returns a macro that picks a random item from a list.
 + * @returns {Macro} The random replace macro
 + */
 +function getRandomReplaceMacro() {
     const randomPattern = /{{random\s?::?([^}]+)}}/gi;
+-
 +    const randomReplace = (match, listString) => {
 -    input = input.replace(randomPattern, (match, listString) => {
         // Split on either double colons or comma. If comma is the separator, we are also trimming all items.
         const list = listString.includes('::')
             ? listString.split('::')

             : listString.replace(/\\,/g, '##�COMMA�##').split(',').map(item => item.trim().replace(/##�COMMA�##/g, ','));
         if (list.length === 0) {
             return emptyListPlaceholder'';
+        }
         const rng = seedrandom('added entropy.', { entropy: true });
         const randomIndex = Math.floor(rng() * list.length);
         return list[randomIndex];
     });
 -    return input;
 -}
 -function pickReplace(input, rawContent, emptyListPlaceholder = '') {
 +    return { regex: randomPattern, replace: randomReplace };
 -    const pickPattern = /{{pick\s?::?([^}]+)}}/gi;
 +}
 +/**
 + * Returns a macro that picks a random item from a list with a consistent seed.
 + * @param {string} rawContent The raw content of the string
 + * @returns {Macro} The pick replace macro
 + */
 +function getPickReplaceMacro(rawContent) {
     // We need to have a consistent chat hash, otherwise we'll lose rolls on chat file rename or branch switches
     // No need to save metadata here - branching and renaming will implicitly do the save for us, and until then loading it like this is consistent
     const chatIdHash = getChatIdHash();
     const rawContentHash = getStringHash(rawContent);
 -    return input.replace(pickPattern, (match, listString, offset) => {
 +    const pickPattern = /{{pick\s?::?([^}]+)}}/gi;
 +    const pickReplace = (match, listString, offset) => {
         // Split on either double colons or comma. If comma is the separator, we are also trimming all items.
         const list = listString.includes('::')
             ? listString.split('::')

             : listString.replace(/\\,/g, '##�COMMA�##').split(',').map(item => item.trim().replace(/##�COMMA�##/g, ','));
         if (list.length === 0) {
             return emptyListPlaceholder'';
+        }
         // We build a hash seed based on: unique chat file, raw content, and the placement inside this content

         const rng = seedrandom(finalSeed);
         const randomIndex = Math.floor(rng() * list.length);
         return list[randomIndex];
     });
++
 +    return { regex: pickPattern, replace: pickReplace };
+}
 -function diceRollReplace(input, invalidRollPlaceholder = '') {
 +/**
 + * @returns {Macro} The dire roll macro
 + */
 +function getDiceRollMacro() {
     const rollPattern = /{{roll[ : ]([^}]+)}}/gi;
+-
 +    const rollReplace = (match, matchValue) => {
 -    return input.replace(rollPattern, (match, matchValue) => {
         let formula = matchValue.trim();
         if (isDigitsOnly(formula)) {

         if (!isValid) {
             console.debug(`Invalid roll formula: ${formula}`);
             return invalidRollPlaceholder'';
+        }
         const result = droll.roll(formula);
 -        return new String(result.total);
 +        if (result === false) return '';
 -    });
 +        return String(result.total);
 +    };
++
 +    return { regex: rollPattern, replace: rollReplace };
+}
 /**
  * Returns the difference between two times. Works with any time format acceptable by moment().
  * Can work with {{date}} {{time}} macros
  * @paramreturns {stringMacro} input - The string to replace time difference macros in.macro
 - * @returns {string} The string with replaced time difference macros.
  */
 function timeDiffReplacegetTimeDiffMacro(input) {
     const timeDiffPattern = /{{timeDiff::(.*?)::(.*?)}}/gi;
+-
 +    const timeDiffReplace = (_match, matchPart1, matchPart2) => {
 -    const output = input.replace(timeDiffPattern, (_match, matchPart1, matchPart2) => {
         const time1 = moment(matchPart1);
         const time2 = moment(matchPart2);
         const timeDifference = moment.duration(time1.diff(time2));
         return timeDifference.humanize(true);
     });
 -    return output;
 +    return { regex: timeDiffPattern, replace: timeDiffReplace };
+}
 /**

  * @param {string} content - The string to substitute parameters in.
  * @param {EnvObject} env - Map of macro names to the values they'll be substituted with. If the param
  * values are functions, those functions will be called and their return values are used.
 + * @param {function(string): string} postProcessFn - Function to run on the macro value before replacing it.
  * @returns {string} The string with substituted parameters.
  */
 export function evaluateMacros(content, env, postProcessFn) {
     if (!content) {
         return '';
+    }
 +    postProcessFn = typeof postProcessFn === 'function' ? postProcessFn : (x => x);
     const rawContent = content;
 -    // Legacy non-macro substitutions
 +    /**
 -    content = content.replace(/<USER>/gi, typeof env.user === 'function' ? env.user() : env.user);
 +     * Built-ins running before the env variables
 -    content = content.replace(/<BOT>/gi, typeof env.char === 'function' ? env.char() : env.char);
 +     * @type {Macro[]}
 -    content = content.replace(/<CHAR>/gi, typeof env.char === 'function' ? env.char() : env.char);
 +     * */
 -    content = content.replace(/<CHARIFNOTGROUP>/gi, typeof env.group === 'function' ? env.group() : env.group);
 +    const preEnvMacros = [
 -    content = content.replace(/<GROUP>/gi, typeof env.group === 'function' ? env.group() : env.group);
 +        // Legacy non-curly macros
+-
 +        { regex: /<USER>/gi, replace: () => typeof env.user === 'function' ? env.user() : env.user },
 -    // Short circuit if there are no macros
 +        { regex: /<BOT>/gi, replace: () => typeof env.char === 'function' ? env.char() : env.char },
 -    if (!content.includes('{{')) {
 +        { regex: /<CHAR>/gi, replace: () => typeof env.char === 'function' ? env.char() : env.char },
 -        return content;
 +        { regex: /<CHARIFNOTGROUP>/gi, replace: () => typeof env.group === 'function' ? env.group() : env.group },
 -    }
 +        { regex: /<GROUP>/gi, replace: () => typeof env.group === 'function' ? env.group() : env.group },
 +        getDiceRollMacro(),
 +        ...getInstructMacros(env),
 +        ...getVariableMacros(),
 +        { regex: /{{newline}}/gi, replace: () => '\n' },
 +        { regex: /(?:\r?\n)*{{trim}}(?:\r?\n)*/gi, replace: () => '' },
 +        { regex: /{{noop}}/gi, replace: () => '' },
 +        { regex: /{{input}}/gi, replace: () => String($('#send_textarea').val()) },
 +    ];
 -    content = diceRollReplace(content);
 +    /**
 -    content = replaceInstructMacros(content, env);
 +     * Built-ins running after the env variables
 -    content = replaceVariableMacros(content);
 +     * @type {Macro[]}
 -    content = content.replace(/{{newline}}/gi, '\n');
 +    */
 -    content = content.replace(/(?:\r?\n)*{{trim}}(?:\r?\n)*/gi, '');
 +    const postEnvMacros = [
 -    content = content.replace(/{{noop}}/gi, '');
 +        { regex: /{{maxPrompt}}/gi, replace: () => String(getMaxContextSize()) },
     content        { =regex: content.replace(/{{inputlastMessage}}/gi, replace: () => String($('#send_textarea').valgetLastMessage())); },
 +        { regex: /{{lastMessageId}}/gi, replace: () => String(getLastMessageId() ?? '') },
 +        { regex: /{{lastUserMessage}}/gi, replace: () => getLastUserMessage() },
 +        { regex: /{{lastCharMessage}}/gi, replace: () => getLastCharMessage() },
 +        { regex: /{{firstIncludedMessageId}}/gi, replace: () => String(getFirstIncludedMessageId() ?? '') },
 +        { regex: /{{lastSwipeId}}/gi, replace: () => String(getLastSwipeId() ?? '') },
 +        { regex: /{{currentSwipeId}}/gi, replace: () => String(getCurrentSwipeId() ?? '') },
 +        { regex: /{{reverse:(.+?)}}/gi, replace: (_, str) => Array.from(str).reverse().join('') },
 +        { regex: /\{\{\/\/([\s\S]*?)\}\}/gm, replace: () => '' },
 +        { regex: /{{time}}/gi, replace: () => moment().format('LT') },
 +        { regex: /{{date}}/gi, replace: () => moment().format('LL') },
 +        { regex: /{{weekday}}/gi, replace: () => moment().format('dddd') },
 +        { regex: /{{isotime}}/gi, replace: () => moment().format('HH:mm') },
 +        { regex: /{{isodate}}/gi, replace: () => moment().format('YYYY-MM-DD') },
 +        { regex: /{{datetimeformat +([^}]*)}}/gi, replace: (_, format) => moment().format(format) },
 +        { regex: /{{idle_duration}}/gi, replace: () => getTimeSinceLastMessage() },
 +        { regex: /{{time_UTC([-+]\d+)}}/gi, replace: (_, offset) => moment().utc().utcOffset(parseInt(offset, 10)).format('LT') },
 +        getTimeDiffMacro(),
 +        getBannedWordsMacro(),
 +        getRandomReplaceMacro(),
 +        getPickReplaceMacro(rawContent),
 +    ];
     // Add all registered macros to the env object
 -    const nonce = uuidv4();
     MacrosParser.populateEnv(env);
 +    const nonce = uuidv4();
 +    const envMacros = [];
     // Substitute passed-in variables
     for (const varName in env) {
         if (!Object.hasOwn(env, varName)) continue;
         contentconst envRegex = content.replace(new RegExp(`{{${escapeRegex(varName)}}}`, 'gi'), () => {;
 +        const envReplace = () => {
             const param = env[varName];
             const value = MacrosParser.sanitizeMacroValue(typeof param === 'function' ? param(nonce) : param);
             return value;
         });
++
 +        envMacros.push({ regex: envRegex, replace: envReplace });
+    }
 -    content = content.replace(/{{maxPrompt}}/gi, () => String(getMaxContextSize()));
 +    const macros = [...preEnvMacros, ...envMacros, ...postEnvMacros];
 -    content = content.replace(/{{lastMessage}}/gi, () => getLastMessage());
++
 -    content = content.replace(/{{lastMessageId}}/gi, () => String(getLastMessageId() ?? ''));
 +    for (const macro of macros) {
 -    content = content.replace(/{{lastUserMessage}}/gi, () => getLastUserMessage());
 +        // Stop if the content is empty
 -    content = content.replace(/{{lastCharMessage}}/gi, () => getLastCharMessage());
 +        if (!content) {
 -    content = content.replace(/{{firstIncludedMessageId}}/gi, () => String(getFirstIncludedMessageId() ?? ''));
 +            break;
 -    content = content.replace(/{{lastSwipeId}}/gi, () => String(getLastSwipeId() ?? ''));
 +        }
 -    content = content.replace(/{{currentSwipeId}}/gi, () => String(getCurrentSwipeId() ?? ''));
 -    content = content.replace(/{{reverse:(.+?)}}/gi, (_, str) => Array.from(str).reverse().join(''));
 -    content = content.replace(/\{\{\/\/([\s\S]*?)\}\}/gm, '');
 +        // Short-circuit if no curly braces are found
 +        if (!macro.regex.source.startsWith('<') && !content.includes('{{')) {
 +            break;
 +        }
             content = content.replace(/{{time}}/gimacro.regex, (...args) => momentpostProcessFn()macro.formatreplace('LT'...args)));
 -    content = content.replace(/{{date}}/gi, () => moment().format('LL'));
 +    }
 -    content = content.replace(/{{weekday}}/gi, () => moment().format('dddd'));
 -    content = content.replace(/{{isotime}}/gi, () => moment().format('HH:mm'));
 -    content = content.replace(/{{isodate}}/gi, () => moment().format('YYYY-MM-DD'));
 -    content = content.replace(/{{datetimeformat +([^}]*)}}/gi, (_, format) => {
 -        const formattedTime = moment().format(format);
 -        return formattedTime;
 -    });
 -    content = content.replace(/{{idle_duration}}/gi, () => getTimeSinceLastMessage());
 -    content = content.replace(/{{time_UTC([-+]\d+)}}/gi, (_, offset) => {
 -        const utcOffset = parseInt(offset, 10);
 -        const utcTime = moment().utc().utcOffset(utcOffset).format('LT');
 -        return utcTime;
 -    });
 -    content = timeDiffReplace(content);
 -    content = bannedWordsReplace(content);
 -    content = randomReplace(content);
 -    content = pickReplace(content, rawContent);
     return content;
+}

public/scripts/variables.js+21 -72 Viewed

     return name;
+}
 -export function replaceVariableMacros(input) {
 +/**
 -    const lines = input.split('\n');
 + * Returns built-in variable macros.
+-
 + * @returns {import('./macros.js').Macro[]}
 -    for (let i = 0; i < lines.length; i++) {
 + */
 -        let line = lines[i];
 +export function getVariableMacros() {
+-
 +    return [
 -        // Skip lines without macros
 -        if (!line || !line.includes('{{')) {
 -            continue;
 -        }
+-
 -        // Replace {{getvar::name}} with the value of the variable name
 -        line = line.replace(/{{getvar::([^}]+)}}/gi, (_, name) => {
 -            name = name.trim();
 -            return getLocalVariable(name);
 -        });
+-
         // Replace {{setvar::name::value}} with empty string and set the variable name to value
         line{ =regex: line.replace(/{{setvar::([^:]+)::([^}]+)}}/gi, replace: (_, name, value) => { setLocalVariable(name.trim(), value); return ''; } },
 -            name = name.trim();
 -            setLocalVariable(name, value);
 -            return '';
 -        });
+-
         // Replace {{addvar::name::value}} with empty string and add value to the variable value
         line{ =regex: line.replace(/{{addvar::([^:]+)::([^}]+)}}/gi, replace: (_, name, value) => { addLocalVariable(name.trim(), value); return ''; } },
 -            name = name.trim();
 -            addLocalVariable(name, value);
 -            return '';
 -        });
+-
         // Replace {{incvar::name}} with empty string and increment the variable name by 1
         line{ =regex: line.replace(/{{incvar::([^}]+)}}/gi, replace: (_, name) => {incrementLocalVariable(name.trim()) },
 -            name = name.trim();
 -            return incrementLocalVariable(name);
 -        });
+-
         // Replace {{decvar::name}} with empty string and decrement the variable name by 1
         line{ =regex: line.replace(/{{decvar::([^}]+)}}/gi, replace: (_, name) => {decrementLocalVariable(name.trim()) },
 -            name = name.trim();
 +        // Replace {{getvar::name}} with the value of the variable name
 -            return decrementLocalVariable(name);
 +        { regex: /{{getvar::([^}]+)}}/gi, replace: (_, name) => getLocalVariable(name.trim()) },
 -        });
+-
 -        // Replace {{getglobalvar::name}} with the value of the global variable name
 -        line = line.replace(/{{getglobalvar::([^}]+)}}/gi, (_, name) => {
 -            name = name.trim();
 -            return getGlobalVariable(name);
 -        });
+-
         // Replace {{setglobalvar::name::value}} with empty string and set the global variable name to value
         line{ =regex: line.replace(/{{setglobalvar::([^:]+)::([^}]+)}}/gi, replace: (_, name, value) => { setGlobalVariable(name.trim(), value); return ''; } },
 -            name = name.trim();
 -            setGlobalVariable(name, value);
 -            return '';
 -        });
+-
         // Replace {{addglobalvar::name::value}} with empty string and add value to the global variable value
         line{ =regex: line.replace(/{{addglobalvar::([^:]+)::([^}]+)}}/gi, replace: (_, name, value) => { addGlobalVariable(name.trim(), value); return ''; } },
 -            name = name.trim();
 -            addGlobalVariable(name, value);
 -            return '';
 -        });
+-
         // Replace {{incglobalvar::name}} with empty string and increment the global variable name by 1
         line{ =regex: line.replace(/{{incglobalvar::([^}]+)}}/gi, replace: (_, name) => {incrementGlobalVariable(name.trim()) },
 -            name = name.trim();
 -            return incrementGlobalVariable(name);
 -        });
+-
         // Replace {{decglobalvar::name}} with empty string and decrement the global variable name by 1
         line{ =regex: line.replace(/{{decglobalvar::([^}]+)}}/gi, replace: (_, name) => {decrementGlobalVariable(name.trim()) },
 -            name = name.trim();
 +        // Replace {{getglobalvar::name}} with the value of the global variable name
 -            return decrementGlobalVariable(name);
 +        { regex: /{{getglobalvar::([^}]+)}}/gi, replace: (_, name) => getGlobalVariable(name.trim()) },
 -        });
 +    ];
+-
 -        lines[i] = line;
 -    }
+-
 -    return lines.join('\n');
+}
 async function listVariablesCallback(args) {

         callback: sortArrayObjectCallback,
         returns: 'the sorted list or dictionary keys',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({ name: 'keysort',
 +                name: 'keysort',
                 description: 'whether to sort by key or value; ignored for lists',
                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 enumList: ['true', 'false'],