Show an error when all tools fail

6558b106754a73faff6ca171254192ed9a1157e9

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

public/script.js+21 -6 Viewed

                 const lastMessage = chat[chat.length - 1];
                 const shouldDeleteMessage = ['', '...'].includes(lastMessage?.mes) && ['', '...'].includes(streamingProcessor.result);
                 shouldDeleteMessage && await deleteLastMessage();
                 const invocationsinvocationResult = await ToolManager.invokeFunctionTools(streamingProcessor.toolCalls);
                 if (Array.isArray(invocations) && invocationsinvocationResult.lengthhadToolCalls) {
 +                    if (!invocationResult.invocations.length && shouldDeleteMessage) {
 +                        ToolManager.showToolCallError(invocationResult.errors);
 +                        unblockGeneration(type);
 +                        generatedPromptCache = '';
 +                        streamingProcessor = null;
 +                        return;
 +                    }
++
                     streamingProcessor = null;
                     ToolManager.saveFunctionToolInvocations(invocationResult.invocations);
                     return Generate(type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage, quietName }, dryRun);
+                }
+            }

         if (canPerformToolCalls) {
             const shouldDeleteMessage = ['', '...'].includes(getMessage);
             shouldDeleteMessage && await deleteLastMessage();
             const invocationsinvocationResult = await ToolManager.invokeFunctionTools(data);
             if (Array.isArray(invocations) && invocationsinvocationResult.lengthhadToolCalls) {
 -                ToolManager.saveFunctionToolInvocations(invocations);
 +                if (!invocationResult.invocations.length && shouldDeleteMessage) {
 +                    ToolManager.showToolCallError(invocationResult.errors);
 +                    unblockGeneration(type);
 +                    generatedPromptCache = '';
 +                    return;
 +                }
++
 +                ToolManager.saveFunctionToolInvocations(invocationResult.invocations);
                 return Generate(type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage, quietName }, dryRun);
+            }
+        }

public/scripts/tool-calling.js+44 -10 Viewed

 import { addOneMessage, chat, main_api, system_avatar, systemUserName } from '../script.js';
 import { chat_completion_sources, oai_settings } from './openai.js';
 +import { Popup } from './popup.js';
 /**
  * @typedef {object} ToolInvocation

  */
 /**
 + * @typedef {object} ToolInvocationResult
 + * @property {ToolInvocation[]} invocations Successful tool invocations
 + * @property {boolean} hadToolCalls Whether any tool calls were found
 + * @property {Error[]} errors Errors that occurred during tool invocation
 + */
++
 +/**
  * A class that represents a tool definition.
  */
 class ToolDefinition {

      * Invokes a tool by name. Returns the result of the tool's action function.
      * @param {string} name The name of the tool to invoke.
      * @param {object} parameters Function parameters. For example, if the tool requires a "name" parameter, you would pass {name: "value"}.
      * @returns {Promise<string|nullError>} The result of the tool's action function. If an error occurs, null is returned. Non-string results are JSON-stringified.
      */
     static async invokeFunctionTool(name, parameters) {
         try {

             return typeof result === 'string' ? result : JSON.stringify(result);
         } catch (error) {
             console.error(`An error occurred while invoking the tool "${name}":`, error);
 -            return null;
++
 +            if (error instanceof Error) {
 +                error.cause = name;
 +                return error;
 +            }
++
 +            return new Error('Unknown error occurred while invoking the tool.', { cause: name });
+        }
+    }

     /**
      * Check for function tool calls in the response data and invoke them.
      * @param {any} data Reply data
      * @returns {Promise<ToolInvocation[]ToolInvocationResult>} Successful tool invocations
      */
     static async invokeFunctionTools(data) {
         /** @type {ToolInvocation[]ToolInvocationResult} */
         const invocationsresult = [];{
 +            invocations: [],
 +            hadToolCalls: false,
 +            errors: [],
 +        };
         const toolCalls = ToolManager.#getToolCallsFromData(data);
         const oaiCompatibleSources = [
             chat_completion_sources.OPENAI,

         if (oaiCompatibleSources.includes(oai_settings.chat_completion_source)) {
             if (!Array.isArray(toolCalls)) {
                 return []result;
+            }
             for (const toolCall of toolCalls) {

                 const id = toolCall.id;
                 const parameters = toolCall.function.arguments;
                 const name = toolCall.function.name;
 +                result.hadToolCalls = true;
                 const toast = toastr.info(`Invoking function tool: ${name}`);
                 const resulttoolResult = await ToolManager.invokeFunctionTool(name, parameters);
                 toastr.clear(toast);
                 console.log('Function tool result:', result);
                 // Save a successful invocation
                 if (resulttoolResult instanceof Error) {
 -                    invocations.push({ id, name, parameters, result });
 +                    result.errors.push(toolResult);
 +                    continue;
+                }
++
 +                result.invocations.push({ id, name, parameters, result: toolResult });
+            }
+        }

         chat.push(message);
         addOneMessage(message);
+    }
++
 +    /**
 +     * Shows an error message for tool calls.
 +     * @param {Error[]} errors Errors that occurred during tool invocation
 +     * @returns {void}
 +     */
 +    static showToolCallError(errors) {
 +        toastr.error('An error occurred while invoking function tools. Click here for more details.', 'Tool Calling', {
 +            onclick: () => Popup.show.text('Tool Calling Errors', DOMPurify.sanitize(errors.map(e => `${e.cause}: ${e.message}`).join('<br>'))),
 +            timeOut: 5000,
 +        });
 +    }
+}

public/style.css+1 -0 Viewed

 .mes.smallSysMes pre {
     text-align: initial;
     word-break: break-all;
 +    margin-top: 5px;
+}
 .mes.smallSysMes summary {