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+8 -2 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 && shouldDeleteMessage) {
+                    if (shouldStopGeneration) {
+                        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 && shouldDeleteMessage) {
+                if (shouldStopGeneration) {
+                    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) {
+    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	get displayName() {	224	get displayName() {
215	return this.#displayName;	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 }) {
+    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);
+        const definition = new ToolDefinition(
+            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 } = args;
+                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 '';