feat: add finalizeIntermediaryMessage for StreamingProcessor (#5333) * feat: add finalizeIntermediaryMessage for streaming tool call chains Add a lighter finalization method on StreamingProcessor that runs before tool invocation. This ensures CHARACTER_MESSAGE_RENDERED is emitted for streamed text messages before the tool call chain continues, allowing extensions (TTS, image forwarding, etc.) to process intermediary messages. finalizeIntermediaryMessage performs essential processing: - Code block styling (addCopyToCodeBlocks) - Reasoning handler finalization - Logprobs saving - Image attachment processing - Reasoning signature storage - MESSAGE_RECEIVED and CHARACTER_MESSAGE_RENDERED events Without the heavier onFinishStreaming operations: - UI unlock (markUIGenStopped) - Auto-swipe - Sound playback - Chat saving - Swipe counter update * fix: return Error objects from invokeFunctionTool and create error invocations invokeFunctionTool previously called .toString() on caught errors, converting them to plain strings. This made the 'instanceof Error' check in invokeFunctionTools dead code - errors silently became successful invocations, showToolCallError never fired, and the result.errors array was always empty. Changes: - Return Error objects directly from invokeFunctionTool - Create error invocations with error: true flag when tools fail - Add error field to ToolInvocation typedef * fix: record failed stealth tools in stealthCalls and preserve signature/reasoning on error invocations When a stealth tool errors, its name was not added to stealthCalls, causing shouldStopGeneration to evaluate as false. This led to an incorrect recursive Generate('normal') call instead of stopping generation as the stealth tool contract requires ('no follow-up generation'). Also preserve toolCall.signature and reasoningText on error invocations to match the success path, preventing Gemini/OpenRouter multi-turn tool context from breaking when a tool call fails. * Clarify method comments * fix: initialize error property in ToolInvocation to false * Apply review suggestions * Make options object required * fix: remove unnecessary return statement in updateSwipeCounter method * refactor: split tool call error handling into separate PR (#5351) --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

94139f465ea3a13c46fb2ac79f70fe8c3d4508e5

Xiangzhe <32761048+xz-dev@users.noreply.github.com>

Signed

public/script.js+19 -1 Viewed

+        }
+    }
 -    async onFinishStreaming(messageId, text) {
 +    /**
 +     * Finalizes an intermediary message after generation is complete, or a tool call is performed.
 +     * Performs essential message processing (code blocks, reasoning, swipes, attachments, events)
 +     * without the heavier finish operations (UI unlock - optional, auto-swipe, sound, save chat).
 +     * @param {number} messageId - The message ID to finalize.
 +     * @param {string} text - The message text.
 +     * @param {Object} options - Additional options for finalization.
 +     * @param {boolean} options.unlockUI - Whether to unlock the generation UI.
 +     */
 +    async finalizeIntermediaryMessage(messageId, text, { unlockUI = true }) {
         await this.onProgressStreaming(messageId, text, true);
         const messageElement = chatElement.find(`.mes[mesid="${messageId}"]`);
         const message = chat[messageId];

             message.extra.reasoning_signature = this.reasoningSignature;
+        }
 +        if (unlockUI) {
             this.markUIGenStopped();
 +        }
         if (this.type !== 'impersonate') {
             await eventSource.emit(event_types.MESSAGE_RECEIVED, this.messageId, this.type);

+        }
         updateSwipeCounter(messageId, { message, messageElement });
 +    }
++
 +    async onFinishStreaming(messageId, text) {
 +        await this.finalizeIntermediaryMessage(messageId, text, { unlockUI: true });
         const isAborted = this.abortController.signal.aborted;
         if (!isAborted && power_user.auto_swipe && generatedTextFiltered(text)) {

                 const hasToolCalls = ToolManager.hasToolCalls(streamingProcessor.toolCalls);
                 const shouldDeleteMessage = type !== 'swipe' && ['', '...'].includes(lastMessage?.mes) && !lastMessage?.extra?.reasoning && ['', '...'].includes(streamingProcessor?.result);
                 hasToolCalls && shouldDeleteMessage && await deleteLastMessage();
 +                if (hasToolCalls && !shouldDeleteMessage) {
 +                    await streamingProcessor.finalizeIntermediaryMessage(streamingProcessor.messageId, getMessage, { unlockUI: false });
 +                }
                 const invocationResult = await ToolManager.invokeFunctionTools(streamingProcessor.toolCalls, {
                     reasoningText: streamingProcessor.reasoningHandler.reasoning,
                 });