Merge 182ebed1c1 into 4e9a113a35

Follow ups and fixes for the new STscript parser

public/css/tags.css

@@ -103,7 +103,8 @@
 }
 
 #bulkTagsList,
-#tagList .tag {
+#tagList .tag,
+#groupTagList .tag {
     opacity: 0.6;
 }
 

public/index.html

@@ -1249,7 +1249,7 @@
                                         <input class="neo-range-slider" type="range" id="max_tokens_second_textgenerationwebui" name="volume" min="0" max="20" step="1" />
                                         <input class="neo-range-input" type="number" min="0" max="20" step="1" data-for="max_tokens_second_textgenerationwebui" id="max_tokens_second_counter_textgenerationwebui">
                                     </div>
-                                    <div data-newbie-hidden data-tg-type="mancer, ooba, koboldcpp, aphrodite, tabby" name="smoothingBlock" class="wide100p">
+                                    <div data-newbie-hidden data-tg-type="mancer, ooba, koboldcpp, aphrodite, tabby, llamacpp" name="smoothingBlock" class="wide100p">
                                         <h4 class="wide100p textAlignCenter">
                                             <label data-i18n="Smooth Sampling">Smooth Sampling</label>
                                             <div class=" fa-solid fa-circle-info opacity50p " data-i18n="[title]Smooth Sampling" title="Allows you to use quadratic/cubic transformations to adjust the distribution. Lower Smoothing Factor values will be more creative, usually between 0.2-0.3 is the sweetspot (assuming the curve = 1). Higher Smoothing Curve values will make the curve steeper, which will punish low probability choices more aggressively. 1.0 curve is equivalent to only using Smoothing Factor."></div>
@@ -1458,7 +1458,7 @@
                                             </div>
                                         </div>
                                     </div>
-                                    <div data-newbie-hidden id="json_schema_block" data-tg-type="tabby" class="wide100p">
+                                    <div data-newbie-hidden id="json_schema_block" data-tg-type="tabby, llamacpp" class="wide100p">
                                         <hr class="wide100p">
                                         <h4 class="wide100p textAlignCenter"><span data-i18n="JSON Schema">JSON Schema</span>
                                             <a href="https://json-schema.org/learn/getting-started-step-by-step" target="_blank">

public/scripts/extensions/expressions/index.js

@@ -1020,12 +1020,12 @@ function parseLlmResponse(emotionResponse, labels) {
         const parsedEmotion = JSON.parse(emotionResponse);
         return parsedEmotion?.emotion ?? fallbackExpression;
     } catch {
-        const fuse = new Fuse([emotionResponse]);
-        for (const label of labels) {
-            const result = fuse.search(label);
-            if (result.length > 0) {
-                return label;
-            }
+        const fuse = new Fuse(labels, { includeScore: true });
+        console.debug('Using fuzzy search in labels:', labels);
+        const result = fuse.search(emotionResponse);
+        if (result.length > 0) {
+            console.debug(`fuzzy search found: ${result[0].item} as closest for the LLM response:`, emotionResponse);
+            return result[0].item;
         }
     }
 

public/scripts/extensions/quick-reply/style.css

@@ -232,6 +232,7 @@
   }
   body .dialogue_popup:has(#qr--modalEditor) .dialogue_popup_text > #qr--modalEditor > #qr--main > .qr--modal-messageContainer > #qr--modal-messageHolder {
     min-height: 50svh;
+    height: 50svh;
   }
 }
 .dialogue_popup:has(#qr--modalEditor) {

public/scripts/extensions/quick-reply/style.less

@@ -255,6 +255,7 @@
 		}
 		> #qr--main > .qr--modal-messageContainer > #qr--modal-messageHolder {
 			min-height: 50svh;
+			height: 50svh;
 		}
 	}
 }

public/scripts/preset-manager.js

