Add shouldRegister arg to /tools-register

649c3911eb458abdc40b3722ce6e0ce22d7c56a5

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

public/scripts/tool-calling.js+19 -6 Viewed

 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, convertResult) {
                     return async (args) => {
                         const localClosure = action.getCopy();
                         localClosure.onProgress = () => { };

@@ -878,11 +887,11 @@ export class ToolManager {
878	887	scope.letVariable('arg', args);
879	888	}
880	889	const result = await localClosure.execute();
881	890	return convertResult(result.pipe);
882	891	};
883	892	}
884	893
885	894	const { name, displayName, description, parameters, formatMessage, shouldRegister } = args;
886	895
887	896	if (!(action instanceof SlashCommandClosure)) {
888	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, x => x);
                 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 '';