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);
+            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	getMessage = trimToEndSentence(getMessage);	5953	getMessage = trimToEndSentence(getMessage);
5954	}	5954	}
5955		5955
5956	if (power_user.trim_spaces) {	5956	if (power_user.trim_spaces && !PromptReasoning.getLatestPrefix()) {
5957	getMessage = getMessage.trim();	5957	getMessage = getMessage.trim();
5958	}	5958	}
5959		5959

+    }
     const targetMessageId = messageId ?? chat.length - 1;
-    if (chat.length > targetMessageId || targetMessageId < 0) {
+    if (targetMessageId >= chat.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 = ReasoningState.Done;
+        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) {
+    async process(messageId, mesChanged, promptReasoning) {
-        mesChanged = this.#autoParseReasoningFromMessage(messageId, mesChanged);
+        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.mes.slice(this.#parsingReasoningMesStartIndex));
+            message.mes = trimSpaces(parseTarget.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.mes.startsWith(power_user.reasoning.prefix) && message.mes.length > power_user.reasoning.prefix.length) {
+            if (parseTarget.startsWith(power_user.reasoning.prefix) && parseTarget.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 = originalMes.indexOf(power_user.reasoning.suffix) + power_user.reasoning.suffix.length;
+            this.#parsingReasoningMesStartIndex = parseTarget.indexOf(power_user.reasoning.suffix) + power_user.reasoning.suffix.length;
-            message.mes = trimSpaces(originalMes.slice(this.#parsingReasoningMesStartIndex));
+            message.mes = trimSpaces(parseTarget.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 {number} */ idx) => {
+    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	return null;	1124	return null;
1068	}	1125	}
1069		1126
1070	if (message.extra?.reasoning) {	1127	if (message.extra?.reasoning && !prefix) {
1071	console.debug('[Reasoning] Message already has reasoning', idx);	1128	console.debug('[Reasoning] Message already has reasoning', idx);
1072	return null;	1129	return null;
1073	}	1130	}
1074		1131
1075	const parsedReasoning = parseReasoningFromString(message.mes);	1132	const parsedReasoning = parseReasoningFromString(prefix + message.mes);
1076		1133
1077	// No reasoning block found	1134	// No reasoning block found
1078	if (!parsedReasoning) {	1135	if (!parsedReasoning) {

@@ -1111,7 +1168,11 @@ function registerReasoningAppEvents() {
1111	};	1168	};
1112		1169
1113	for (const event of [event_types.MESSAGE_RECEIVED, event_types.MESSAGE_UPDATED]) {	1170	for (const event of [event_types.MESSAGE_RECEIVED, event_types.MESSAGE_UPDATED]) {
1114	eventSource.on(event, eventHandler);	1171	eventSource.on(event, (/** @type {number} */ idx) => eventHandler(event, idx));
		1172	}
		1173
		1174	for (const event of [event_types.GENERATION_STOPPED, event_types.GENERATION_ENDED, event_types.CHAT_CHANGED]) {
		1175	eventSource.on(event, () => PromptReasoning.clearLatest());
1115	}	1176	}
1116	}	1177	}
1117		1178