649c3911 · permissionBRICK/SillyTavern

 import { enumTypes, SlashCommandEnumValue } from './slash-commands/SlashCommandEnumValue.js';
 import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { slashCommandReturnHelper } from './slash-commands/SlashCommandReturnHelper.js';
+import { isTrueBoolean } from './utils.js';
 /**
  * @typedef {object} ToolInvocation

                     isRequired: true,
                     acceptsMultiple: false,
                 }),
+                SlashCommandNamedArgument.fromProps({
+                    name: 'shouldRegister',
+                    description: 'The closure to be executed to determine if the tool should be registered. Must return a boolean.',
+                    typeList: [ARGUMENT_TYPE.CLOSURE],
+                    isRequired: false,
+                    acceptsMultiple: false,
+                }),
             ],
             unnamedArgumentList: [
                 SlashCommandArgument.fromProps({

                 /**
                  * Converts a slash command closure to a function.
                  * @param {SlashCommandClosure} action Closure to convert to a function
+                 * @param {function(any): any} convertResult Function to convert the result
                  * @returns {function} Function that executes the closure
                  */
-                function closureToFunction(action) {
+                function closureToFunction(action, convertResult) {
                     return async (args) => {
                         const localClosure = action.getCopy();
                         localClosure.onProgress = () => { };

@@ -878,11 +887,11 @@ export class ToolManager {
878	scope.letVariable('arg', args);	887	scope.letVariable('arg', args);
879	}	888	}
880	const result = await localClosure.execute();	889	const result = await localClosure.execute();
881	return result.pipe;	890	return convertResult(result.pipe);
882	};	891	};
883	}	892	}
884		893
885	const { name, displayName, description, parameters, formatMessage } = args;	894	const { name, displayName, description, parameters, formatMessage, shouldRegister } = args;
886		895
887	if (!(action instanceof SlashCommandClosure)) {	896	if (!(action instanceof SlashCommandClosure)) {
888	throw new Error('The unnamed argument must be a closure.');	897	throw new Error('The unnamed argument must be a closure.');

                 if (formatMessage && !(formatMessage instanceof SlashCommandClosure)) {
                     throw new Error('The "formatMessage" argument must be a closure.');
+                }
+                if (shouldRegister && !(shouldRegister instanceof SlashCommandClosure)) {
+                    throw new Error('The "shouldRegister" argument must be a closure.');
+                }
-                const actionFunc = closureToFunction(action);
+                const actionFunc = closureToFunction(action, x => x);
-                const formatMessageFunc = formatMessage instanceof SlashCommandClosure ? closureToFunction(formatMessage) : null;
+                const formatMessageFunc = formatMessage instanceof SlashCommandClosure ? closureToFunction(formatMessage, x => String(x)) : null;
+                const shouldRegisterFunc = shouldRegister instanceof SlashCommandClosure ? closureToFunction(shouldRegister, x => isTrueBoolean(x)) : null;
                 ToolManager.registerFunctionTool({
                     name: String(name ?? ''),

                     parameters: JSON.parse(parameters ?? '{}'),
                     action: actionFunc,
                     formatMessage: formatMessageFunc,
-                    shouldRegister: async () => true, // TODO: Implement shouldRegister
+                    shouldRegister: shouldRegisterFunc,
                 });
                 return '';

Add shouldRegister arg to /tools-register