Save tool calls to visible chats.

0f8c1fa95d7bdfea5d69ffed3c0ee76eef444886

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

Parents: 3335dbf1a75dd0ffeaede2239c64fb5b85425f31

public/script.js+15 -11 Viewed

@@ -3571,7 +3571,9 @@ export async function Generate(type, { automatic_trigger, force_name2, quiet_pro
3571	}	3571	}
3572		3572
3573	// Collect messages with usable content	3573	// Collect messages with usable content
3574	let coreChat = chat.filter(x => !x.is_system);	3574	const canUseTools = ToolManager.isToolCallingSupported();
		3575	const canPerformToolCalls = !dryRun && ToolManager.canPerformToolCalls(type);
		3576	let coreChat = chat.filter(x => !x.is_system \|\| (canUseTools && Array.isArray(x.extra?.tool_invocations)));
3575	if (type === 'swipe') {	3577	if (type === 'swipe') {
3576	coreChat.pop();	3578	coreChat.pop();
3577	}	3579	}

                 getMessage = continue_mag + getMessage;
+            }
-            if (ToolManager.isFunctionCallingSupported() && Array.isArray(streamingProcessor.toolCalls) && streamingProcessor.toolCalls.length) {
+            if (canPerformToolCalls && Array.isArray(streamingProcessor.toolCalls) && streamingProcessor.toolCalls.length) {
-                const invocations = await ToolManager.checkFunctionToolCalls(streamingProcessor.toolCalls);
+                const invocations = await ToolManager.invokeFunctionTools(streamingProcessor.toolCalls);
                 if (Array.isArray(invocations) && invocations.length) {
                     const lastMessage = chat[chat.length - 1];
                     const shouldDeleteMessage = ['', '...'].includes(lastMessage?.mes) && ['', '...'].includes(streamingProcessor.result);

             throw new Error(data?.response);
+        }
-        if (ToolManager.isFunctionCallingSupported()) {
-            const invocations = await ToolManager.checkFunctionToolCalls(data);
-            if (Array.isArray(invocations) && invocations.length) {
-                ToolManager.saveFunctionToolInvocations(invocations);
-                return Generate(type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage, quietName }, dryRun);
-            }
-        }
         //const getData = await response.json();
         let getMessage = extractMessageFromData(data);
         let title = extractTitleFromData(data);

             parseAndSaveLogprobs(data, continue_mag);
+        }
+        if (canPerformToolCalls) {
+            const invocations = await ToolManager.invokeFunctionTools(data);
+            if (Array.isArray(invocations) && invocations.length) {
+                const shouldDeleteMessage = ['', '...'].includes(getMessage);
+                shouldDeleteMessage && await deleteLastMessage();
+                ToolManager.saveFunctionToolInvocations(invocations);
+                return Generate(type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage, quietName }, dryRun);
+            }
+        }
         if (type !== 'quiet') {
             playMessageSound();
+        }

public/scripts/openai.js+15 -8 Viewed

+    }
     const imageInlining = isImageInliningSupported();
-    const toolCalling = ToolManager.isFunctionCallingSupported();
+    const canUseTools = ToolManager.isToolCallingSupported();
     // Insert chat messages as long as there is budget available
     const chatPool = [...messages].reverse();

             await chatMessage.addImage(chatPrompt.image);
+        }
-        if (toolCalling && Array.isArray(chatPrompt.invocations)) {
+        if (canUseTools && Array.isArray(chatPrompt.invocations)) {
             /** @type {import('./tool-calling.js').ToolInvocation[]} */
             const invocations = chatPrompt.invocations;
-            const toolCallMessage = new Message('assistant', undefined, 'toolCall-' + chatMessage.identifier);
+            const toolCallMessage = new Message(chatMessage.role, undefined, 'toolCall-' + chatMessage.identifier);
             toolCallMessage.setToolCalls(invocations);
             if (chatCompletion.canAfford(toolCallMessage)) {
                 chatCompletion.reserveBudget(toolCallMessage);

     const eventData = { chat, dryRun };
     await eventSource.emit(event_types.CHAT_COMPLETION_PROMPT_READY, eventData);
-    openai_messages_count = chat.filter(x => x?.role === 'user' || x?.role === 'assistant')?.length || 0;
+    openai_messages_count = chat.filter(x => !x?.tool_calls && (x?.role === 'user' || x?.role === 'assistant'))?.length || 0;
     return [chat, promptManager.tokenHandler.counts];
+}

@@ -1886,7 +1886,7 @@ async function sendOpenAIRequest(type, messages, signal) {
1886	generate_data['seed'] = oai_settings.seed;	1886	generate_data['seed'] = oai_settings.seed;
1887	}	1887	}
1888		1888
1889	if (!canMultiSwipe && ToolManager.isFunctionCallingSupported()) {	1889	if (!canMultiSwipe && ToolManager.canPerformToolCalls(type)) {
1890	await ToolManager.registerFunctionToolsOpenAI(generate_data);	1890	await ToolManager.registerFunctionToolsOpenAI(generate_data);
1891	}	1891	}
1892		1892

+    }
     /**
-     * Get chat in the format of {role, name, content}.
+     * Get chat in the format of {role, name, content, tool_calls}.
      * @returns {Array} Array of objects with role, name, and content properties.
      */
     getChat() {
         return this.collection.reduce((acc, message) => {
-            const name = message.name;
+            if (message.content || message.tool_calls) {
-            if (message.content) acc.push({ role: message.role, ...(name && { name }), content: message.content });
+                acc.push({
+                    role: message.role,
+                    content: message.content,
+                    ...(message.name && { name: message.name }),
+                    ...(message.tool_calls && { tool_calls: message.tool_calls }),
+                    ...(message.role === 'tool' && { tool_call_id: message.identifier }),
+                });
+            }
             return acc;
         }, []);
+    }

