Tool Calling: Implement stealth tool defintions (#3192) * Tool Calling: Implement stealth tool defintions * Move isStealth check up * Always stop generation on stealth tool calls * Image Generation: use stealth flag for tool registration * Update stealth property description to clarify no follow-up generation will be performed * Revert "Image Generation: use stealth flag for tool registration" This reverts commit 8d13445c0b66e4c0ef1ddcfaf18ab185464de600.

7e7b3e30c481e128d78c1e6391ecebc6e230ba6e

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

Signed

Parents: e83182c03b78df935f2751f041f1c8534fc08f8c

public/script.js+10 -4 Viewed

                 const shouldDeleteMessage = type !== 'swipe' && ['', '...'].includes(lastMessage?.mes) && ['', '...'].includes(streamingProcessor?.result);
                 hasToolCalls && shouldDeleteMessage && await deleteLastMessage();
                 const invocationResult = await ToolManager.invokeFunctionTools(streamingProcessor.toolCalls);
 +                const shouldStopGeneration = (!invocationResult.invocations.length && shouldDeleteMessage) || invocationResult.stealthCalls.length;
                 if (hasToolCalls) {
                     if (!invocationResult.invocations.length && shouldDeleteMessageshouldStopGeneration) {
 -                        ToolManager.showToolCallError(invocationResult.errors);
 +                        if (Array.isArray(invocationResult.errors) && invocationResult.errors.length) {
 +                            ToolManager.showToolCallError(invocationResult.errors);
 +                        }
                         unblockGeneration(type);
                         generatedPromptCache = '';
                         streamingProcessor = null;

             const shouldDeleteMessage = type !== 'swipe' && ['', '...'].includes(getMessage);
             hasToolCalls && shouldDeleteMessage && await deleteLastMessage();
             const invocationResult = await ToolManager.invokeFunctionTools(data);
 +            const shouldStopGeneration = (!invocationResult.invocations.length && shouldDeleteMessage) || invocationResult.stealthCalls.length;
             if (hasToolCalls) {
                 if (!invocationResult.invocations.length && shouldDeleteMessageshouldStopGeneration) {
 -                    ToolManager.showToolCallError(invocationResult.errors);
 +                    if (Array.isArray(invocationResult.errors) && invocationResult.errors.length) {
 +                        ToolManager.showToolCallError(invocationResult.errors);
 +                    }
                     unblockGeneration(type);
                     generatedPromptCache = '';
                     return;

public/scripts/tool-calling.js+58 -5 Viewed

  * @typedef {object} ToolInvocationResult
  * @property {ToolInvocation[]} invocations Successful tool invocations
  * @property {Error[]} errors Errors that occurred during tool invocation
 + * @property {string[]} stealthCalls Names of stealth tools that were invoked
  */
 /**

  * @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.
 + * @property {boolean} [stealth] - A tool call result will not be shown in the chat. No follow-up generation will be performed.
  */
 /**

     #shouldRegister;
     /**
 +     * A tool call result will not be shown in the chat. No follow-up generation will be performed.
 +     * @type {boolean}
 +     */
 +    #stealth;
++
 +    /**
      * 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 {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.
 +     * @param {boolean} stealth A tool call result will not be shown in the chat. No follow-up generation will be performed.
      */
     constructor(name, displayName, description, parameters, action, formatMessage, shouldRegister, stealth) {
         this.#name = name;
         this.#displayName = displayName;
         this.#description = description;

         this.#action = action;
         this.#formatMessage = formatMessage;
         this.#shouldRegister = shouldRegister;
 +        this.#stealth = stealth;
+    }
     /**

@@ -214,6 +224,10 @@ class ToolDefinition {
214	224	get displayName() {
215	225	return this.#displayName;
216	226	}
	227	+
	228	+ get stealth() {
	229	+ return this.#stealth;
	230	+ }
217	231	}
218	232
219	233	/**

      * Registers a new tool with the tool registry.
      * @param {ToolRegistration} tool The tool to register.
      */
     static registerFunctionTool({ name, displayName, description, parameters, action, formatMessage, shouldRegister, stealth }) {
         // Convert WIP arguments
         if (typeof arguments[0] !== 'object') {
             [name, description, parameters, action] = arguments;

             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);
 +            name,
 +            displayName,
 +            description,
 +            parameters,
 +            action,
 +            formatMessage,
 +            shouldRegister,
 +            stealth,
 +        );
         this.#tools.set(name, definition);
         console.log('[ToolManager] Registered function tool:', definition);
+    }

+    }
     /**
 +     * Checks if a tool is a stealth tool.
 +     * @param {string} name The name of the tool to check.
 +     * @returns {boolean} Whether the tool is a stealth tool.
 +     */
 +    static isStealthTool(name) {
 +        if (!this.#tools.has(name)) {
 +            return false;
 +        }
++
 +        const tool = this.#tools.get(name);
 +        return !!tool.stealth;
 +    }
++
 +    /**
      * Formats a message for a tool call by name.
      * @param {string} name The name of the tool to format the message for.
      * @param {object} parameters Function tool call parameters.

         const result = {
             invocations: [],
             errors: [],
 +            stealthCalls: [],
         };
         const toolCalls = ToolManager.#getToolCallsFromData(data);

             const parameters = toolCall.function.arguments;
             const name = toolCall.function.name;
             const displayName = ToolManager.getDisplayName(name);
+-
 +            const isStealth = ToolManager.isStealthTool(name);
             const message = await ToolManager.formatToolCallMessage(name, parameters);
             const toast = message && toastr.info(message, 'Tool Calling', { timeOut: 0 });
             const toolResult = await ToolManager.invokeFunctionTool(name, parameters);

                 continue;
+            }
 +            // Don't save stealth tool invocations
 +            if (isStealth) {
 +                result.stealthCalls.push(name);
 +                continue;
 +            }
++
             const invocation = {
                 id,
                 displayName,

                     isRequired: false,
                     acceptsMultiple: false,
                 }),
 +                SlashCommandNamedArgument.fromProps({
 +                    name: 'stealth',
 +                    description: 'If true, a tool call result will not be shown in the chat and no follow-up generation will be performed.',
 +                    typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                    isRequired: false,
 +                    acceptsMultiple: false,
 +                    defaultValue: String(false),
 +                }),
             ],
             unnamedArgumentList: [
                 SlashCommandArgument.fromProps({

                     };
+                }
                 const { name, displayName, description, parameters, formatMessage, shouldRegister, stealth } = args;
                 if (!(action instanceof SlashCommandClosure)) {
                     throw new Error('The unnamed argument must be a closure.');

                     action: actionFunc,
                     formatMessage: formatMessageFunc,
                     shouldRegister: shouldRegisterFunc,
 +                    stealth: stealth && isTrueBoolean(String(stealth)),
                 });
                 return '';