@@ -114,7 +114,9 @@ class PresetManager {
      * @returns {any} Preset value
      */
     findPreset(name) {
-        return $(this.select).find(`option:contains(${name})`).val();
+        return $(this.select).find('option').filter(function() {
+            return $(this).text() === name;
+        }).val();
     }
 
     /**

public/scripts/slash-commands.js

@@ -704,6 +704,19 @@ SlashCommandParser.addCommandObject(SlashCommand.fromProps({ name: 'addswipe',
 }));
 SlashCommandParser.addCommandObject(SlashCommand.fromProps({ name: 'abort',
     callback: abortCallback,
+    namedArgumentList: [
+        SlashCommandNamedArgument.fromProps({ name: 'quiet',
+            description: 'Whether to suppress the toast message notifying about the /abort call.',
+            typeList: [ARGUMENT_TYPE.BOOLEAN],
+            defaultValue: 'true',
+            enumList: ['true', 'false'],
+        }),
+    ],
+    unnamedArgumentList: [
+        SlashCommandArgument.fromProps({ description: 'The reason for aborting command execution. Shown when quiet=false',
+            typeList: [ARGUMENT_TYPE.STRING],
+        }),
+    ],
     helpString: 'Aborts the slash command batch execution.',
 }));
 SlashCommandParser.addCommandObject(SlashCommand.fromProps({ name: 'fuzzy',
@@ -1421,9 +1434,15 @@ async function runCallback(args, name) {
     }
 }
 
-function abortCallback() {
-    $('#send_textarea').val('')[0].dispatchEvent(new Event('input', { bubbles:true }));
-    throw new Error('/abort command executed', { cause: 'abort' });
+/**
+ *
+ * @param {object} param0
+ * @param {SlashCommandAbortController} param0._abortController
+ * @param {string} [param0.quiet]
+ * @param {string} [reason]
+ */
+function abortCallback({ _abortController, quiet }, reason) {
+    _abortController.abort((reason ?? '').toString().length == 0 ? '/abort command executed' : reason, !isFalseBoolean(quiet ?? 'true'));
 }
 
 async function delayCallback(_, amount) {
@@ -2786,7 +2805,7 @@ async function executeSlashCommandsWithOptions(text, options = {}) {
 
     let closure;
     try {
-        closure = parser.parse(text, true, options.parserFlags, options.abortController);
+        closure = parser.parse(text, true, options.parserFlags, options.abortController ?? new SlashCommandAbortController());
         closure.scope.parent = options.scope;
         closure.onProgress = options.onProgress;
     } catch (e) {
@@ -2813,7 +2832,7 @@ async function executeSlashCommandsWithOptions(text, options = {}) {
 
     try {
         const result = await closure.execute();
-        if (result.isAborted) {
+        if (result.isAborted && !result.isQuietlyAborted) {
             toastr.warning(result.abortReason, 'Command execution aborted');
         }
         return result;

public/scripts/slash-commands/SlashCommand.js

@@ -1,5 +1,25 @@
+import { SlashCommandAbortController } from './SlashCommandAbortController.js';
 import { SlashCommandArgument, SlashCommandNamedArgument } from './SlashCommandArgument.js';
 import { SlashCommandClosure } from './SlashCommandClosure.js';
+import { PARSER_FLAG } from './SlashCommandParser.js';
+import { SlashCommandScope } from './SlashCommandScope.js';
+
+
+
+
+/**
+ * @typedef {{
+ * _pipe:string|SlashCommandClosure,
+ * _scope:SlashCommandScope,
+ * _parserFlags:{[id:PARSER_FLAG]:boolean},
+ * _abortController:SlashCommandAbortController,
+ * [id:string]:string,
+ * }} NamedArguments
+ */
+
+/**
+ * @typedef {string|SlashCommandClosure|(string|SlashCommandClosure)[]} UnnamedArguments
+*/
 
 
 
@@ -8,7 +28,7 @@ export class SlashCommand {
      * Creates a SlashCommand from a properties object.
      * @param {Object} props
      * @param {string} [props.name]
-     * @param {(namedArguments:Object.<string,string|SlashCommandClosure>, unnamedArguments:string|SlashCommandClosure|(string|SlashCommandClosure)[])=>string|SlashCommandClosure|void|Promise<string|SlashCommandClosure|void>} [props.callback]
+     * @param {(namedArguments:NamedArguments, unnamedArguments:string|SlashCommandClosure|(string|SlashCommandClosure)[])=>string|SlashCommandClosure|void|Promise<string|SlashCommandClosure|void>} [props.callback]
      * @param {string} [props.helpString]
      * @param {boolean} [props.splitUnnamedArgument]
      * @param {string[]} [props.aliases]
@@ -25,7 +45,7 @@ export class SlashCommand {
 
 
     /**@type {string}*/ name;
-    /**@type {(namedArguments:Object<string, string|SlashCommandClosure>, unnamedArguments:string|SlashCommandClosure|(string|SlashCommandClosure)[])=>string|SlashCommandClosure|Promise<string|SlashCommandClosure>}*/ callback;
+    /**@type {(namedArguments:{_pipe:string|SlashCommandClosure, _scope:SlashCommandScope, _abortController:SlashCommandAbortController, [id:string]:string|SlashCommandClosure}, unnamedArguments:string|SlashCommandClosure|(string|SlashCommandClosure)[])=>string|SlashCommandClosure|Promise<string|SlashCommandClosure>}*/ callback;
     /**@type {string}*/ helpString;
     /**@type {boolean}*/ splitUnnamedArgument = false;
     /**@type {string[]}*/ aliases = [];

public/scripts/slash-commands/SlashCommandAbortController.js

@@ -5,7 +5,8 @@ export class SlashCommandAbortController {
     constructor() {
         this.signal = new SlashCommandAbortSignal();
     }
-    abort(reason = 'No reason.') {
+    abort(reason = 'No reason.', isQuiet = false) {
+        this.signal.isQuiet = isQuiet;
         this.signal.aborted = true;
         this.signal.reason = reason;
     }
@@ -20,8 +21,8 @@ export class SlashCommandAbortController {
 }
 
 export class SlashCommandAbortSignal {
+    /**@type {boolean}*/ isQuiet = false;
     /**@type {boolean}*/ paused = false;
     /**@type {boolean}*/ aborted = false;
     /**@type {string}*/ reason = null;
-
 }

public/scripts/slash-commands/SlashCommandClosure.js

@@ -161,6 +161,7 @@ export class SlashCommandClosure {
                 let args = {
                     _scope: this.scope,
                     _parserFlags: executor.parserFlags,
+                    _abortController: this.abortController,
                 };
                 let value;
                 // substitute named arguments
@@ -254,6 +255,7 @@ export class SlashCommandClosure {
         if (this.abortController?.signal?.aborted) {
             const result = new SlashCommandClosureResult();
             result.isAborted = true;
+            result.isQuietlyAborted = this.abortController.signal.isQuiet;
             result.abortReason = this.abortController.signal.reason.toString();
             return result;
         }

public/scripts/slash-commands/SlashCommandClosureResult.js

@@ -2,6 +2,7 @@ export class SlashCommandClosureResult {
     /**@type {boolean}*/ interrupt = false;
     /**@type {string}*/ pipe;
     /**@type {boolean}*/ isAborted = false;
+    /**@type {boolean}*/ isQuietlyAborted = false;
     /**@type {string}*/ abortReason;
     /**@type {boolean}*/ isError = false;
     /**@type {string}*/ errorMessage;

public/scripts/slash-commands/SlashCommandExecutor.js

@@ -20,7 +20,7 @@ export class SlashCommandExecutor {
     // @ts-ignore
     /**@type {SlashCommandNamedArgumentAssignment[]}*/ namedArgumentList = [];
     /**@type {SlashCommandUnnamedArgumentAssignment[]}*/ unnamedArgumentList = [];
-    /**@type {Object<PARSER_FLAG,boolean>} */ parserFlags;
+    /**@type {{[id:PARSER_FLAG]:boolean}} */ parserFlags;
 
     get commandCount() {
         return 1

public/scripts/slash-commands/SlashCommandParser.js

@@ -829,6 +829,7 @@ export class SlashCommandParser {
                     assignment.start = this.index;
                     value = '';
                 }
+                assignment.start = this.index;
                 assignment.value = this.parseClosure();
                 assignment.end = this.index;
                 listValues.push(assignment);

public/scripts/tags.js

@@ -14,10 +14,12 @@ import {
 // eslint-disable-next-line no-unused-vars
 import { FILTER_TYPES, FILTER_STATES, DEFAULT_FILTER_STATE, isFilterState, FilterHelper } from './filters.js';
 
-import { groupCandidatesFilter, groups, selected_group } from './group-chats.js';
+import { groupCandidatesFilter, groups, select_group_chats, selected_group } from './group-chats.js';
 import { download, onlyUnique, parseJsonFile, uuidv4, getSortableDelay, flashHighlight } from './utils.js';
 import { power_user } from './power-user.js';
-import { debounce_timeout } from './constants.js';
+import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
+import { SlashCommand } from './slash-commands/SlashCommand.js';
+import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './slash-commands/SlashCommandArgument.js';
 
 export {
     TAG_FOLDER_TYPES,
@@ -357,7 +359,7 @@ function createTagMapFromList(listElement, key) {
  * If you have an entity, you can get it's key easily via `getTagKeyForEntity(entity)`.
  *
  * @param {string} key - The key for which to get tags via the tag map
- * @param {boolean} [sort=true] -
+ * @param {boolean} [sort=true] - Whether the tag list should be sorted
  * @returns {Tag[]} A list of tags
  */
 function getTagsList(key, sort = true) {
@@ -463,35 +465,122 @@ export function getTagKeyForEntityElement(element) {
     return undefined;
 }
 
+/**
+ * Adds a tag to a given entity
+ * @param {Tag} tag - The tag to add
+ * @param {string|string[]} entityId - The entity to add this tag to. Has to be the entity key (e.g. `addTagToEntity`). (Also allows multiple entities to be passed in)
+ * @param {object} [options={}] - Optional arguments
+ * @param {JQuery<HTMLElement>|string?} [options.tagListSelector=null] - An optional selector if a specific list should be updated with the new tag too (for example because the add was triggered for that function)
+ * @param {PrintTagListOptions} [options.tagListOptions] - Optional parameters for printing the tag list. Can be set to be consistent with the expected behavior of tags in the list that was defined before.
+ * @returns {boolean} Whether at least one tag was added
+ */
+export function addTagToEntity(tag, entityId, { tagListSelector = null, tagListOptions = {} } = {}) {
+    let result = false;
+    // Add tags to the map
+    if (Array.isArray(entityId)) {
+        entityId.forEach((id) => result = addTagToMap(tag.id, id) || result);
+    } else {
+        result = addTagToMap(tag.id, entityId);
+    }
+
+    // Save and redraw
+    printCharactersDebounced();
+    saveSettingsDebounced();
+
+    // We should manually add the selected tag to the print tag function, so we cover places where the tag list did not automatically include it
+    tagListOptions.addTag = tag;
+
+    // add tag to the UI and internal map - we reprint so sorting and new markup is done correctly
+    if (tagListSelector) printTagList(tagListSelector, tagListOptions);
+    const inlineSelector = getInlineListSelector();
+    if (inlineSelector) {
+        printTagList($(inlineSelector), tagListOptions);
+    }
+
+    return result;
+}
+
+/**
+ * Removes a tag from a given entity
+ * @param {Tag} tag - The tag to remove
+ * @param {string|string[]} entityId - The entity to remove this tag from. Has to be the entity key (e.g. `addTagToEntity`). (Also allows multiple entities to be passed in)
+ * @param {object} [options={}] - Optional arguments
+ * @param {JQuery<HTMLElement>|string?} [options.tagListSelector=null] - An optional selector if a specific list should be updated with the tag removed too (for example because the add was triggered for that function)
+ * @param {JQuery<HTMLElement>?} [options.tagElement=null] - Optionally a direct html element of the tag to be removed, so it can be removed from the UI
+ * @returns {boolean} Whether at least one tag was removed
+ */
+export function removeTagFromEntity(tag, entityId, { tagListSelector = null, tagElement = null } = {}) {
+    let result = false;
+    // Remove tag from the map
+    if (Array.isArray(entityId)) {
+        entityId.forEach((id) => result = removeTagFromMap(tag.id, id) || result);
+    } else {
+        result = removeTagFromMap(tag.id, entityId);
+    }
+
+    // Save and redraw
+    printCharactersDebounced();
+    saveSettingsDebounced();
+
+    // We don't reprint the lists, we can just remove the html elements from them.
+    if (tagListSelector) {
+        const $selector = (typeof tagListSelector === 'string') ? $(tagListSelector) : tagListSelector;
+        $selector.find(`.tag[id="${tag.id}"]`).remove();
+    }
+    if (tagElement) tagElement.remove();
+    $(`${getInlineListSelector()} .tag[id="${tag.id}"]`).remove();
+
+    return result;
+}
+
+/**
+ * Adds a tag from a given character. If no character is provided, adds it from the currently active one.
+ * @param {string} tagId - The id of the tag
+ * @param {string} characterId - The id/key of the character or group
+ * @returns {boolean} Whether the tag was added or not
+ */
 function addTagToMap(tagId, characterId = null) {
     const key = characterId !== null && characterId !== undefined ? getTagKeyForEntity(characterId) : getTagKey();
 
     if (!key) {
-        return;
+        return false;
     }
 
     if (!Array.isArray(tag_map[key])) {
         tag_map[key] = [tagId];
+        return true;
     }
     else {
+        if (tag_map[key].includes(tagId))
+            return false;
+
         tag_map[key].push(tagId);
         tag_map[key] = tag_map[key].filter(onlyUnique);
+        return true;
     }
 }
 
+/**
+ * Removes a tag from a given character. If no character is provided, removes it from the currently active one.
+ * @param {string} tagId - The id of the tag
+ * @param {string} characterId - The id/key of the character or group
+ * @returns {boolean} Whether the tag was removed or not
+ */
 function removeTagFromMap(tagId, characterId = null) {
     const key = characterId !== null && characterId !== undefined ? getTagKeyForEntity(characterId) : getTagKey();
 
     if (!key) {
-        return;
+        return false;
     }
 
     if (!Array.isArray(tag_map[key])) {
         tag_map[key] = [];
+        return false;
     }
     else {
         const indexOf = tag_map[key].indexOf(tagId);
         tag_map[key].splice(indexOf, 1);
+        return indexOf !== -1;
     }
 }
 
@@ -535,24 +624,7 @@ function selectTag(event, ui, listSelector, { tagListOptions = {} } = {}) {
     const characterData = event.target.closest('#bulk_tags_div')?.dataset.characters;
     const characterIds = characterData ? JSON.parse(characterData).characterIds : null;
 
-    if (characterIds) {
-        characterIds.forEach((characterId) => addTagToMap(tag.id, characterId));
-    } else {
-        addTagToMap(tag.id);
-    }
-
-    printCharactersDebounced();
-    saveSettingsDebounced();
-
-    // We should manually add the selected tag to the print tag function, so we cover places where the tag list did not automatically include it
-    tagListOptions.addTag = tag;
-
-    // add tag to the UI and internal map - we reprint so sorting and new markup is done correctly
-    printTagList(listSelector, tagListOptions);
-    const inlineSelector = getInlineListSelector();
-    if (inlineSelector) {
-        printTagList($(inlineSelector), tagListOptions);
-    }
+    addTagToEntity(tag, characterIds, { tagListSelector: listSelector, tagListOptions: tagListOptions });
 
     // need to return false to keep the input clear
     return false;
@@ -635,6 +707,7 @@ function createNewTag(tagName) {
         create_date: Date.now(),
     };
     tags.push(tag);
+    console.debug('Created new tag', tag.name, 'with id', tag.id);
     return tag;
 }
 
@@ -932,8 +1005,8 @@ function updateTagFilterIndicator() {
 
 function onTagRemoveClick(event) {
     event.stopPropagation();
-    const tag = $(this).closest('.tag');
-    const tagId = tag.attr('id');
+    const tagElement = $(this).closest('.tag');
+    const tagId = tagElement.attr('id');
 
     // Check if we are inside the drilldown. If so, we call remove on the bogus folder
     if ($(this).closest('.rm_tag_bogus_drilldown').length > 0) {
@@ -942,24 +1015,13 @@ function onTagRemoveClick(event) {
         return;
     }
 
+    const tag = tags.find(t => t.id === tagId);
+
     // Optional, check for multiple character ids being present.
     const characterData = event.target.closest('#bulk_tags_div')?.dataset.characters;
     const characterIds = characterData ? JSON.parse(characterData).characterIds : null;
 
-    tag.remove();
-
-    if (characterIds) {
-        characterIds.forEach((characterId) => removeTagFromMap(tagId, characterId));
-    } else {
-        removeTagFromMap(tagId);
-    }
-
-    $(`${getInlineListSelector()} .tag[id="${tagId}"]`).remove();
-
-    printCharactersDebounced();
-    saveSettingsDebounced();
-
-
+    removeTagFromEntity(tag, characterIds, { tagElement: tagElement });
 }
 
 // @ts-ignore
@@ -985,7 +1047,7 @@ function onGroupCreateClick() {
 
 export function applyTagsOnCharacterSelect() {
     //clearTagsFilter();
-    const chid = Number($(this).attr('chid'));
+    const chid = Number(this_chid);
     printTagList($('#tagList'), { forEntityOrKey: chid, tagOptions: { removable: true } });
 }
 
@@ -1461,14 +1523,200 @@ function printViewTagList(empty = true) {
     }
 }
 
+function registerTagsSlashCommands() {
+    /**
+     * Gets the key for char/group for a slash command. If none can be found, a toastr will be shown and null returned.
+     * @param {string?} [charName] The optionally provided char name
+     * @returns {string?} - The char/group key, or null if none found
+     */
+    function paraGetCharKey(charName) {
+        const entity = charName
+            ? (characters.find(x => x.name === charName) || groups.find(x => x.name == charName))
+            : (selected_group ? groups.find(x => x.id == selected_group) : characters[this_chid]);
+        const key = getTagKeyForEntity(entity);
+        if (!key) {
+            toastr.warning(`Character ${charName} not found.`);
+            return null;
+        }
+        return key;
+    }
+    /**
+     * Gets a tag by its name. Optionally can create the tag if it does not exist.
+     * @param {string} tagName - The name of the tag
+     * @param {object} options - Optional arguments
+     * @param {boolean} [options.allowCreate=false] - Whether a new tag should be created if no tag with the name exists
+     * @returns {Tag?} The tag, or null if not found
+     */
+    function paraGetTag(tagName, { allowCreate = false } = {}) {
+        if (!tagName) {
+            toastr.warning('Tag name must be provided.');
+            return null;
+        }
+        let tag = tags.find(t => t.name === tagName);
+        if (allowCreate && !tag) {
+            tag = createNewTag(tagName);
+        }
+        if (!tag) {
+            toastr.warning(`Tag ${tagName} not found.`);
+            return null;
+        }
+        return tag;
+    }
+
+    function updateTagsList() {
+        switch (menu_type) {
+            case 'characters':
+                printTagFilters(tag_filter_types.character);
+                printTagFilters(tag_filter_types.group_member);
+                break;
+            case 'character_edit':
+                applyTagsOnCharacterSelect();
+                break;
+            case 'group_edit':
+                select_group_chats(selected_group, true);
+                break;
+        }
+    }
+
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'tag-add',
+        returns: 'true/false - Whether the tag was added or was assigned already',
+        /** @param {{name: string}} namedArgs @param {string} tagName @returns {string} */
+        callback: ({ name }, tagName) => {
+            const key = paraGetCharKey(name);
+            if (!key) return 'false';
+            const tag = paraGetTag(tagName, { allowCreate: true });
+            if (!tag) return 'false';
+            const result = addTagToEntity(tag, key);
+            updateTagsList();
+            return String(result);
+        },
+        namedArgumentList: [
+            new SlashCommandNamedArgument('name', 'Character name', [ARGUMENT_TYPE.STRING], false, false, '{{char}}'),
+        ],
+        unnamedArgumentList: [
+            new SlashCommandArgument('tag name', [ARGUMENT_TYPE.STRING], true),
+        ],
+        helpString: `
+        <div>
+            Adds a tag to the character. If no character is provided, it adds it to the current character (<code>{{char}}</code>).
+            If the tag doesn't exist, it is created.
+        </div>
+        <div>
+            <strong>Example:</strong>
+            <ul>
+                <li>
+                    <pre><code>/tag-add name="Chloe" scenario</code></pre>
+                    will add the tag "scenario" to the character named Chloe.
+                </li>
+            </ul>
+        </div>
+    `,
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'tag-remove',
+        returns: 'true/false - Whether the tag was removed or wasn\'t assigned already',
+        /** @param {{name: string}} namedArgs @param {string} tagName @returns {string} */
+        callback: ({ name }, tagName) => {
+            const key = paraGetCharKey(name);
+            if (!key) return 'false';
+            const tag = paraGetTag(tagName);
+            if (!tag) return 'false';
+            const result = removeTagFromEntity(tag, key);
+            updateTagsList();
+            return String(result);
+        },
+        namedArgumentList: [
+            new SlashCommandNamedArgument('name', 'Character name', [ARGUMENT_TYPE.STRING], false, false, '{{char}}'),
+        ],
+        unnamedArgumentList: [
+            new SlashCommandArgument('tag name', [ARGUMENT_TYPE.STRING], true),
+        ],
+        helpString: `
+        <div>
+            Removes a tag from the character. If no character is provided, it removes it from the current character (<code>{{char}}</code>).
+        </div>
+        <div>
+            <strong>Example:</strong>
+            <ul>
+                <li>
+                    <pre><code>/tag-remove name="Chloe" scenario</code></pre>
+                    will remove the tag "scenario" from the character named Chloe.
+                </li>
+            </ul>
+        </div>
+    `,
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'tag-exists',
+        returns: 'true/false - Whether the given tag name is assigned to the character',
+        /** @param {{name: string}} namedArgs @param {string} tagName @returns {string} */
+        callback: ({ name }, tagName) => {
+            const key = paraGetCharKey(name);
+            if (!key) return 'false';
+            const tag = paraGetTag(tagName);
+            if (!tag) return 'false';
+            return String(tag_map[key].includes(tag.id));
+        },
+        namedArgumentList: [
+            new SlashCommandNamedArgument('name', 'Character name', [ARGUMENT_TYPE.STRING], false, false, '{{char}}'),
+        ],
+        unnamedArgumentList: [
+            new SlashCommandArgument('tag name', [ARGUMENT_TYPE.STRING], true),
+        ],
+        helpString: `
+        <div>
+            Checks whether the given tag is assigned to the character. If no character is provided, it checks the current character (<code>{{char}}</code>).
+        </div>
+        <div>
+            <strong>Example:</strong>
+            <ul>
+                <li>
+                    <pre><code>/tag-exists name="Chloe" scenario</code></pre>
+                    will return true if the character named Chloe has the tag "scenario".
+                </li>
+            </ul>
+        </div>
+    `,
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'tag-list',
+        returns: 'Comma-separated list of all assigned tags',
+        /** @param {{name: string}} namedArgs @returns {string} */
+        callback: ({ name }) => {
+            const key = paraGetCharKey(name);
+            if (!key) return '';
+            const tags = getTagsList(key);
+            return tags.map(x => x.name).join(', ');
+        },
+        namedArgumentList: [
+            new SlashCommandNamedArgument('name', 'Character name', [ARGUMENT_TYPE.STRING], false, false, '{{char}}'),
+        ],
+        helpString: `
+        <div>
+            Lists all assigned tags of the character. If no character is provided, it uses the current character (<code>{{char}}</code>).
+            <br />
+            Note that there is no special handling for tags containing commas, they will be printed as-is.
+        </div>
+        <div>
+            <strong>Example:</strong>
+            <ul>
+                <li>
+                    <pre><code>/tag-list name="Chloe"</code></pre>
+                    could return something like <code>OC, scenario, edited, funny</code>
+                </li>
+            </ul>
+        </div>
+    `,
+    }));
+}
+
 export function initTags() {
     createTagInput('#tagInput', '#tagList', { tagOptions: { removable: true } });
     createTagInput('#groupTagInput', '#groupTagList', { tagOptions: { removable: true } });
 
     $(document).on('click', '#rm_button_create', onCharacterCreateClick);
     $(document).on('click', '#rm_button_group_chats', onGroupCreateClick);
-    $(document).on('click', '.character_select', applyTagsOnCharacterSelect);
-    $(document).on('click', '.group_select', applyTagsOnGroupSelect);
     $(document).on('click', '.tag_remove', onTagRemoveClick);
     $(document).on('input', '.tag_input', onTagInput);
     $(document).on('click', '.tags_view', onViewTagsListClick);
@@ -1479,6 +1727,7 @@ export function initTags() {
     $(document).on('click', '.tag_view_backup', onTagsBackupClick);
     $(document).on('click', '.tag_view_restore', onBackupRestoreClick);
     eventSource.on(event_types.CHARACTER_DUPLICATED, copyTags);
+    eventSource.makeFirst(event_types.CHAT_CHANGED, () => selected_group ? applyTagsOnGroupSelect() : applyTagsOnCharacterSelect());
 
     $(document).on('input', '#dialogue_popup input[name="auto_sort_tags"]', (evt) => {
         const toggle = $(evt.target).is(':checked');
@@ -1506,4 +1755,6 @@ export function initTags() {
             printCharactersDebounced();
         }
     }
+
+    registerTagsSlashCommands();
 }

public/scripts/textgen-settings.js

@@ -991,7 +991,7 @@ export function getTextGenModel() {
 }
 
 export function isJsonSchemaSupported() {
-    return settings.type === TABBY && main_api === 'textgenerationwebui';
+    return [TABBY, LLAMACPP].includes(settings.type) && main_api === 'textgenerationwebui';
 }
 
 export function getTextGenGenerationData(finalPrompt, maxTokens, isImpersonate, isContinue, cfgValues, type) {
@@ -1065,7 +1065,7 @@ export function getTextGenGenerationData(finalPrompt, maxTokens, isImpersonate,
         'guidance_scale': cfgValues?.guidanceScale?.value ?? settings.guidance_scale ?? 1,
         'negative_prompt': cfgValues?.negativePrompt ?? substituteParams(settings.negative_prompt) ?? '',
         'grammar_string': settings.grammar_string,
-        'json_schema': settings.type === TABBY ? settings.json_schema : undefined,
+        'json_schema': [TABBY, LLAMACPP].includes(settings.type) ? settings.json_schema : undefined,
         // llama.cpp aliases. In case someone wants to use LM Studio as Text Completion API
         'repeat_penalty': settings.rep_pen,
         'tfs_z': settings.tfs,
@@ -1150,5 +1150,15 @@ export function getTextGenGenerationData(finalPrompt, maxTokens, isImpersonate,
 
     eventSource.emitAndWait(event_types.TEXT_COMPLETION_SETTINGS_READY, params);
 
+    // Grammar conflicts with with json_schema
+    if (settings.type === LLAMACPP) {
+        if (params.json_schema && Object.keys(params.json_schema).length > 0) {
+            delete params.grammar_string;
+            delete params.grammar;
+        } else {
+            delete params.json_schema;
+        }
+    }
+
     return params;
 }

public/scripts/variables.js

@@ -1,11 +1,13 @@
 import { chat_metadata, getCurrentChatId, saveSettingsDebounced, sendSystemMessage, system_message_types } from '../script.js';
 import { extension_settings, saveMetadataDebounced } from './extensions.js';
-import { executeSlashCommands } from './slash-commands.js';
+import { executeSlashCommands, executeSlashCommandsWithOptions } from './slash-commands.js';
 import { SlashCommand } from './slash-commands/SlashCommand.js';
+import { SlashCommandAbortController } from './slash-commands/SlashCommandAbortController.js';
 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './slash-commands/SlashCommandArgument.js';
 import { SlashCommandClosure } from './slash-commands/SlashCommandClosure.js';
+import { SlashCommandClosureResult } from './slash-commands/SlashCommandClosureResult.js';
 import { SlashCommandEnumValue } from './slash-commands/SlashCommandEnumValue.js';
-import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
+import { PARSER_FLAG, SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { SlashCommandScope } from './slash-commands/SlashCommandScope.js';
 import { isFalseBoolean } from './utils.js';
 
@@ -317,58 +319,101 @@ function listVariablesCallback() {
 async function whileCallback(args, command) {
     const isGuardOff = isFalseBoolean(args.guard);
     const iterations = isGuardOff ? Number.MAX_SAFE_INTEGER : MAX_LOOPS;
+    if (command) {
+        if (command[0] instanceof SlashCommandClosure) {
+            command = command[0];
+        } else {
+            command = command.join(' ');
+        }
+    }
 
+    let commandResult;
     for (let i = 0; i < iterations; i++) {
         const { a, b, rule } = parseBooleanOperands(args);
         const result = evalBoolean(rule, a, b);
 
         if (result && command) {
-            if (command instanceof SlashCommandClosure) await command.execute();
-            else await executeSubCommands(command, args._scope, args._parserFlags);
+            if (command instanceof SlashCommandClosure) {
+                commandResult = await command.execute();
+            } else {
+                commandResult = await executeSubCommands(command, args._scope, args._parserFlags, args._abortController);
+                if (commandResult.isAborted) {
+                    args._abortController.abort(commandResult.abortReason, true);
+                }
+            }
+            break;
         } else {
             break;
         }
     }
 
+    if (commandResult) {
+        return commandResult.pipe;
+    }
+
     return '';
 }
 
+/**
+ *
+ * @param {import('./slash-commands/SlashCommand.js').NamedArguments} args
+ * @param {import('./slash-commands/SlashCommand.js').UnnamedArguments} value
+ * @returns
+ */
 async function timesCallback(args, value) {
     let repeats;
     let command;
     if (Array.isArray(value)) {
-        [repeats, command] = value;
+        [repeats, ...command] = value;
+        if (command[0] instanceof SlashCommandClosure) {
+            command = command[0];
+        } else {
+            command = command.join(' ');
+        }
     } else {
-        [repeats, ...command] = value.split(' ');
+        [repeats, ...command] = /**@type {string}*/(value).split(' ');
         command = command.join(' ');
     }
     const isGuardOff = isFalseBoolean(args.guard);
     const iterations = Math.min(Number(repeats), isGuardOff ? Number.MAX_SAFE_INTEGER : MAX_LOOPS);
+    let result;
     for (let i = 0; i < iterations; i++) {
+        /**@type {SlashCommandClosureResult}*/
         if (command instanceof SlashCommandClosure) {
             command.scope.setMacro('timesIndex', i);
-            await command.execute();
+            result = await command.execute();
         }
         else {
-            await executeSubCommands(command.replace(/\{\{timesIndex\}\}/g, i), args._scope, args._parserFlags);
+            result = await executeSubCommands(command.replace(/\{\{timesIndex\}\}/g, i.toString()), args._scope, args._parserFlags);
+            if (result.isAborted) {
+                args._abortController.abort(result.abortReason, true);
+                break;
+            }
         }
     }
 
-    return '';
+    return result?.pipe ?? '';
 }
 
 async function ifCallback(args, command) {
     const { a, b, rule } = parseBooleanOperands(args);
     const result = evalBoolean(rule, a, b);
 
+    let commandResult;
     if (result && command) {
         if (command instanceof SlashCommandClosure) return (await command.execute()).pipe;
-        return await executeSubCommands(command, args._scope, args._parserFlags);
+        commandResult = await executeSubCommands(command, args._scope, args._parserFlags);
     } else if (!result && args.else && ((typeof args.else === 'string' && args.else !== '') || args.else instanceof SlashCommandClosure)) {
         if (args.else instanceof SlashCommandClosure) return (await args.else.execute(args._scope)).pipe;
-        return await executeSubCommands(args.else, args._scope, args._parserFlags);
+        commandResult = await executeSubCommands(args.else, args._scope, args._parserFlags);
     }
 
+    if (commandResult) {
+        if (commandResult.isAborted) {
+            args._abortController.abort(commandResult.abortReason, true);
+        }
+        return commandResult.pipe;
+    }
     return '';
 }
 
@@ -511,20 +556,25 @@ function evalBoolean(rule, a, b) {
 /**
  * Executes a slash command from a string (may be enclosed in quotes) and returns the result.
  * @param {string} command Command to execute. May contain escaped macro and batch separators.
- * @returns {Promise<string>} Pipe result
+ * @param {SlashCommandScope} [scope] The scope to use.
+ * @param {PARSER_FLAG[]} [parserFlags] The parser flags to use.
+ * @returns {Promise<SlashCommandClosureResult>} Closure execution result
  */
 async function executeSubCommands(command, scope = null, parserFlags = null) {
     if (command.startsWith('"') && command.endsWith('"')) {
         command = command.slice(1, -1);
     }
 
-    const result = await executeSlashCommands(command, true, scope, false, parserFlags);
+    const abortController = new SlashCommandAbortController();
+    const result = await executeSlashCommandsWithOptions(command, {
+        handleExecutionErrors: false,
+        handleParserErrors: false,
+        parserFlags,
+        scope,
+        abortController,
+    });
 
-    if (!result || typeof result !== 'object') {
-        return '';
-    }
-
-    return result?.pipe || '';
+    return result;
 }
 
 /**
@@ -1132,6 +1182,7 @@ export function registerVariableCommands() {
                 'command to execute while true', [ARGUMENT_TYPE.CLOSURE, ARGUMENT_TYPE.SUBCOMMAND], true,
             ),
         ],
+        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Compares the value of the left operand <code>a</code> with the value of the right operand <code>b</code>,
@@ -1184,6 +1235,7 @@ export function registerVariableCommands() {
                 true,
             ),
         ],
+        splitUnnamedArgument: true,
         helpString: `
             <div>
                 Execute any valid slash command enclosed in quotes <code>repeats</code> number of times.

public/style.css

@@ -2068,6 +2068,7 @@ input[type="file"] {
     gap: 5px;
     justify-content: center;
     align-items: center;
+    flex-wrap: wrap;
 }
 
 .bulk_select_checkbox {
@@ -4892,4 +4893,4 @@ body:not(.movingUI) .drawer-content.maximized {
 .regex-operator { color: #FFB6C1; } /* Light Pink */
 .regex-flags { color: #98FB98; } /* Pale Green */
 .regex-delimiter { font-weight: bold; color: #FF6961; } /* Pastel Red */
-.regex-highlight { color: #FAF8F6; } /* Pastel White */
+.regex-highlight { color: #FAF8F6; } /* Pastel White */