Merge pull request #3496 from SillyTavern/parse-reasoning-command-args Add 'return' and 'strict' to `/reasoning-parse`, and make all reasoning parsing strict by default

580856064e05faeb7375eb2b95a63648aea0d028

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

Signed

public/scripts/reasoning.js+39 -9 Viewed

 import { power_user } from './power-user.js';
 import { SlashCommand } from './slash-commands/SlashCommand.js';
 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './slash-commands/SlashCommandArgument.js';
-import { commonEnumProviders } from './slash-commands/SlashCommandCommonEnumsProvider.js';
+import { commonEnumProviders, enumIcons } from './slash-commands/SlashCommandCommonEnumsProvider.js';
+import { enumTypes, SlashCommandEnumValue } from './slash-commands/SlashCommandEnumValue.js';
 import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { textgen_types, textgenerationwebui_settings } from './textgen-settings.js';
 import { copyText, escapeRegex, isFalseBoolean, setDatasetProperty } from './utils.js';

                 typeList: [ARGUMENT_TYPE.BOOLEAN],
                 defaultValue: 'true',
                 isRequired: false,
-                enumProvider: commonEnumProviders.boolean('trueFalse'),
+                enumList: commonEnumProviders.boolean('trueFalse')(),
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'return',
+                description: 'Whether to return the parsed reasoning or the content without reasoning',
+                typeList: [ARGUMENT_TYPE.STRING],
+                defaultValue: 'reasoning',
+                isRequired: false,
+                enumList: [
+                    new SlashCommandEnumValue('reasoning', null, enumTypes.enum, enumIcons.reasoning),
+                    new SlashCommandEnumValue('content', null, enumTypes.enum, enumIcons.message),
+                ],
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'strict',
+                description: 'Whether to require the reasoning block to be at the beginning of the string (excluding whitespaces).',
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'true',
+                isRequired: false,
+                enumList: commonEnumProviders.boolean('trueFalse')(),
             }),
         ],
         unnamedArgumentList: [

             }),
         ],
         callback: (args, value) => {
-            if (!value) {
+            if (!value || typeof value !== 'string') {
                 return '';
+            }
             if (!power_user.reasoning.prefix || !power_user.reasoning.suffix) {
-                toastr.warning(t`Both prefix and suffix must be set in the Reasoning Formatting settings.`);
+                toastr.warning(t`Both prefix and suffix must be set in the Reasoning Formatting settings.`, t`Reasoning Parse`);
-                return String(value);
+                return value;
+            }
+            if (typeof args.return !== 'string' || !['reasoning', 'content'].includes(args.return)) {
+                toastr.warning(t`Invalid return type '${args.return}', defaulting to 'reasoning'.`, t`Reasoning Parse`);
+            }
-            const parsedReasoning = parseReasoningFromString(String(value));
+            const returnMessage = args.return === 'content';
+            const parsedReasoning = parseReasoningFromString(value, { strict: !isFalseBoolean(String(args.strict ?? '')) });
             if (!parsedReasoning) {
-                return '';
+                return returnMessage ? value : '';
+            }
+            if (returnMessage) {
+                return parsedReasoning.content;
+            }
             const applyRegex = !isFalseBoolean(String(args.regex ?? ''));

  * @property {string} reasoning Reasoning block
  * @property {string} content Message content
  * @param {string} str Content of the message
+ * @param {Object} options Optional arguments
+ * @param {boolean} [options.strict=true] Whether the reasoning block **has** to be at the beginning of the provided string (excluding whitespaces), or can be anywhere in it
  * @returns {ParsedReasoning|null} Parsed reasoning block and message content
  */
-function parseReasoningFromString(str) {
+function parseReasoningFromString(str, { strict = true } = {}) {
     // Both prefix and suffix must be defined
     if (!power_user.reasoning.prefix || !power_user.reasoning.suffix) {
         return null;
+    }
     try {
-        const regex = new RegExp(`${escapeRegex(power_user.reasoning.prefix)}(.*?)${escapeRegex(power_user.reasoning.suffix)}`, 's');
+        const regex = new RegExp(`${(strict ? '^\\s*?' : '')}${escapeRegex(power_user.reasoning.prefix)}(.*?)${escapeRegex(power_user.reasoning.suffix)}`, 's');
         let didReplace = false;
         let reasoning = '';

public/scripts/slash-commands/SlashCommandCommonEnumsProvider.js+1 -0 Viewed

     preset: '⚙️',
     file: '📄',
     message: '💬',
+    reasoning: '💡',
     voice: '🎤',
     server: '🖥️',
     popup: '🗔',