Merge pull request #3725 from SillyTavern/feat/expressions-filter-available Adds filtering to expressions to ignore labels that do not have sprites available

6bfa54e9b4535579abc22ce58a82b44eca788b00

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

Signed

Parents: d5d3516e1875a6234c579b7b92039688204d9f3a f5ecd1fa5f872cfe50fbf8ab9199fc925624f6de

public/scripts/extensions/expressions/index.js+53 -15 Viewed

 import { dragElement, isMobile } from '../../RossAscends-mods.js';
 import { getContext, getApiUrl, modules, extension_settings, ModuleWorkerWrapper, doExtrasFetch, renderExtensionTemplateAsync } from '../../extensions.js';
 import { loadMovingUIState, performFuzzySearch, power_user } from '../../power-user.js';
 import { onlyUnique, debounce, getCharaFilename, trimToEndSentence, trimToStartSentence, waitUntilCondition, findChar, isFalseBoolean } from '../../utils.js';
 import { hideMutedSprites, selected_group } from '../../group-chats.js';
 import { isJsonSchemaSupported } from '../../textgen-settings.js';
 import { debounce_timeout } from '../../constants.js';

     return '';
+}
 async function classifyCallback(/** @type {{api: string?, filter: string?, prompt: string?}} */ { api = null, filter = null, prompt = null }, text) {
     if (!text) {
         toastr.error('No text provided');
         return '';

@@ -690,13 +690,14 @@ async function classifyCallback(/** @type {{api: string?, prompt: string?}} */ {
690	690	}
691	691
692	692	const expressionApi = EXPRESSION_API[api] \|\| extension_settings.expressions.api;
	693	+ const filterAvailable = !isFalseBoolean(filter);
693	694
694	695	if (!modules.includes('classify') && expressionApi == EXPRESSION_API.extras) {
695	696	toastr.warning('Text classification is disabled or not available');
696	697	return '';
697	698	}
698	699
699	700	const label = await getExpressionLabel(text, expressionApi, { filterAvailable: filterAvailable, customPrompt: prompt });
700	701	console.debug(`Classification result for "${text}": ${label}`);
701	702	return label;
702	703	}

  * @param {string} text - The text to classify and retrieve the expression label for.
  * @param {EXPRESSION_API} [expressionsApi=extension_settings.expressions.api] - The expressions API to use for classification.
  * @param {object} [options={}] - Optional arguments.
 + * @param {boolean?} [options.filterAvailable=null] - Whether to filter available expressions. If not specified, uses the extension setting.
  * @param {string?} [options.customPrompt=null] - The custom prompt to use for classification.
  * @returns {Promise<string?>} - The label of the expression.
  */
 export async function getExpressionLabel(text, expressionsApi = extension_settings.expressions.api, { filterAvailable = null, customPrompt = null } = {}) {
     // Return if text is undefined, saving a costly fetch request
     if ((!modules.includes('classify') && expressionsApi == EXPRESSION_API.extras) || !text) {
         return extension_settings.expressions.fallback_expression;

     text = sampleClassifyText(text);
 +    filterAvailable ??= extension_settings.expressions.filterAvailable;
 +    if (filterAvailable && ![EXPRESSION_API.llm, EXPRESSION_API.webllm].includes(expressionsApi)) {
 +        console.debug('Filter available is only supported for LLM and WebLLM expressions');
 +    }
++
     try {
         switch (expressionsApi) {
             // Local BERT pipeline

                     return extension_settings.expressions.fallback_expression;
+                }
                 const expressionsList = await getExpressionsList({ filterAvailable: filterAvailable });
                 const prompt = substituteParamsExtended(customPrompt, { labels: expressionsList }) || await getLlmPrompt(expressionsList);
                 eventSource.once(event_types.TEXT_COMPLETION_SETTINGS_READY, onTextGenSettingsReady);
                 const emotionResponse = await generateRaw(text, main_api, false, false, prompt);

                     return extension_settings.expressions.fallback_expression;
+                }
                 const expressionsList = await getExpressionsList({ filterAvailable: filterAvailable });
                 const prompt = substituteParamsExtended(customPrompt, { labels: expressionsList }) || await getLlmPrompt(expressionsList);
                 const messages = [
                     { role: 'user', content: text + '\n\n' + prompt },

     return [...expressionsList, ...extension_settings.expressions.custom].filter(onlyUnique);
+}
 export async function getExpressionsList({ filterAvailable = false } = {}) {
     // ReturnIf there is no cached list, ifload availableand cache it
     if (!Array.isArray(expressionsList)) {
         returnexpressionsList getCachedExpressions= await resolveExpressionsList();
 +    }
++
 +    const expressions = getCachedExpressions();
++
 +    // Filtering is only available for llm and webllm APIs
 +    if (!filterAvailable || ![EXPRESSION_API.llm, EXPRESSION_API.webllm].includes(extension_settings.expressions.api)) {
 +        return expressions;
+    }
 +    // Get expressions with available sprites
 +    const currentLastMessage = selected_group ? getLastCharacterMessage() : null;
 +    const spriteFolderName = getSpriteFolderName(currentLastMessage, currentLastMessage?.name);
++
 +    return expressions.filter(label => {
 +        const expression = spriteCache[spriteFolderName]?.find(x => x.label === label);
 +        return (expression?.files.length ?? 0) > 0;
 +    });
++
     /**
      * Returns the list of expressions from the API or fallback in offline mode.
      * @returns {Promise<string[]>}

@@ -1376,9 +1399,6 @@ export async function getExpressionsList() {
1376	1399	expressionsList = DEFAULT_EXPRESSIONS.slice();
1377	1400	return expressionsList;
1378	1401	}
1379		-
1380		- const result = await resolveExpressionsList();
1381		- return [...result, ...extension_settings.expressions.custom].filter(onlyUnique);
1382	1402	}
1383	1403
1384	1404	/**

             extension_settings.expressions.rerollIfSame = !!$(this).prop('checked');
             saveSettingsDebounced();
         });
 +        $('#expressions_filter_available').prop('checked', extension_settings.expressions.filterAvailable).on('input', function () {
 +            extension_settings.expressions.filterAvailable = !!$(this).prop('checked');
 +            saveSettingsDebounced();
 +        });
         $('#expression_override_cleanup_button').on('click', onClickExpressionOverrideRemoveAllButton);
         $(document).on('dragstart', '.expression', (e) => {
             e.preventDefault();

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'expression-list',
         aliases: ['expressions'],
         /** @type {(args: {return: string, filter: string}) => Promise<string>} */
         callback: async (args) => {
             let returnType =
                 /** @type {import('../../slash-commands/SlashCommandReturnHelper.js').SlashCommandReturnType} */
                 (args.return);
             const list = await getExpressionsList({ filterAvailable: !isFalseBoolean(args.filter) });
             return await slashCommandReturnHelper.doReturn(returnType ?? 'pipe', list, { objectToStringFunc: list => list.join(', ') });
         },

                 enumList: slashCommandReturnHelper.enumList({ allowObject: true }),
                 forceEnum: true,
             }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'filter',
 +                description: 'Filter the list to only include expressions that have available sprites for the current character.',
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                enumList: commonEnumProviders.boolean('trueFalse')(),
 +                defaultValue: 'true',
 +            }),
         ],
         returns: 'The comma-separated list of available expressions, including custom expressions.',
         helpString: 'Returns a list of available expressions, including custom expressions.',

                 enumList: Object.keys(EXPRESSION_API).map(api => new SlashCommandEnumValue(api, null, enumTypes.enum)),
             }),
             SlashCommandNamedArgument.fromProps({
 +                name: 'filter',
 +                description: 'Filter the list to only include expressions that have available sprites for the current character.',
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                enumList: commonEnumProviders.boolean('trueFalse')(),
 +                defaultValue: 'true',
 +            }),
 +            SlashCommandNamedArgument.fromProps({
                 name: 'prompt',
                 description: 'Custom prompt for classification. Only relevant if Classifier API is set to LLM.',
                 typeList: [ARGUMENT_TYPE.STRING],

public/scripts/extensions/expressions/settings.html+5 -1 Viewed

                 </select>
             </div>
             <div class="expression_llm_prompt_block m-b-1 m-t-1">
 -                <label for="expression_llm_prompt" class="title_restorable">
 +                <label class="checkbox_label" for="expressions_filter_available" title="When using LLM or WebLLM classifier, only show and use expressions that have sprites assigned to them." data-i18n="[title]When using LLM or WebLLM classifier, only show and use expressions that have sprites assigned to them.">
 +                    <input id="expressions_filter_available" type="checkbox">
 +                    <span data-i18n="Filter expressions for available sprites">Filter expressions for available sprites</span>
 +                </label>
 +                <label for="expression_llm_prompt" class="title_restorable m-t-1">
                     <span data-i18n="LLM Prompt">LLM Prompt</span>
                     <div id="expression_llm_prompt_restore" title="Restore default value" class="right_menu_button">
                         <i class="fa-solid fa-clock-rotate-left fa-sm"></i>