a37b805a · permissionBRICK/SillyTavern

 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';
 import { isFunctionCallingSupported } from '../../openai.js';
 import { SlashCommandEnumValue, enumTypes } from '../../slash-commands/SlashCommandEnumValue.js';
 import { commonEnumProviders } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';

     'surprise',
     'neutral',
 ];
 +/** @enum {number} */
 const EXPRESSION_API = {
     local: 0,
     extras: 1,

     return '';
+}
 -async function classifyCommand(_, text) {
 +async function classifyCallback(/** @type {{api: string?}} */ { api = null }, text) {
     if (!text) {
         consoletoastr.logwarning('No text provided');
 +        return '';
 +    }
 +    if (api && !Object.keys(EXPRESSION_API).includes(api)) {
 +        toastr.warning('Invalid API provided');
         return '';
+    }
 -    if (!modules.includes('classify') && extension_settings.expressions.api == EXPRESSION_API.extras) {
 +    const expressionApi = EXPRESSION_API[api] || extension_settings.expressions.api;
++
 +    if (!modules.includes('classify') && expressionApi == EXPRESSION_API.extras) {
         toastr.warning('Text classification is disabled or not available');
         return '';
+    }
     const label = getExpressionLabel(text, expressionApi);
     console.debug(`Classification result for "${text}": ${label}`);
     return label;
+}

+    }
+}
 -async function getExpressionLabel(text) {
 +/**
 + * Retrieves the label of an expression via classification based on the provided text.
 + * Optionally allows to override the expressions API being used.
 + * @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.
 + * @returns {Promise<string>} - The label of the expression.
 + */
 +export async function getExpressionLabel(text, expressionsApi = extension_settings.expressions.api) {
     // Return if text is undefined, saving a costly fetch request
     if ((!modules.includes('classify') && extension_settings.expressions.apiexpressionsApi == EXPRESSION_API.extras) || !text) {
         return getFallbackExpression();
+    }

     text = sampleClassifyText(text);
     try {
         switch (extension_settings.expressions.apiexpressionsApi) {
             // Local BERT pipeline
             case EXPRESSION_API.local: {
                 const localResult = await fetch('/api/extra/classify', {

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'classify',
         callback: classifyCommandclassifyCallback,
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'api',
 +                description: 'The Classifier API to classify with. If not specified, the configured one will be used.',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                enumList: Object.keys(EXPRESSION_API).map(api => new SlashCommandEnumValue(api, null, enumTypes.enum)),
 +            }),
 +        ],
         unnamedArgumentList: [
             new SlashCommandArgument(
                 'text', [ARGUMENT_TYPE.STRING], true,

                 Performs an emotion classification of the given text and returns a label.
             </div>
             <div>
 +                Allows to specify which Classifier API to perform the classification with.
 +            </div>
 +            <div>
                 <strong>Example:</strong>
                 <ul>
                     <li>

/classify can specify classier API as argument