5cf64a26 · permissionBRICK/SillyTavern

 /**
  * @typedef {object} ToolInvocation
  * @property {string} id - A unique identifier for the tool invocation.
 + * @property {string} displayName - The display name of the tool.
  * @property {string} name - The name of the tool.
  * @property {string} parameters - The parameters for the tool invocation.
  * @property {string} result - The result of the tool invocation.

     #name;
     /**
 +     * A user-friendly display name for the tool.
 +     * @type {string}
 +     */
 +    #displayName;
++
 +    /**
      * A description of what the tool does.
      * @type {string}
      */

     #action;
     /**
 +     * A function that will be called to format the tool call toast.
 +     * @type {function}
 +     */
 +    #formatMessage;
++
 +    /**
      * 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 {string} description A description of what the tool does.
      * @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.
      */
     constructor(name, displayName, description, parameters, action, formatMessage) {
         this.#name = name;
 +        this.#displayName = displayName;
         this.#description = description;
         this.#parameters = parameters;
         this.#action = action;
 +        this.#formatMessage = formatMessage;
+    }
     /**

     async invoke(parameters) {
         return await this.#action(parameters);
+    }
++
 +    /**
 +     * Formats a message with the tool invocation.
 +     * @param {object} parameters The parameters to pass to the tool.
 +     * @returns {string} The formatted message.
 +     */
 +    formatMessage(parameters) {
 +        return typeof this.#formatMessage === 'function'
 +            ? this.#formatMessage(parameters)
 +            : `Invoking tool: ${this.#displayName || this.#name}`;
 +    }
++
 +    get displayName() {
 +        return this.#displayName;
 +    }
+}
 /**

     /**
      * Registers a new tool with the tool registry.
      * @param {stringobject} nametool The name oftool theto toolregister.
      * @param {string} descriptiontool.name AThe descriptionname of what the tool does.
      * @param {objectstring} parameterstool.displayName A JSON schema foruser-friendly thedisplay parametersname thatfor the tool accepts.
      * @param {functionstring} actiontool.description A function that will bedescription calledof whenwhat the tool is executeddoes.
 +     * @param {object} tool.parameters A JSON schema for the parameters that the tool accepts.
 +     * @param {function} tool.action A function that will be called when the tool is executed.
 +     * @param {function} tool.formatMessage A function that will be called to format the tool call toast.
      */
     static registerFunctionTool({ name, displayName, description, parameters, action, formatMessage }) {
 +        // Convert WIP arguments
 +        if (typeof arguments[0] !== 'object') {
 +            [name, description, parameters, action] = arguments;
 +        }
++
         if (this.#tools.has(name)) {
             console.warn(`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);
         this.#tools.set(name, definition);
         console.log('[ToolManager] Registered function tool:', definition);
+    }

+        }
+    }
 +    static formatToolCallMessage(name, parameters) {
 +        if (!this.#tools.has(name)) {
 +            return `Invoked unknown tool: ${name}`;
 +        }
++
 +        try {
 +            const tool = this.#tools.get(name);
 +            const formatParameters = typeof parameters === 'string' ? JSON.parse(parameters) : parameters;
 +            return tool.formatMessage(formatParameters);
 +        } catch (error) {
 +            console.error(`An error occurred while formatting the tool call message for "${name}":`, error);
 +            return `Invoking tool: ${name}`;
 +        }
 +    }
++
 +    /**
 +     * Gets the display name of a tool by name.
 +     * @param {string} name
 +     * @returns {string} The display name of the tool.
 +     */
 +    static getDisplayName(name) {
 +        if (!this.#tools.has(name)) {
 +            return name;
 +        }
++
 +        const tool = this.#tools.get(name);
 +        return tool.displayName || name;
 +    }
++
     /**
      * Register function tools for the next chat completion request.
      * @param {object} data Generation data

                 const id = toolCall.id;
                 const parameters = toolCall.function.arguments;
                 const name = toolCall.function.name;
 +                const displayName = ToolManager.getDisplayName(name);
                 result.hadToolCalls = true;
                 const toastmessage = toastrToolManager.infoformatToolCallMessage(`Invoking function tool: ${name}`, parameters);
 +                const toast = message && toastr.info(message, 'Tool Calling', { timeOut: 0 });
                 const toolResult = await ToolManager.invokeFunctionTool(name, parameters);
                 toastr.clear(toast);
                 console.log('Function tool result:', result);

@@ -365,7 +436,14 @@ export class ToolManager {
365	436	continue;
366	437	}
367	438
368		- result.invocations.push({ id, name, parameters, result: toolResult });
	439	+ const invocation = {
	440	+ id,
	441	+ displayName,
	442	+ name,
	443	+ parameters,
	444	+ result: toolResult,
	445	+ };
	446	+ result.invocations.push(invocation);
369	447	}
370	448	}
371	449

         codeElement.classList.add('language-json');
         data.forEach(i => i.parameters = tryParse(i.parameters));
         codeElement.textContent = JSON.stringify(data, null, 2);
         const toolNames = data.map(i => i.displayName || i.name).join(', ');
         summaryElement.textContent = `Performed toolTool calls: ${toolNames}`;
         preElement.append(codeElement);
         detailsElement.append(summaryElement, preElement);
         return detailsElement.outerHTML;

Update tool registration