Fix auto-parsing of continue from reasoning Continues #3606

980ed76cc39b726407948d26bf8fb87d70cdf9c6

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

Parents: 91fe2841e3d65e8daca4fbaf207c3db040b4d984

public/script.js+7 -3 Viewed

             chat[messageId]['extra']['time_to_first_token'] = this.timeToFirstToken;
             // Update reasoning
             await this.reasoningHandler.process(messageId, mesChanged, this.promptReasoning);
             processedText = chat[messageId]['mes'];
             // Token count update.

@@ -5953,7 +5953,7 @@ export function cleanUpMessage(getMessage, isImpersonate, isContinue, displayInc
5953	5953	getMessage = trimToEndSentence(getMessage);
5954	5954	}
5955	5955
5956	5956	if (power_user.trim_spaces && !PromptReasoning.getLatestPrefix()) {
5957	5957	getMessage = getMessage.trim();
5958	5958	}
5959	5959

+    }
     const targetMessageId = messageId ?? chat.length - 1;
     if (chat.lengthtargetMessageId >= targetMessageIdchat.length || targetMessageId < 0) {
         console.warn(`[syncMesToSwipe] Invalid message ID: ${messageId}`);
         return false;
+    }
     const targetMessage = chat[targetMessageId];
 +    if (!targetMessage) {
 +        return false;
 +    }