public/scripts/tool-calling.js+41 -25 Viewed

-import { chat, main_api } from '../script.js';
+import { addOneMessage, chat, main_api, system_avatar, systemUserName } from '../script.js';
 import { chat_completion_sources, oai_settings } from './openai.js';
 /**

@@ -243,12 +243,12 @@ export class ToolManager {
243	}	243	}
244	}	244	}
245		245
246	static isFunctionCallingSupported() {	246	/**
247	if (main_api !== 'openai') {	247	* Checks if tool calling is supported for the current settings and generation type.
248	return false;	248	* @returns {boolean} Whether tool calling is supported for the given type
249	}	249	*/
250		250	static isToolCallingSupported() {
251	if (!oai_settings.function_calling) {	251	if (main_api !== 'openai' \|\| !oai_settings.function_calling) {
252	return false;	252	return false;
253	}	253	}
254		254

         return supportedSources.includes(oai_settings.chat_completion_source);
+    }
+    /**
+     * Checks if tool calls can be performed for the current settings and generation type.
+     * @param {string} type Generation type
+     * @returns {boolean} Whether tool calls can be performed for the given type
+     */
+    static canPerformToolCalls(type) {
+        const noToolCallTypes = ['swipe', 'impersonate', 'quiet', 'continue'];
+        const isSupported = ToolManager.isToolCallingSupported();
+        return isSupported && !noToolCallTypes.includes(type);
+    }
+    /**
+     * Utility function to get tool calls from the response data.
+     * @param {any} data Response data
+     * @returns {any[]} Tool calls from the response data
+     */
     static #getToolCallsFromData(data) {
         // Parsed tool calls from streaming data
         if (Array.isArray(data) && data.length > 0) {

      * @param {any} data Reply data
      * @returns {Promise<ToolInvocation[]>} Successful tool invocations
      */
-    static async checkFunctionToolCalls(data) {
+    static async invokeFunctionTools(data) {
-        if (!ToolManager.isFunctionCallingSupported()) {
-            return [];
-        }
         /** @type {ToolInvocation[]} */
         const invocations = [];
         const toolCalls = ToolManager.#getToolCallsFromData(data);
-        const oaiCompat = [
+        const oaiCompatibleSources = [
             chat_completion_sources.OPENAI,
             chat_completion_sources.CUSTOM,
             chat_completion_sources.MISTRALAI,

             chat_completion_sources.GROQ,
         ];
-        if (oaiCompat.includes(oai_settings.chat_completion_source)) {
+        if (oaiCompatibleSources.includes(oai_settings.chat_completion_source)) {
             if (!Array.isArray(toolCalls)) {
                 return [];
+            }

                 toastr.info('Invoking function tool: ' + name);
                 const result = await ToolManager.invokeFunctionTool(name, parameters);
-                toastr.info('Function tool result: ' + result);
+                console.log('Function tool result:', result);
                 // Save a successful invocation
                 if (result) {

      * @param {ToolInvocation[]} invocations Successful tool invocations
      */
     static saveFunctionToolInvocations(invocations) {
-        for (let index = chat.length - 1; index >= 0; index--) {
+        const toolNames = invocations.map(i => i.name).join(', ');
-            const message = chat[index];
+        const message = {
-            if (message.is_user) {
+            name: systemUserName,
-                if (!message.extra || typeof message.extra !== 'object') {
+            force_avatar: system_avatar,
-                    message.extra = {};
+            is_system: true,
-                }
+            is_user: false,
-                message.extra.tool_invocations = invocations;
+            mes: `Performed tool calls: ${toolNames}`,
-                break;
+            extra: {
-            }
+                isSmallSys: true,
-        }
+                tool_invocations: invocations,
+            },
+        };
+        chat.push(message);
+        addOneMessage(message);
+    }
+}