add Slash commands regenerate and swipe (#5243) * add Slash commands regenerate and swipe * Update /swipe slash command direction handling * Fix await not working in groups * Add SLASH_COMMAND source to swipe functionality and update constants --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

2415e6bc86157577024e17f1e4dbfc02abf019d9

Haochen <38915833+hcsum@users.noreply.github.com>

Signed

Parents: 8c07dcda243718851aa5cf22095ef23eeeb23ae2

public/script.js+1 -1 Viewed

     const mesId = Number(forceMesId ?? event?.currentTarget?.closest('.mes')?.getAttribute('mesid') ?? messageIndex ?? chat.length - 1);
 -    if (source === SWIPE_SOURCE.DELETE || source === SWIPE_SOURCE.BACK || source === SWIPE_SOURCE.AUTO_SWIPE) {
 +    if ([SWIPE_SOURCE.DELETE, SWIPE_SOURCE.BACK, SWIPE_SOURCE.AUTO_SWIPE, SWIPE_SOURCE.SLASH_COMMAND].includes(source)) {
         console.info(`The ${direction} swipe source on message #${mesId} is ${source}, Most checks have been bypassed. `);
     } else {
         //Only show an error if swipes are not hidden and a message is generating.

public/scripts/constants.js+1 -0 Viewed

     KEYBOARD: 'keyboard',
     BACK: 'back',
     AUTO_SWIPE: 'auto_swipe',
 +    SLASH_COMMAND: 'slash_command',
 };
 /**

public/scripts/group-chats.js+1 -1 Viewed

     const abortController = new AbortController();
     setExternalAbortController(abortController);
     return generateGroupWrapper(false, 'normal', { signal: abortController.signal });
+}
 /**

public/scripts/slash-commands.js+121 -2 Viewed

     setCharacterName,
     setExtensionPrompt,
     showMoreMessages,
 +    swipe,
     stopGeneration,
     substituteParams,
     syncMesToSwipe,

 import { hideChatMessageRange } from './chats.js';
 import { getContext, saveMetadataDebounced } from './extensions.js';
 import { getRegexedString, regex_placement } from './extensions/regex/engine.js';
 import { findGroupMemberId, groups, is_group_generating, openGroupById, regenerateGroup, resetSelectedGroup, saveGroupChat, selected_group, getGroupMembers } from './group-chats.js';
 import { chat_completion_sources, oai_settings, promptManager, ZAI_ENDPOINT } from './openai.js';
 import { user_avatar } from './personas.js';
 import { addEphemeralStoppingString, chat_styles, context_presets, flushEphemeralStoppingStrings, playMessageSound, power_user } from './power-user.js';

 import { t } from './i18n.js';
 import { kai_settings } from './kai-settings.js';
 import { instruct_presets, selectContextPreset, selectInstructPreset } from './instruct-mode.js';
 import { debounce_timeout, SWIPE_DIRECTION, SWIPE_SOURCE } from './constants.js';
 export {
     executeSlashCommands, executeSlashCommandsWithOptions, getSlashCommandsHelp, registerSlashCommand,
 };

     `,
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'regenerate',
 +        callback: regenerateChatCallback,
 +        aliases: ['regen'],
 +        namedArgumentList: [
 +            new SlashCommandNamedArgument(
 +                'await',
 +                t`Whether to await for the regeneration before proceeding`,
 +                [ARGUMENT_TYPE.BOOLEAN],
 +                false,
 +                false,
 +                'false',
 +            ),
 +        ],
 +        helpString: `
 +        <div>
 +            ${t`Regenerates the latest reply in the chat.`}
 +        </div>
 +        <div>
 +            ${t`If <code>await=true</code> named argument is passed, the command will await for the regeneration before proceeding.`}
 +        </div>
 +    `,
 +    }));
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'swipe',
 +        callback: swipeChatCallback,
 +        namedArgumentList: [
 +            new SlashCommandNamedArgument(
 +                'direction',
 +                t`Swipe direction`,
 +                [ARGUMENT_TYPE.STRING],
 +                false,
 +                false,
 +                SWIPE_DIRECTION.RIGHT,
 +                [
 +                    new SlashCommandEnumValue(SWIPE_DIRECTION.RIGHT, t`Swipe to the next reply`, enumTypes.enum, enumIcons.default),
 +                    new SlashCommandEnumValue(SWIPE_DIRECTION.LEFT, t`Swipe to the previous reply`, enumTypes.enum, enumIcons.default),
 +                ],
 +                [],
 +                null,
 +                true,
 +            ),
 +            new SlashCommandNamedArgument(
 +                'await',
 +                t`Whether to await for the swipe action before proceeding`,
 +                [ARGUMENT_TYPE.BOOLEAN],
 +                false,
 +                false,
 +                'false',
 +            ),
 +        ],
 +        helpString: `
 +        <div>
 +            ${t`Swipes the latest reply. Defaults to <code>direction=right</code>; use <code>direction=left</code> to go to the previous reply. If no next swipe exists, behavior depends on message context.`}
 +        </div>
 +        <div>
 +            ${t`If <code>await=true</code> named argument is passed, the command will await for the swipe action before proceeding.`}
 +        </div>
 +    `,
 +    }));
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'go',
         callback: goToCharacterCallback,
         returns: t`The character/group name`,

     return '';
+}
 +async function regenerateChatCallback(args) {
 +    const shouldAwait = isTrueBoolean(args?.await);
++
 +    const outerPromise = new Promise((outerResolve) => setTimeout(async () => {
 +        try {
 +            await waitUntilCondition(() => !is_send_press && !is_group_generating, 10000, 100);
 +        } catch {
 +            console.warn('Timeout waiting for generation unlock');
 +            toastr.warning(t`Cannot run /regenerate command while the reply is being generated.`);
 +            outerResolve(Promise.resolve(''));
 +            return '';
 +        }
++
 +        if (selected_group) {
 +            outerResolve(Promise.resolve(regenerateGroup()));
 +            return '';
 +        }
++
 +        outerResolve(new Promise(innerResolve => setTimeout(() => {
 +            innerResolve(Generate('regenerate'));
 +        }, 1)));
 +        return '';
 +    }, 1));
++
 +    if (shouldAwait) {
 +        const innerPromise = await outerPromise;
 +        await innerPromise;
 +    }
++
 +    return '';
 +}
++
 +async function swipeChatCallback(args) {
 +    const shouldAwait = isTrueBoolean(args?.await);
 +    const direction = args?.direction === SWIPE_DIRECTION.LEFT ? SWIPE_DIRECTION.LEFT : SWIPE_DIRECTION.RIGHT;
++
 +    const outerPromise = new Promise((outerResolve) => setTimeout(async () => {
 +        try {
 +            await waitUntilCondition(() => !is_send_press && !is_group_generating, 10000, 100);
 +        } catch {
 +            console.warn('Timeout waiting for generation unlock');
 +            toastr.warning(t`Cannot run /swipe command while the reply is being generated.`);
 +            outerResolve(Promise.resolve(''));
 +            return '';
 +        }
++
 +        outerResolve(Promise.resolve(swipe(null, direction, { source: SWIPE_SOURCE.SLASH_COMMAND, repeated: false })));
 +        return '';
 +    }, 1));
++
 +    if (shouldAwait) {
 +        const innerPromise = await outerPromise;
 +        await innerPromise;
 +    }
++
 +    return '';
 +}
++
 export async function generateSystemMessage(args, prompt) {
     $('#send_textarea').val('')[0].dispatchEvent(new Event('input', { bubbles: true }));