++
     // No swipe data there yet, exit out
     if (typeof targetMessage.swipe_id !== 'number') {
         return false;

public/scripts/reasoning.js+75 -14 Viewed

      */
     initContinue(promptReasoning) {
         this.reasoning = promptReasoning.prefixReasoning;
         this.state = promptReasoning.prefixIncomplete ? ReasoningState.None : ReasoningState.Done;
         this.startTime = this.initialTime;
         this.endTime = promptReasoning.prefixDuration ? new Date(this.initialTime.getTime() + promptReasoning.prefixDuration) : null;
+    }

+     *
      * @param {number} messageId - The ID of the message to process
      * @param {boolean} mesChanged - Whether the message has changed
 +     * @param {PromptReasoning} promptReasoning - Prompt reasoning object
      * @returns {Promise<void>}
      */
     async process(messageId, mesChanged, promptReasoning) {
         mesChanged = this.#autoParseReasoningFromMessage(messageId, mesChanged, promptReasoning);
         if (!this.reasoning && !this.#isHiddenReasoningModel)
             return;

+        }
+    }
 -    #autoParseReasoningFromMessage(messageId, mesChanged) {
 +    /**
 +     * Parse reasoning from a message during streaming.
 +     * @param {number} messageId Message ID
 +     * @param {boolean} mesChanged Whether the message has changed before reasoning parsing
 +     * @param {PromptReasoning} promptReasoning Prompt reasoning object
 +     * @returns {boolean} Whether the message has changed after reasoning parsing
 +     */
 +    #autoParseReasoningFromMessage(messageId, mesChanged, promptReasoning) {
         if (!power_user.reasoning.auto_parse)
             return;
         if (!power_user.reasoning.prefix || !power_user.reasoning.suffix)

         const message = chat[messageId];
         if (!message) return mesChanged;
 +        const parseTarget = promptReasoning?.prefixIncomplete ? (promptReasoning.prefixReasoningFormatted + message.mes) : message.mes;
++
         // If we are done with reasoning parse, we just split the message correctly so the reasoning doesn't show up inside of it.
         if (this.#parsingReasoningMesStartIndex) {
             message.mes = trimSpaces(message.mesparseTarget.slice(this.#parsingReasoningMesStartIndex));
             return mesChanged;
+        }
         if (this.state === ReasoningState.None || this.#isHiddenReasoningModel) {
             // If streamed message starts with the opening, cut it out and put all inside reasoning
             if (message.mesparseTarget.startsWith(power_user.reasoning.prefix) && message.mesparseTarget.length > power_user.reasoning.prefix.length) {
                 this.#isParsingReasoning = true;
                 // Manually set starting state here, as we might already have received the ending suffix

             return mesChanged;
         // If we are in manual parsing mode, all currently streaming mes tokens will go the the reasoning block
 -        const originalMes = message.mes;
 +        this.reasoning = parseTarget.slice(power_user.reasoning.prefix.length);
 -        this.reasoning = originalMes.slice(power_user.reasoning.prefix.length);
         message.mes = '';
         // If the reasoning contains the ending suffix, we cut that off and continue as message streaming
         if (this.reasoning.includes(power_user.reasoning.suffix)) {
             this.reasoning = this.reasoning.slice(0, this.reasoning.indexOf(power_user.reasoning.suffix));
             this.#parsingReasoningMesStartIndex = originalMesparseTarget.indexOf(power_user.reasoning.suffix) + power_user.reasoning.suffix.length;
             message.mes = trimSpaces(originalMesparseTarget.slice(this.#parsingReasoningMesStartIndex));
             this.#isParsingReasoning = false;
+        }

  * Keeps track of the number of reasoning additions.
  */
 export class PromptReasoning {
 +    /**
 +     * An instance initiated during the latest prompt processing.
 +     * @type {PromptReasoning}
 +     * */
 +    static #LATEST = null;
 +    /**
 +     * @readonly Zero-width space character used as a placeholder for reasoning.
 +     * @type {string}
 +    */
     static REASONING_PLACEHOLDER = '\u200B';
 +    /**
 +     * Returns the latest formatted reasoning prefix if the prefix is incomplete.
 +     * @returns {string} Formatted reasoning prefix
 +     */
 +    static getLatestPrefix() {
 +        if (!PromptReasoning.#LATEST) {
 +            return '';
 +        }
++
 +        if (!PromptReasoning.#LATEST.prefixIncomplete) {
 +            return '';
 +        }
++
 +        return PromptReasoning.#LATEST.prefixReasoningFormatted;
 +    }
++
 +    /**
 +     * Free the latest reasoning instance.
 +     * To be called when the generation has ended or stopped.
 +     */
 +    static clearLatest() {
 +        PromptReasoning.#LATEST = null;
 +    }
++
     constructor() {
 +        PromptReasoning.#LATEST = this;
++
 +        /** @type {number} */
         this.counter = 0;
 +        /** @type {number} */
         this.prefixLength = -1;
 +        /** @type {string} */
         this.prefixReasoning = '';
 +        /** @type {string} */
 +        this.prefixReasoningFormatted = '';
 +        /** @type {number?} */
         this.prefixDuration = null;
 +        /** @type {boolean} */
 +        this.prefixIncomplete = false;
+    }
     /**

             const formattedReasoning = `${prefix}${reasoning}`;
             if (isPrefix) {
                 this.prefixReasoning = reasoning;
 +                this.prefixReasoningFormatted = formattedReasoning;
                 this.prefixLength = formattedReasoning.length;
                 this.prefixDuration = duration;
 +                this.prefixIncomplete = true;
+            }
             return formattedReasoning;
+        }

         const formattedReasoning = `${prefix}${reasoning}${suffix}${separator}`;
         if (isPrefix) {
             this.prefixReasoning = reasoning;
 +            this.prefixReasoningFormatted = formattedReasoning;
             this.prefixLength = formattedReasoning.length;
             this.prefixDuration = duration;
 +            this.prefixIncomplete = false;
+        }
         return `${formattedReasoning}${content}`;
+    }

+}
 function registerReasoningAppEvents() {
     const eventHandler = (/** @type {string} */ type, /** @type {number} */ idx) => {
         if (!power_user.reasoning.auto_parse) {
             return;
+        }
         console.debug('[Reasoning] Auto-parsing reasoning block for message', idx);
 +        const prefix = type === event_types.MESSAGE_RECEIVED ? PromptReasoning.getLatestPrefix() : '';
         const message = chat[idx];
         if (!message) {

@@ -1067,12 +1124,12 @@ function registerReasoningAppEvents() {
1067	1124	return null;
1068	1125	}
1069	1126
1070	1127	if (message.extra?.reasoning && !prefix) {
1071	1128	console.debug('[Reasoning] Message already has reasoning', idx);
1072	1129	return null;
1073	1130	}
1074	1131
1075	1132	const parsedReasoning = parseReasoningFromString(prefix + message.mes);
1076	1133
1077	1134	// No reasoning block found
1078	1135	if (!parsedReasoning) {

     };
     for (const event of [event_types.MESSAGE_RECEIVED, event_types.MESSAGE_UPDATED]) {
 -        eventSource.on(event, eventHandler);
 +        eventSource.on(event, (/** @type {number} */ idx) => eventHandler(event, idx));
 +    }
++
 +    for (const event of [event_types.GENERATION_STOPPED, event_types.GENERATION_ENDED, event_types.CHAT_CHANGED]) {
 +        eventSource.on(event, () => PromptReasoning.clearLatest());
+    }
+}