bc0f5bf4 · permissionBRICK/SillyTavern

  * @property {object} parameters - The parameters for the tool.
  * @property {function} action - The action to perform when the tool is invoked.
  * @property {function} formatMessage - A function to format the tool call message.
 + * @property {function} shouldRegister - A function to determine if the tool should be registered.
  */
 /**

     #formatMessage;
     /**
 +     * A function that will be called to determine if the tool should be registered.
 +     * @type {function}
 +     */
 +    #shouldRegister;
++
 +    /**
      * Creates a new ToolDefinition.
      * @param {string} name A unique name for the tool.
      * @param {string} displayName A user-friendly display name for the tool.

      * @param {object} parameters A JSON schema for the parameters that the tool accepts.
      * @param {function} action A function that will be called when the tool is executed.
      * @param {function} formatMessage A function that will be called to format the tool call toast.
 +     * @param {function} shouldRegister A function that will be called to determine if the tool should be registered.
      */
     constructor(name, displayName, description, parameters, action, formatMessage, shouldRegister) {
         this.#name = name;
         this.#displayName = displayName;
         this.#description = description;
         this.#parameters = parameters;
         this.#action = action;
         this.#formatMessage = formatMessage;
 +        this.#shouldRegister = shouldRegister;
+    }
     /**

             : `Invoking tool: ${this.#displayName || this.#name}`;
+    }
 +    async shouldRegister() {
 +        return typeof this.#shouldRegister === 'function'
 +            ? await this.#shouldRegister()
 +            : true;
 +    }
++
     get displayName() {
         return this.#displayName;
+    }

      * Registers a new tool with the tool registry.
      * @param {ToolRegistration} tool The tool to register.
      */
     static registerFunctionTool({ name, displayName, description, parameters, action, formatMessage, shouldRegister }) {
         // Convert WIP arguments
         if (typeof arguments[0] !== 'object') {
             [name, description, parameters, action] = arguments;
+        }
         if (this.#tools.has(name)) {
             console.warn(`[ToolManager] A tool with the name "${name}" has already been registered. The definition will be overwritten.`);
+        }
         const definition = new ToolDefinition(name, displayName, description, parameters, action, formatMessage, shouldRegister);
         this.#tools.set(name, definition);
         console.log('[ToolManager] Registered function tool:', definition);
+    }

             const result = await tool.invoke(invokeParameters);
             return typeof result === 'string' ? result : JSON.stringify(result);
         } catch (error) {
             console.error(`[ToolManager] An error occurred while invoking the tool "${name}":`, error);
             if (error instanceof Error) {
                 error.cause = name;

@@ -300,7 +315,7 @@ export class ToolManager {
300	315	const formatParameters = typeof parameters === 'string' ? JSON.parse(parameters) : parameters;
301	316	return tool.formatMessage(formatParameters);
302	317	} catch (error) {
303	318	console.error(`[ToolManager] An error occurred while formatting the tool call message for "${name}":`, error);
304	319	return `Invoking tool: ${name}`;
305	320	}
306	321	}

         const tools = [];
         for (const tool of ToolManager.tools) {
 +            const register = await tool.shouldRegister();
 +            if (!register) {
 +                console.log('[ToolManager] Skipping tool registration:', tool);
 +                continue;
 +            }
             tools.push(tool.toFunctionOpenAI());
+        }
         if (tools.length) {
             console.log('[ToolManager] Registered function tools:', tools);
             data['tools'] = tools;
             data['tool_choice'] = 'auto';

@@ -422,7 +442,7 @@ export class ToolManager {
422	442	delete targetToolCall[this.#INPUT_DELTA_KEY];
423	443	ToolManager.#applyToolCallDelta(targetToolCall, jsonDelta);
424	444	} catch (error) {
425	445	console.warn('[ToolManager] Failed to apply input JSON delta:', error);
426	446	}
427	447	}
428	448	}

                 continue;
+            }
             console.log('[ToolManager] Function tool call:', toolCall);
             const id = toolCall.id;
             const parameters = toolCall.function.arguments;
             const name = toolCall.function.name;

             const toast = message && toastr.info(message, 'Tool Calling', { timeOut: 0 });
             const toolResult = await ToolManager.invokeFunctionTool(name, parameters);
             toastr.clear(toast);
             console.log('[ToolManager] Function tool result:', result);
             // Save a successful invocation
             if (toolResult instanceof Error) {

Tool Calling: add shouldRegister function to tool defintion