Merge branch 'staging' into translation-improvements

fcc00e0b263bcdea477e45dfecce36d2df28d0fa

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

Parents: d99452854835696baf8e7fe898723c92633af13e 2b50ab398b00cbf28ba1c14cf55420156670fcde

jsconfig.json+6 -1 Viewed

         "**/node_modules/*",
         "public/lib",
         "backups/*",
-        "data/*"
+        "data/*",
+        "**/dist/*",
+        "dist/*",
+        "cache/*",
+        "src/tokenizers/*",
+        "docker/*",
+    ]
+}

public/script.js+2 -1 Viewed

 import { debounce_timeout } from './scripts/constants.js';
 import { ModuleWorkerWrapper, doDailyExtensionUpdatesCheck, extension_settings, getContext, loadExtensionSettings, renderExtensionTemplate, renderExtensionTemplateAsync, runGenerationInterceptors, saveMetadataDebounced, writeExtensionField } from './scripts/extensions.js';
-import { COMMENT_NAME_DEFAULT, executeSlashCommands, executeSlashCommandsOnChatInput, getSlashCommandsHelp, isExecutingCommandsFromChatInput, pauseScriptExecution, processChatSlashCommands, registerSlashCommand, stopScriptExecution } from './scripts/slash-commands.js';
+import { COMMENT_NAME_DEFAULT, executeSlashCommands, executeSlashCommandsOnChatInput, getSlashCommandsHelp, initDefaultSlashCommands, isExecutingCommandsFromChatInput, pauseScriptExecution, processChatSlashCommands, registerSlashCommand, stopScriptExecution } from './scripts/slash-commands.js';
 import {
     tag_map,
     tags,

     initKeyboard();
     initDynamicStyles();
     initTags();
+    initDefaultSlashCommands();
     await getUserAvatars(true, user_avatar);
     await getCharacters();
     await getBackgrounds();

public/scripts/extensions/caption/index.js+1 -0 Viewed

                 (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'llamacpp' && textgenerationwebui_settings.server_urls[textgen_types.LLAMACPP]) ||
                 (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'ooba' && textgenerationwebui_settings.server_urls[textgen_types.OOBA]) ||
                 (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'koboldcpp' && textgenerationwebui_settings.server_urls[textgen_types.KOBOLDCPP]) ||
+                (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'vllm' && textgenerationwebui_settings.server_urls[textgen_types.VLLM]) ||
                 (extension_settings.caption.source === 'multimodal' && extension_settings.caption.multimodal_api === 'custom') ||
                 extension_settings.caption.source === 'local' ||
                 extension_settings.caption.source === 'horde';

public/scripts/extensions/caption/settings.html+2 -0 Viewed

                         <option value="openai">OpenAI</option>
                         <option value="openrouter">OpenRouter</option>
                         <option value="ooba" data-i18n="Text Generation WebUI (oobabooga)">Text Generation WebUI (oobabooga)</option>
+                        <option value="vllm">vLLM</option>
                     </select>
                 </div>
                 <div class="flex1 flex-container flexFlowColumn flexNoGap">

                         <option data-type="llamacpp" value="llamacpp_current" data-i18n="currently_loaded">[Currently loaded]</option>
                         <option data-type="ooba" value="ooba_current" data-i18n="currently_loaded">[Currently loaded]</option>
                         <option data-type="koboldcpp" value="koboldcpp_current" data-i18n="currently_loaded">[Currently loaded]</option>
+                        <option data-type="vllm" value="vllm_current" data-i18n="currently_selected">[Currently selected]</option>
                         <option data-type="custom" value="custom_current" data-i18n="currently_selected">[Currently selected]</option>
                     </select>
                 </div>

public/scripts/extensions/shared.js+17 -0 Viewed

     const isCustom = extension_settings.caption.multimodal_api === 'custom';
     const isOoba = extension_settings.caption.multimodal_api === 'ooba';
     const isKoboldCpp = extension_settings.caption.multimodal_api === 'koboldcpp';
+    const isVllm = extension_settings.caption.multimodal_api === 'vllm';
     const base64Bytes = base64Img.length * 0.75;
     const compressionLimit = 2 * 1024 * 1024;
     if ((['google', 'openrouter'].includes(extension_settings.caption.multimodal_api) && base64Bytes > compressionLimit) || isOoba || isKoboldCpp) {

         requestBody.server_url = textgenerationwebui_settings.server_urls[textgen_types.OLLAMA];
+    }
+    if (isVllm) {
+        if (extension_settings.caption.multimodal_model === 'vllm_current') {
+            requestBody.model = textgenerationwebui_settings.vllm_model;
+        }
+        requestBody.server_url = textgenerationwebui_settings.server_urls[textgen_types.VLLM];
+    }
     if (isLlamaCpp) {
         requestBody.server_url = textgenerationwebui_settings.server_urls[textgen_types.LLAMACPP];
+    }

         throw new Error('KoboldCpp server URL is not set.');
+    }
+    if (extension_settings.caption.multimodal_api === 'vllm' && !textgenerationwebui_settings.server_urls[textgen_types.VLLM]) {
+        throw new Error('vLLM server URL is not set.');
+    }
+    if (extension_settings.caption.multimodal_api === 'vllm' && extension_settings.caption.multimodal_model === 'vllm_current' && !textgenerationwebui_settings.vllm_model) {
+        throw new Error('vLLM model is not set.');
+    }
     if (extension_settings.caption.multimodal_api === 'custom' && !oai_settings.custom_url) {
         throw new Error('Custom API URL is not set.');
+    }

public/scripts/extensions/tts/index.js+2 -0 Viewed

 import { power_user } from '../../power-user.js';
 import { OpenAITtsProvider } from './openai.js';
 import { XTTSTtsProvider } from './xtts.js';
+import { VITSTtsProvider } from './vits.js';
 import { GSVITtsProvider } from './gsvi.js';
 import { SBVits2TtsProvider } from './sbvits2.js';
 import { AllTalkTtsProvider } from './alltalk.js';

     ElevenLabs: ElevenLabsTtsProvider,
     Silero: SileroTtsProvider,
     XTTSv2: XTTSTtsProvider,
+    VITS: VITSTtsProvider,
     GSVI: GSVITtsProvider,
     SBVits2: SBVits2TtsProvider,
     System: SystemTtsProvider,

public/scripts/extensions/tts/vits.js+404 -0 Viewed

+import { getPreviewString, saveTtsProviderSettings } from './index.js';
+export { VITSTtsProvider };
+class VITSTtsProvider {
+    //########//
+    // Config //
+    //########//
+    settings;
+    ready = false;
+    voices = [];
+    separator = '. ';
+    audioElement = document.createElement('audio');
+    /**
+     * Perform any text processing before passing to TTS engine.
+     * @param {string} text Input text
+     * @returns {string} Processed text
+     */
+    processText(text) {
+        return text;
+    }
+    audioFormats = ['wav', 'ogg', 'silk', 'mp3', 'flac'];
+    languageLabels = {
+        'Auto': 'auto',
+        'Chinese': 'zh',
+        'English': 'en',
+        'Japanese': 'ja',
+        'Korean': 'ko',
+    };
+    langKey2LangCode = {
+        'zh': 'zh-CN',
+        'en': 'en-US',
+        'ja': 'ja-JP',
+        'ko': 'ko-KR',
+    };
+    modelTypes = {
+        VITS: 'VITS',
+        W2V2_VITS: 'W2V2-VITS',
+        BERT_VITS2: 'BERT-VITS2',
+    };
+    defaultSettings = {
+        provider_endpoint: 'http://localhost:23456',
+        format: 'wav',
+        lang: 'auto',
+        length: 1.0,
+        noise: 0.33,
+        noisew: 0.4,
+        segment_size: 50,
+        streaming: false,
+        dim_emotion: 0,
+        sdp_ratio: 0.2,
+        emotion: 0,
+        text_prompt: '',
+        style_text: '',
+        style_weight: 1,
+    };
+    get settingsHtml() {
+        let html = `
+        <label for="vits_lang">Text Language</label>
+        <select id="vits_lang">`;
+        for (let language in this.languageLabels) {
+            if (this.languageLabels[language] == this.settings?.lang) {
+                html += `<option value="${this.languageLabels[language]}" selected="selected">${language}</option>`;
+                continue;
+            }
+            html += `<option value="${this.languageLabels[language]}">${language}</option>`;
+        }
+        html += `
+        </select>
+        <label>VITS / W2V2-VITS / Bert-VITS2 Settings:</label><br/>
+        <label for="vits_endpoint">Provider Endpoint:</label>
+        <input id="vits_endpoint" type="text" class="text_pole" maxlength="250" value="${this.defaultSettings.provider_endpoint}"/>
+        <span>Use <a target="_blank" href="https://github.com/Artrajz/vits-simple-api">vits-simple-api</a>.</span><br/>
+        <label for="vits_format">Audio format:</label>
+        <select id="vits_format">`;
+        for (let format of this.audioFormats) {
+            if (format == this.settings?.format) {
+                html += `<option value="${format}" selected="selected">${format}</option>`;
+                continue;
+            }
+            html += `<option value="${format}">${format}</option>`;
+        }
+        html += `
+        </select>
+        <label for="vits_length">Audio length: <span id="vits_length_output">${this.defaultSettings.length}</span></label>
+        <input id="vits_length" type="range" value="${this.defaultSettings.length}" min="0.0" max="5" step="0.01" />
+        <label for="vits_noise">Noise: <span id="vits_noise_output">${this.defaultSettings.noise}</span></label>
+        <input id="vits_noise" type="range" value="${this.defaultSettings.noise}" min="0.1" max="2" step="0.01" />
+        <label for="vits_noisew">SDP noise: <span id="vits_noisew_output">${this.defaultSettings.noisew}</span></label>
+        <input id="vits_noisew" type="range" value="${this.defaultSettings.noisew}" min="0.1" max="2" step="0.01" />
+        <label for="vits_segment_size">Segment Size: <span id="vits_segment_size_output">${this.defaultSettings.segment_size}</span></label>
+        <input id="vits_segment_size" type="range" value="${this.defaultSettings.segment_size}" min="0" max="1000" step="1" />
+        <label for="vits_streaming" class="checkbox_label">
+            <input id="vits_streaming" type="checkbox" />
+            <span>Streaming</span>
+        </label>
+        <label>W2V2-VITS Settings:</label><br/>
+        <label for="vits_dim_emotion">Dimensional emotion:</label>
+        <input id="vits_dim_emotion" type="number" class="text_pole" min="0" max="5457" step="1" value="${this.defaultSettings.dim_emotion}"/>
+        <label>BERT-VITS2 Settings:</label><br/>
+        <label for="vits_sdp_ratio">sdp_ratio: <span id="vits_sdp_ratio_output">${this.defaultSettings.sdp_ratio}</span></label>
+        <input id="vits_sdp_ratio" type="range" value="${this.defaultSettings.sdp_ratio}" min="0.0" max="1" step="0.01" />
+        <label for="vits_emotion">emotion: <span id="vits_emotion_output">${this.defaultSettings.emotion}</span></label>
+        <input id="vits_emotion" type="range" value="${this.defaultSettings.emotion}" min="0" max="9" step="1" />
+        <label for="vits_text_prompt">Text Prompt:</label>
+        <input id="vits_text_prompt" type="text" class="text_pole" maxlength="512" value="${this.defaultSettings.text_prompt}"/>
+        <label for="vits_style_text">Style text:</label>
+        <input id="vits_style_text" type="text" class="text_pole" maxlength="512" value="${this.defaultSettings.style_text}"/>
+        <label for="vits_style_weight">Style weight <span id="vits_style_weight_output">${this.defaultSettings.style_weight}</span></label>
+        <input id="vits_style_weight" type="range" value="${this.defaultSettings.style_weight}" min="0" max="1" step="0.01" />
+        `;
+        return html;
+    }
+    onSettingsChange() {
+        // Used when provider settings are updated from UI
+        this.settings.provider_endpoint = $('#vits_endpoint').val();
+        this.settings.lang = $('#vits_lang').val();
+        this.settings.format = $('#vits_format').val();
+        this.settings.dim_emotion = $('#vits_dim_emotion').val();
+        this.settings.text_prompt = $('#vits_text_prompt').val();
+        this.settings.style_text = $('#vits_style_text').val();
+        // Update the default TTS settings based on input fields
+        this.settings.length = $('#vits_length').val();
+        this.settings.noise = $('#vits_noise').val();
+        this.settings.noisew = $('#vits_noisew').val();
+        this.settings.segment_size = $('#vits_segment_size').val();
+        this.settings.streaming = $('#vits_streaming').is(':checked');
+        this.settings.sdp_ratio = $('#vits_sdp_ratio').val();
+        this.settings.emotion = $('#vits_emotion').val();
+        this.settings.style_weight = $('#vits_style_weight').val();
+        // Update the UI to reflect changes
+        $('#vits_length_output').text(this.settings.length);
+        $('#vits_noise_output').text(this.settings.noise);
+        $('#vits_noisew_output').text(this.settings.noisew);
+        $('#vits_segment_size_output').text(this.settings.segment_size);
+        $('#vits_sdp_ratio_output').text(this.settings.sdp_ratio);
+        $('#vits_emotion_output').text(this.settings.emotion);
+        $('#vits_style_weight_output').text(this.settings.style_weight);
+        saveTtsProviderSettings();
+        this.changeTTSSettings();
+    }
+    async loadSettings(settings) {
+        // Pupulate Provider UI given input settings
+        if (Object.keys(settings).length == 0) {
+            console.info('Using default TTS Provider settings');
+        }
+        // Only accept keys defined in defaultSettings
+        this.settings = this.defaultSettings;
+        for (const key in settings) {
+            if (key in this.settings) {
+                this.settings[key] = settings[key];
+            } else {
+                console.debug(`Ignoring non-user-configurable setting: ${key}`);
+            }
+        }
+        // Set initial values from the settings
+        $('#vits_endpoint').val(this.settings.provider_endpoint);
+        $('#vits_lang').val(this.settings.lang);
+        $('#vits_format').val(this.settings.format);
+        $('#vits_length').val(this.settings.length);
+        $('#vits_noise').val(this.settings.noise);
+        $('#vits_noisew').val(this.settings.noisew);
+        $('#vits_segment_size').val(this.settings.segment_size);
+        $('#vits_streaming').prop('checked', this.settings.streaming);
+        $('#vits_dim_emotion').val(this.settings.dim_emotion);
+        $('#vits_sdp_ratio').val(this.settings.sdp_ratio);
+        $('#vits_emotion').val(this.settings.emotion);
+        $('#vits_text_prompt').val(this.settings.text_prompt);
+        $('#vits_style_text').val(this.settings.style_text);
+        $('#vits_style_weight').val(this.settings.style_weight);
+        // Update the UI to reflect changes
+        $('#vits_length_output').text(this.settings.length);
+        $('#vits_noise_output').text(this.settings.noise);
+        $('#vits_noisew_output').text(this.settings.noisew);
+        $('#vits_segment_size_output').text(this.settings.segment_size);
+        $('#vits_sdp_ratio_output').text(this.settings.sdp_ratio);
+        $('#vits_emotion_output').text(this.settings.emotion);
+        $('#vits_style_weight_output').text(this.settings.style_weight);
+        // Register input/change event listeners to update settings on user interaction
+        $('#vits_endpoint').on('input', () => { this.onSettingsChange(); });
+        $('#vits_lang').on('change', () => { this.onSettingsChange(); });
+        $('#vits_format').on('change', () => { this.onSettingsChange(); });
+        $('#vits_length').on('change', () => { this.onSettingsChange(); });
+        $('#vits_noise').on('change', () => { this.onSettingsChange(); });
+        $('#vits_noisew').on('change', () => { this.onSettingsChange(); });
+        $('#vits_segment_size').on('change', () => { this.onSettingsChange(); });
+        $('#vits_streaming').on('change', () => { this.onSettingsChange(); });
+        $('#vits_dim_emotion').on('change', () => { this.onSettingsChange(); });
+        $('#vits_sdp_ratio').on('change', () => { this.onSettingsChange(); });
+        $('#vits_emotion').on('change', () => { this.onSettingsChange(); });
+        $('#vits_text_prompt').on('change', () => { this.onSettingsChange(); });
+        $('#vits_style_text').on('change', () => { this.onSettingsChange(); });
+        $('#vits_style_weight').on('change', () => { this.onSettingsChange(); });
+        await this.checkReady();
+        console.info('VITS: Settings loaded');
+    }
+    // Perform a simple readiness check by trying to fetch voiceIds
+    async checkReady() {
+        await Promise.allSettled([this.fetchTtsVoiceObjects(), this.changeTTSSettings()]);
+    }
+    async onRefreshClick() {
+        return;
+    }
+    //#################//
+    //  TTS Interfaces //
+    //#################//
+    async getVoice(voiceName) {
+        if (this.voices.length == 0) {
+            this.voices = await this.fetchTtsVoiceObjects();
+        }
+        const match = this.voices.filter(
+            v => v.name == voiceName,
+        )[0];
+        if (!match) {
+            throw `TTS Voice name ${voiceName} not found`;
+        }
+        return match;
+    }
+    async getVoiceById(voiceId) {
+        if (this.voices.length == 0) {
+            this.voices = await this.fetchTtsVoiceObjects();
+        }
+        const match = this.voices.filter(
+            v => v.voice_id == voiceId,
+        )[0];
+        if (!match) {
+            throw `TTS Voice id ${voiceId} not found`;
+        }
+        return match;
+    }
+    async generateTts(text, voiceId) {
+        const response = await this.fetchTtsGeneration(text, voiceId);
+        return response;
+    }
+    //###########//
+    // API CALLS //
+    //###########//
+    async fetchTtsVoiceObjects() {
+        const response = await fetch(`${this.settings.provider_endpoint}/voice/speakers`);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${await response.json()}`);
+        }
+        const jsonData = await response.json();
+        const voices = [];
+        const addVoices = (modelType) => {
+            jsonData[modelType].forEach(voice => {
+                voices.push({
+                    name: `[${modelType}] ${voice.name} (${voice.lang})`,
+                    voice_id: `${modelType}&${voice.id}`,
+                    preview_url: false,
+                    lang: voice.lang,
+                });
+            });
+        };
+        for (const key in this.modelTypes) {
+            addVoices(this.modelTypes[key]);
+        }
+        this.voices = voices; // Assign to the class property
+        return voices; // Also return this list
+    }
+    // Each time a parameter is changed, we change the configuration
+    async changeTTSSettings() {
+    }
+    /**
+     * Fetch TTS generation from the API.
+     * @param {string} inputText Text to generate TTS for
+     * @param {string} voiceId Voice ID to use (model_type&speaker_id))
+     * @returns {Promise<Response|string>} Fetch response
+     */
+    async fetchTtsGeneration(inputText, voiceId, lang = null, forceNoStreaming = false) {
+        console.info(`Generating new TTS for voice_id ${voiceId}`);
+        const streaming = !forceNoStreaming && this.settings.streaming;
+        const [model_type, speaker_id] = voiceId.split('&');
+        const params = new URLSearchParams();
+        params.append('text', inputText);
+        params.append('id', speaker_id);
+        if (streaming) {
+            params.append('streaming', streaming);
+            // Streaming response only supports MP3
+        }
+        else {
+            params.append('format', this.settings.format);
+        }
+        params.append('lang', lang ?? this.settings.lang);
+        params.append('length', this.settings.length);
+        params.append('noise', this.settings.noise);
+        params.append('noisew', this.settings.noisew);
+        params.append('segment_size', this.settings.segment_size);
+        if (model_type == this.modelTypes.W2V2_VITS) {
+            params.append('emotion', this.settings.dim_emotion);
+        }
+        else if (model_type == this.modelTypes.BERT_VITS2) {
+            params.append('sdp_ratio', this.settings.sdp_ratio);
+            params.append('emotion', this.settings.emotion);
+            if (this.settings.text_prompt) {
+                params.append('text_prompt', this.settings.text_prompt);
+            }
+            if (this.settings.style_text) {
+                params.append('style_text', this.settings.style_text);
+                params.append('style_weight', this.settings.style_weight);
+            }
+        }
+        const url = `${this.settings.provider_endpoint}/voice/${model_type.toLowerCase()}`;
+        if (streaming) {
+            return url + `?${params.toString()}`;
+        }
+        const response = await fetch(
+            url,
+            {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: params,
+            },
+        );
+        if (!response.ok) {
+            toastr.error(response.statusText, 'TTS Generation Failed');
+            throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+        }
+        return response;
+    }
+    /**
+     * Preview TTS for a given voice ID.
+     * @param {string} id Voice ID
+     */
+    async previewTtsVoice(id) {
+        this.audioElement.pause();
+        this.audioElement.currentTime = 0;
+        const voice = await this.getVoiceById(id);
+        const lang = voice.lang.includes(this.settings.lang) ? this.settings.lang : voice.lang[0];
+        let lang_code = this.langKey2LangCode[lang];
+        const text = getPreviewString(lang_code);
+        const response = await this.fetchTtsGeneration(text, id, lang, true);
+        if (typeof response != 'string') {
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+            }
+            const audio = await response.blob();
+            const url = URL.createObjectURL(audio);
+            this.audioElement.src = url;
+            this.audioElement.play();
+        }
+    }
+    // Interface not used
+    async fetchTtsFromHistory(history_item_id) {
+        return Promise.resolve(history_item_id);
+    }
+}

public/scripts/slash-commands.js+106 -19 Viewed

     system_message_types,
     this_chid,
 } from '../script.js';
-import { PARSER_FLAG, SlashCommandParser } from './slash-commands/SlashCommandParser.js';
+import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { SlashCommandParserError } from './slash-commands/SlashCommandParserError.js';
 import { getMessageTimeStamp } from './RossAscends-mods.js';
 import { hideChatMessageRange } from './chats.js';
-import { extension_settings, getContext, saveMetadataDebounced } from './extensions.js';
+import { getContext, saveMetadataDebounced } from './extensions.js';
 import { getRegexedString, regex_placement } from './extensions/regex/engine.js';
-import { findGroupMemberId, getGroupMembers, groups, is_group_generating, openGroupById, resetSelectedGroup, saveGroupChat, selected_group } from './group-chats.js';
+import { findGroupMemberId, groups, is_group_generating, openGroupById, resetSelectedGroup, saveGroupChat, selected_group } from './group-chats.js';
 import { chat_completion_sources, oai_settings, setupChatCompletionPromptManager } from './openai.js';
 import { autoSelectPersona, retriggerFirstMessageOnEmptyChat, setPersonaLockState, togglePersonaLock, user_avatar } from './personas.js';
 import { addEphemeralStoppingString, chat_styles, flushEphemeralStoppingStrings, power_user } from './power-user.js';

 import { debounce, delay, isFalseBoolean, isTrueBoolean, stringToRange, trimToEndSentence, trimToStartSentence, waitUntilCondition } from './utils.js';
 import { registerVariableCommands, resolveVariable } from './variables.js';
 import { background_settings } from './backgrounds.js';
-import { SlashCommandScope } from './slash-commands/SlashCommandScope.js';
 import { SlashCommandClosure } from './slash-commands/SlashCommandClosure.js';
 import { SlashCommandClosureResult } from './slash-commands/SlashCommandClosureResult.js';
 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './slash-commands/SlashCommandArgument.js';

 const registerSlashCommand = SlashCommandParser.addCommand.bind(SlashCommandParser);
 const getSlashCommandsHelp = parser.getHelpString.bind(parser);
+export function initDefaultSlashCommands() {
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: '?',
         callback: helpCommandCallback,

             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'at',
-            description: 'position to insert the message',
+                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),

             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'at',
-            description: 'position to insert the message',
+                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),

             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'at',
-            description: 'position to insert the message',
+                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),

             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'at',
-            description: 'position to insert the message',
+                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),

                     new SlashCommandEnumValue('success', 'success', enumTypes.enum, '✅'),
                 ],
             }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'timeout',
+                description: 'time in milliseconds to display the toast message. Set this and \'extendedTimeout\' to 0 to show indefinitely until dismissed.',
+                typeList: [ARGUMENT_TYPE.NUMBER],
+                defaultValue: `${toastr.options.timeOut}`,
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'extendedTimeout',
+                description: 'time in milliseconds to display the toast message. Set this and \'timeout\' to 0 to show indefinitely until dismissed.',
+                typeList: [ARGUMENT_TYPE.NUMBER],
+                defaultValue: `${toastr.options.extendedTimeOut}`,
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'preventDuplicates',
+                description: 'prevent duplicate toasts with the same message from being displayed.',
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'false',
+                enumList: commonEnumProviders.boolean('trueFalse')(),
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'awaitDismissal',
+                description: 'wait for the toast to be dismissed before continuing.',
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'false',
+                enumList: commonEnumProviders.boolean('trueFalse')(),
+            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

     }));
     registerVariableCommands();
+}
 const NARRATOR_NAME_KEY = 'narrator_name';
 const NARRATOR_NAME_DEFAULT = 'System';

+    }
+}
+/**
+ *
+ * @param {{title?: string, severity?: string, timeout?: string, extendedTimeout?: string, preventDuplicates?: string, awaitDismissal?: string}} args - named arguments from the slash command
+ * @param {string} value - The string to echo (unnamed argument from the slash command)
+ * @returns {Promise<string>} The text that was echoed
+ */
 async function echoCallback(args, value) {
     // Note: We don't need to sanitize input, as toastr is set up by default to escape HTML via toastr options
     if (value === '') {
         console.warn('WARN: No argument provided for /echo command');
-        return;
+        return '';
+    }
+    if (args.severity && !['error', 'warning', 'success', 'info'].includes(args.severity)) {
+        toastr.warning(`Invalid severity provided for /echo command: ${args.severity}`);
+        args.severity = null;
+    }
-    const title = args?.title !== undefined && typeof args?.title === 'string' ? args.title : undefined;
-    const severity = args?.severity !== undefined && typeof args?.severity === 'string' ? args.severity : 'info';
+    const title = args.title ? args.title : undefined;
+    const severity = args.severity ? args.severity : 'info';
+    /** @type {ToastrOptions} */
+    const options = {};
+    if (args.timeout && !isNaN(parseInt(args.timeout))) options.timeOut = parseInt(args.timeout);
+    if (args.extendedTimeout && !isNaN(parseInt(args.extendedTimeout))) options.extendedTimeOut = parseInt(args.extendedTimeout);
+    if (isTrueBoolean(args.preventDuplicates)) options.preventDuplicates = true;
+    // Prepare possible await handling
+    let awaitDismissal = isTrueBoolean(args.awaitDismissal);
+    let resolveToastDismissal;
+    if (awaitDismissal) {
+        options.onHidden = () => resolveToastDismissal(value);
+    }
     switch (severity) {
         case 'error':
-            toastr.error(value, title);
+            toastr.error(value, title, options);
             break;
         case 'warning':
-            toastr.warning(value, title);
+            toastr.warning(value, title, options);
             break;
         case 'success':
-            toastr.success(value, title);
+            toastr.success(value, title, options);
             break;
         case 'info':
         default:
-            toastr.info(value, title);
+            toastr.info(value, title, options);
             break;
+    }
+    if (awaitDismissal) {
+        return new Promise((resolve) => {
+            resolveToastDismissal = resolve;
+        });
+    } else {
         return value;
+    }
+}
 async function addSwipeCallback(_, arg) {
     const lastMessage = chat[chat.length - 1];

     text = text.trim();
     const compact = isTrueBoolean(args?.compact);
     const bias = extractMessageBias(text);
-    const insertAt = Number(args?.at);
+    let insertAt = Number(args?.at);
+    // Convert possible depth parameter to index
+    if (!isNaN(insertAt) && (insertAt < 0 || insertAt === Number(-0))) {
+        // Negative value means going back from current chat length. (E.g.: 8 messages, Depth 1 means insert at index 7)
+        insertAt = chat.length + insertAt;
+    }
     if ('name' in args) {
         const name = args.name || '';

         },
     }];
-    const insertAt = Number(args.at);
+    let insertAt = Number(args.at);
+    // Convert possible depth parameter to index
+    if (!isNaN(insertAt) && (insertAt < 0 || insertAt === Number(-0))) {
+        // Negative value means going back from current chat length. (E.g.: 8 messages, Depth 1 means insert at index 7)
+        insertAt = chat.length + insertAt;
+    }
     if (!isNaN(insertAt) && insertAt >= 0 && insertAt <= chat.length) {
         chat.splice(insertAt, 0, message);

         },
     };
-    const insertAt = Number(args.at);
+    let insertAt = Number(args.at);
+    // Convert possible depth parameter to index
+    if (!isNaN(insertAt) && (insertAt < 0 || insertAt === Number(-0))) {
+        // Negative value means going back from current chat length. (E.g.: 8 messages, Depth 1 means insert at index 7)
+        insertAt = chat.length + insertAt;
+    }
     if (!isNaN(insertAt) && insertAt >= 0 && insertAt <= chat.length) {
         chat.splice(insertAt, 0, message);

         },
     };
-    const insertAt = Number(args.at);
+    let insertAt = Number(args.at);
+    // Convert possible depth parameter to index
+    if (!isNaN(insertAt) && (insertAt < 0 || insertAt === Number(-0))) {
+        // Negative value means going back from current chat length. (E.g.: 8 messages, Depth 1 means insert at index 7)
+        insertAt = chat.length + insertAt;
+    }
     if (!isNaN(insertAt) && insertAt >= 0 && insertAt <= chat.length) {
         chat.splice(insertAt, 0, message);

public/scripts/slash-commands/SlashCommandArgument.js+5 -5 Viewed

      * @param {string|SlashCommandEnumValue|(string|SlashCommandEnumValue)[]} enums
      * @param {(executor:SlashCommandExecutor)=>SlashCommandEnumValue[]} enumProvider function that returns auto complete options
      */
-    constructor(description, types, isRequired = false, acceptsMultiple = false, defaultValue = null, enums = [], enumProvider = null, forceEnum = true) {
+    constructor(description, types, isRequired = false, acceptsMultiple = false, defaultValue = null, enums = [], enumProvider = null, forceEnum = false) {
         this.description = description;
         this.typeList = types ? Array.isArray(types) ? types : [types] : [];
         this.isRequired = isRequired ?? false;

      * @param {string|SlashCommandClosure} [props.defaultValue=null] default value if no value is provided
      * @param {string|SlashCommandEnumValue|(string|SlashCommandEnumValue)[]} [props.enumList=[]] list of accepted values
      * @param {(executor:SlashCommandExecutor)=>SlashCommandEnumValue[]} [props.enumProvider=null] function that returns auto complete options
-     * @param {boolean} [props.forceEnum=true] default: true - whether the input must match one of the enum values
+     * @param {boolean} [props.forceEnum=false] default: false - whether the input must match one of the enum values
      */
     static fromProps(props) {
         return new SlashCommandNamedArgument(

             props.enumList ?? [],
             props.aliasList ?? [],
             props.enumProvider ?? null,
-            props.forceEnum ?? true,
+            props.forceEnum ?? false,
         );
+    }

      * @param {string|SlashCommandEnumValue|(string|SlashCommandEnumValue)[]} [enums=[]]
      * @param {string[]} [aliases=[]]
      * @param {(executor:SlashCommandExecutor)=>SlashCommandEnumValue[]} [enumProvider=null] function that returns auto complete options
-     * @param {boolean} [forceEnum=true]
+     * @param {boolean} [forceEnum=false]
      */
-    constructor(name, description, types, isRequired = false, acceptsMultiple = false, defaultValue = null, enums = [], aliases = [], enumProvider = null, forceEnum = true) {
+    constructor(name, description, types, isRequired = false, acceptsMultiple = false, defaultValue = null, enums = [], aliases = [], enumProvider = null, forceEnum = false) {
         super(description, types, isRequired, acceptsMultiple, defaultValue, enums, enumProvider, forceEnum);
         this.name = name;
         this.aliasList = aliases ? Array.isArray(aliases) ? aliases : [aliases] : [];

src/endpoints/openai.js+6 -2 Viewed

@@ -43,7 +43,11 @@ router.post('/caption-image', jsonParser, async (request, response) => {
43	key = readSecret(request.user.directories, SECRET_KEYS.KOBOLDCPP);	43	key = readSecret(request.user.directories, SECRET_KEYS.KOBOLDCPP);
44	}	44	}
45		45
46	if (!key && !request.body.reverse_proxy && ['custom', 'ooba', 'koboldcpp'].includes(request.body.api) === false) {	46	if (request.body.api === 'vllm') {
		47	key = readSecret(request.user.directories, SECRET_KEYS.VLLM);
		48	}
		49
		50	if (!key && !request.body.reverse_proxy && ['custom', 'ooba', 'koboldcpp', 'vllm'].includes(request.body.api) === false) {
47	console.log('No key found for API', request.body.api);	51	console.log('No key found for API', request.body.api);
48	return response.sendStatus(400);	52	return response.sendStatus(400);
49	}	53	}

@@ -110,7 +114,7 @@ router.post('/caption-image', jsonParser, async (request, response) => {
110	});	114	});
111	}	115	}
112		116
113	if (request.body.api === 'koboldcpp') {	117	if (request.body.api === 'koboldcpp' \|\| request.body.api === 'vllm') {
114	apiUrl = `${trimV1(request.body.server_url)}/v1/chat/completions`;	118	apiUrl = `${trimV1(request.body.server_url)}/v1/chat/completions`;
115	}	119	}
116		120