Merge pull request #3345 from SillyTavern/woo-yeah Better reasoning

3b8fd6f62f1afc410cb451acbe7e52dfc85724e1

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

Signed

Parents: abe240397d35d220820beac19d99d60580adb2ca 8b5e0df2d70b80d265a208cc021537c967e5a4d8

public/index.html+51 -6 Viewed

                                             </span>
                                         </div>
                                     </div>
-                                    <div class="range-block" data-source="makersuite,deepseek">
+                                    <div class="range-block" data-source="makersuite,deepseek,openrouter">
                                         <label for="openai_show_thoughts" class="checkbox_label widthFreeExpand">
                                             <input id="openai_show_thoughts" type="checkbox" />
                                             <span>
-                                                <span data-i18n="Show model thoughts">Show model thoughts</span>
+                                                <span data-i18n="Show model reasoning">Show model reasoning</span>
                                                 <i class="opacity50p fa-solid fa-circle-info" title="Gemini 2.0 Thinking / DeepSeek Reasoner"></i>
                                             </span>
                                         </label>

                             </div>
                         </div>
                         <div>
+                            <h4 class="standoutHeader">
+                                <span data-i18n="Reasoning">Reasoning</span>
+                            </h4>
+                            <div>
+                                <label class="checkbox_label" for="reasoning_add_to_prompts" title="Add existing reasoning blocks to prompts. To add a new reasoning block, use the message edit menu." data-i18n="[title]reasoning_add_to_prompts">
+                                    <input id="reasoning_add_to_prompts" type="checkbox" />
+                                    <small data-i18n="Add Reasoning to Prompts">
+                                        Add Reasoning to Prompts
+                                    </small>
+                                </label>
+                                <div class="flex-container">
+                                    <div class="flex1" title="Inserted before the reasoning content." data-i18n="[title]reasoning_prefix">
+                                        <small data-i18n="Prefix">Prefix</small>
+                                        <textarea id="reasoning_prefix" class="text_pole textarea_compact autoSetHeight"></textarea>
+                                    </div>
+                                    <div class="flex1" title="Inserted after the reasoning content." data-i18n="[title]reasoning_suffix">
+                                        <small data-i18n="Suffix">Suffix</small>
+                                        <textarea id="reasoning_suffix" class="text_pole textarea_compact autoSetHeight"></textarea>
+                                    </div>
+                                </div>
+                                <div class="flex-container">
+                                    <div class="flex1" title="Inserted between the reasoning and the message content." data-i18n="[title]reasoning_separator">
+                                        <small data-i18n="Separator">Separator</small>
+                                        <textarea id="reasoning_separator" class="text_pole textarea_compact autoSetHeight"></textarea>
+                                    </div>
+                                    <div class="flex1" title="Maximum number of reasoning blocks to be added per prompt, counting from the last message." data-i18n="[title]reasoning_max_additions">
+                                        <small data-i18n="Max Additions">Max Additions</small>
+                                        <input id="reasoning_max_additions" class="text_pole textarea_compact" type="number" min="0" max="999"></textarea>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                        <div>
                             <h4 class="standoutHeader" data-i18n="Miscellaneous">Miscellaneous</h4>
                             <div>
                                 <small>

                         <div class="mes_edit_buttons">
                             <div class="mes_edit_done menu_button  fa-solid fa-check" title="Confirm" data-i18n="[title]Confirm"></div>
                             <div class="mes_edit_copy menu_button  fa-solid fa-copy" title="Copy this message" data-i18n="[title]Copy this message"></div>
-                            <div class="mes_edit_delete menu_button  fa-solid fa-trash-can" title="Delete this message" data-i18n="[title]Delete this message">
+                            <div class="mes_edit_add_reasoning menu_button fa-solid fa-lightbulb" title="Add a reasoning block" data-i18n="[title]Add a reasoning block"></div>
-                            </div>
+                            <div class="mes_edit_delete menu_button  fa-solid fa-trash-can" title="Delete this message" data-i18n="[title]Delete this message"></div>
                             <div class="mes_edit_up menu_button  fa-solid fa-chevron-up " title="Move message up" data-i18n="[title]Move message up"></div>
-                            <div class="mes_edit_down menu_button  fa-solid fa-chevron-down" title="Move message down" data-i18n="[title]Move message down">
+                            <div class="mes_edit_down menu_button  fa-solid fa-chevron-down" title="Move message down" data-i18n="[title]Move message down"></div>
-                            </div>
                             <div class="mes_edit_cancel menu_button  fa-solid fa-xmark" title="Cancel" data-i18n="[title]Cancel"></div>
                         </div>
                     </div>
+                    <details class="mes_reasoning_details">
+                        <summary class="mes_reasoning_summary">
+                            <span data-i18n="Reasoning">Reasoning</span>
+                            <div class="mes_reasoning_actions">
+                                <div class="mes_reasoning_edit_done mes_button fa-solid fa-check" title="Confirm" data-i18n="[title]Confirmedit"></div>
+                                <div class="mes_reasoning_edit_cancel mes_button fa-solid fa-xmark" title="Cancel edit" data-i18n="[title]Cancel edit"></div>
+                                <div class="mes_reasoning_edit mes_button fa-solid fa-pencil" title="Edit reasoning" data-i18n="[title]Edit reasoning"></div>
+                                <div class="mes_reasoning_copy mes_button fa-solid fa-copy" title="Copy reasoning" data-i18n="[title]Copy reasoning"></div>
+                                <div class="mes_reasoning_delete mes_button fa-solid fa-trash-can" title="Remove reasoning" data-i18n="[title]Remove reasoning"></div>
+                            </div>
+                        </summary>
+                        <div class="mes_reasoning"></div>
+                    </details>
                     <div class="mes_text"></div>
                     <div class="mes_img_container">
                         <div class="mes_img_controls">

public/locales/fr-fr.json+1 -1 Viewed

     "enable_functions_desc_1": "Autorise l'utilisation",
     "enable_functions_desc_2": "outils de fonction",
     "enable_functions_desc_3": "Peut être utilisé par diverses extensions pour fournir des fonctionnalités supplémentaires.",
-    "Show model thoughts": "Afficher les pensées du modèle",
+    "Show model reasoning": "Afficher les pensées du modèle",
     "Display the model's internal thoughts in the response.": "Afficher les pensées internes du modèle dans la réponse.",
     "Confirm token parsing with": "Confirmer l'analyse des tokens avec",
     "openai_logit_bias_no_items": "Aucun élément",

public/locales/zh-cn.json+1 -1 Viewed

     "Use system prompt": "使用系统提示词",
     "Merges_all_system_messages_desc_1": "合并所有系统消息，直到第一条具有非系统角色的消息，然后通过",
     "Merges_all_system_messages_desc_2": "字段发送。",
-    "Show model thoughts": "展示思维链",
+    "Show model reasoning": "展示思维链",
     "Display the model's internal thoughts in the response.": "展示模型在回复时的内部思维链。",
     "Assistant Prefill": "AI预填",
     "Expand the editor": "展开编辑器",

public/locales/zh-tw.json+1 -1 Viewed

     "Forbid": "禁止",
     "Aphrodite only. Determines the order of samplers. Skew is always applied post-softmax, so it's not included here.": "僅限 Aphrodite 使用。決定採樣器的順序。偏移總是在 softmax 後應用，因此不包括在此。",
     "Aphrodite only. Determines the order of samplers.": "僅限 Aphrodite 使用。決定採樣器的順序。",
-    "Show model thoughts": "顯示模型思維鏈",
+    "Show model reasoning": "顯示模型思維鏈",
     "Display the model's internal thoughts in the response.": "在回應中顯示模型的思維鏈（內部思考過程）。",
     "Generic (OpenAI-compatible) [LM Studio, LiteLLM, etc.]": "通用（兼容 OpenAI）[LM Studio, LiteLLM 等]",
     "Model ID (optional)": "模型 ID（可選）",

public/script.js+100 -26 Viewed

 import { initBulkEdit } from './scripts/bulk-edit.js';
 import { deriveTemplatesFromChatTemplate } from './scripts/chat-templates.js';
 import { getContext } from './scripts/st-context.js';
+import { initReasoning, PromptReasoning } from './scripts/reasoning.js';
 // API OBJECT FOR EXTERNAL WIRING
 globalThis.SillyTavern = {

     initServerHistory();
     initSettingsSearch();
     initBulkEdit();
+    initReasoning();
     await initScrapers();
     doDailyExtensionUpdatesCheck();
     await hideLoader();

     isUser,
     avatarImg,
     bias,
+    reasoning,
     isSystem,
     title,
     timerValue,

     mes.find('.avatar img').attr('src', avatarImg);
     mes.find('.ch_name .name_text').text(characterName);
     mes.find('.mes_bias').html(bias);
+    mes.find('.mes_reasoning').html(reasoning);
     mes.find('.timestamp').text(timestamp).attr('title', `${extra?.api ? extra.api + ' - ' : ''}${extra?.model ?? ''}`);
     mes.find('.mesIDDisplay').text(`#${mesId}`);
     tokenCount && mes.find('.tokenCounterDisplay').text(`${tokenCount}t`);

     return mes;
+}
+/**
+ * Re-renders a message block with updated content.
+ * @param {number} messageId Message ID
+ * @param {object} message Message object
+ */
 export function updateMessageBlock(messageId, message) {
     const messageElement = $(`#chat [mesid="${messageId}"]`);
     const text = message?.extra?.display_text ?? message.mes;
     messageElement.find('.mes_text').html(messageFormatting(text, message.name, message.is_system, message.is_user, messageId));
+    messageElement.find('.mes_reasoning').html(messageFormatting(message.extra?.reasoning ?? '', '', false, false, -1));
     addCopyToCodeBlocks(messageElement);
     appendMediaToMessage(message, messageElement);
+}

         sanitizerOverrides,
     );
     const bias = messageFormatting(mes.extra?.bias ?? '', '', false, false, -1);
+    const reasoning = messageFormatting(mes.extra?.reasoning ?? '', '', false, false, -1);
     let bookmarkLink = mes?.extra?.bookmark_link ?? '';
     let params = {

         isUser: mes.is_user,
         avatarImg: avatarImg,
         bias: bias,
+        reasoning: reasoning,
         isSystem: isSystem,
         title: title,
         bookmarkLink: bookmarkLink,

         const swipeMessage = chatElement.find(`[mesid="${chat.length - 1}"]`);
         swipeMessage.attr('swipeid', params.swipeId);
         swipeMessage.find('.mes_text').html(messageText).attr('title', title);
+        swipeMessage.find('.mes_reasoning').html(reasoning);
         swipeMessage.find('.timestamp').text(timestamp).attr('title', `${params.extra.api} - ${params.extra.model}`);
         appendMediaToMessage(mes, swipeMessage);
         if (power_user.timestamp_model_icon && params.extra?.api) {

         this.messageTextDom = null;
         this.messageTimerDom = null;
         this.messageTokenCounterDom = null;
+        this.messageReasoningDom = null;
         /** @type {HTMLTextAreaElement} */
         this.sendTextarea = document.querySelector('#send_textarea');
         this.type = type;

         /** @type {import('./scripts/logprobs.js').TokenLogprobs[]} */
         this.messageLogprobs = [];
         this.toolCalls = [];
+        this.reasoning = '';
+    }
     #checkDomElements(messageId) {

@@ -3101,6 +3116,7 @@ class StreamingProcessor {
3101	this.messageTextDom = this.messageDom?.querySelector('.mes_text');	3116	this.messageTextDom = this.messageDom?.querySelector('.mes_text');
3102	this.messageTimerDom = this.messageDom?.querySelector('.mes_timer');	3117	this.messageTimerDom = this.messageDom?.querySelector('.mes_timer');
3103	this.messageTokenCounterDom = this.messageDom?.querySelector('.tokenCounterDisplay');	3118	this.messageTokenCounterDom = this.messageDom?.querySelector('.tokenCounterDisplay');
		3119	this.messageReasoningDom = this.messageDom?.querySelector('.mes_reasoning');
3104	}	3120	}
3105	}	3121	}
3106		3122

             this.#checkDomElements(messageId);
             this.#updateMessageBlockVisibility();
             const currentTime = new Date();
-            // Don't waste time calculating token count for streaming
-            const currentTokenCount = isFinal && power_user.message_token_count_enabled ? getTokenCount(processedText, 0) : 0;
-            const timePassed = formatGenerationTimer(this.timeStarted, currentTime, currentTokenCount);
             chat[messageId]['mes'] = processedText;
             chat[messageId]['gen_started'] = this.timeStarted;
             chat[messageId]['gen_finished'] = currentTime;
-            if (currentTokenCount) {
             if (!chat[messageId]['extra']) {
                 chat[messageId]['extra'] = {};
+            }
+            if (this.reasoning) {
+                chat[messageId]['extra']['reasoning'] = this.reasoning;
+                if (this.messageReasoningDom instanceof HTMLElement) {
+                    const formattedReasoning = messageFormatting(this.reasoning, '', false, false, -1);
+                    this.messageReasoningDom.innerHTML = formattedReasoning;
+                }
+            }
+            // Don't waste time calculating token count for streaming
+            const tokenCountText = (this.reasoning || '') + processedText;
+            const currentTokenCount = isFinal && power_user.message_token_count_enabled ? getTokenCount(tokenCountText, 0) : 0;
+            if (currentTokenCount) {
                 chat[messageId]['extra']['token_count'] = currentTokenCount;
                 if (this.messageTokenCounterDom instanceof HTMLElement) {
                     this.messageTokenCounterDom.textContent = `${currentTokenCount}t`;

@@ -3211,10 +3236,13 @@ class StreamingProcessor {
3211	if (this.messageTextDom instanceof HTMLElement) {	3236	if (this.messageTextDom instanceof HTMLElement) {
3212	this.messageTextDom.innerHTML = formattedText;	3237	this.messageTextDom.innerHTML = formattedText;
3213	}	3238	}
		3239
		3240	const timePassed = formatGenerationTimer(this.timeStarted, currentTime, currentTokenCount);
3214	if (this.messageTimerDom instanceof HTMLElement) {	3241	if (this.messageTimerDom instanceof HTMLElement) {
3215	this.messageTimerDom.textContent = timePassed.timerValue;	3242	this.messageTimerDom.textContent = timePassed.timerValue;
3216	this.messageTimerDom.title = timePassed.timerTitle;	3243	this.messageTimerDom.title = timePassed.timerTitle;
3217	}	3244	}
		3245
3218	this.setFirstSwipe(messageId);	3246	this.setFirstSwipe(messageId);
3219	}	3247	}
3220		3248

+    }
     /**
-     * @returns {Generator<{ text: string, swipes: string[], logprobs: import('./scripts/logprobs.js').TokenLogprobs, toolCalls: any[] }, void, void>}
+     * @returns {Generator<{ text: string, swipes: string[], logprobs: import('./scripts/logprobs.js').TokenLogprobs, toolCalls: any[], state: any }, void, void>}
      */
     *nullStreamingGeneration() {
         throw new Error('Generation function for streaming is not hooked up');

         try {
             const sw = new Stopwatch(1000 / power_user.streaming_fps);
             const timestamps = [];
-            for await (const { text, swipes, logprobs, toolCalls } of this.generator()) {
+            for await (const { text, swipes, logprobs, toolCalls, state } of this.generator()) {
                 timestamps.push(Date.now());
                 if (this.isStopped) {
                     return;

@@ -3355,6 +3383,7 @@ class StreamingProcessor {
3355	if (logprobs) {	3383	if (logprobs) {
3356	this.messageLogprobs.push(...(Array.isArray(logprobs) ? logprobs : [logprobs]));	3384	this.messageLogprobs.push(...(Array.isArray(logprobs) ? logprobs : [logprobs]));
3357	}	3385	}
		3386	this.reasoning = state?.reasoning ?? '';
3358	await eventSource.emit(event_types.STREAM_TOKEN_RECEIVED, text);	3387	await eventSource.emit(event_types.STREAM_TOKEN_RECEIVED, text);
3359	await sw.tick(() => this.onProgressStreaming(this.messageId, this.continueMessage + text));	3388	await sw.tick(() => this.onProgressStreaming(this.messageId, this.continueMessage + text));
3360	}	3389	}

         coreChat.pop();
+    }
+    const reasoning = new PromptReasoning();
+    for (let i = coreChat.length - 1; i >= 0; i--) {
+        if (reasoning.isLimitReached()) {
+            break;
+        }
+        coreChat[i] = { ...coreChat[i], mes: reasoning.addToMessage(coreChat[i].mes, coreChat[i].extra?.reasoning) };
+    }
     coreChat = await Promise.all(coreChat.map(async (chatItem, index) => {
         let message = chatItem.mes;
         let regexType = chatItem.is_user ? regex_placement.USER_INPUT : regex_placement.AI_OUTPUT;

         //const getData = await response.json();
         let getMessage = extractMessageFromData(data);
         let title = extractTitleFromData(data);
+        let reasoning = extractReasoningFromData(data);
         kobold_horde_model = title;
         const swipes = extractMultiSwipes(data, type);

@@ -4768,10 +4806,10 @@ export async function Generate(type, { automatic_trigger, force_name2, quiet_pro
4768	else {	4806	else {
4769	// Without streaming we'll be having a full message on continuation. Treat it as a last chunk.	4807	// Without streaming we'll be having a full message on continuation. Treat it as a last chunk.
4770	if (originalType !== 'continue') {	4808	if (originalType !== 'continue') {
4771	({ type, getMessage } = await saveReply(type, getMessage, false, title, swipes));	4809	({ type, getMessage } = await saveReply(type, getMessage, false, title, swipes, reasoning));
4772	}	4810	}
4773	else {	4811	else {
4774	({ type, getMessage } = await saveReply('appendFinal', getMessage, false, title, swipes));	4812	({ type, getMessage } = await saveReply('appendFinal', getMessage, false, title, swipes, reasoning));
4775	}	4813	}
4776		4814
4777	// This relies on `saveReply` having been called to add the message to the chat, so it must be last.	4815	// This relies on `saveReply` having been called to add the message to the chat, so it must be last.

         return data;
+    }
-    function getTextContext() {
     switch (main_api) {
         case 'kobold':
             return data.results[0].text;

+    }
+}
-    const content = getTextContext();
+/**
+ * Extracts the reasoning from the response data.
-    if (main_api === 'openai' && oai_settings.chat_completion_source === chat_completion_sources.DEEPSEEK && oai_settings.show_thoughts) {
+ * @param {object} data Response data
-        const thoughts = data?.choices?.[0]?.message?.reasoning_content ?? '';
+ * @returns {string} Extracted reasoning
-        return [thoughts, content].filter(x => x).join('\n\n');
+ */
+function extractReasoningFromData(data) {
+    if (main_api === 'openai' && oai_settings.show_thoughts) {
+        switch (oai_settings.chat_completion_source) {
+            case chat_completion_sources.DEEPSEEK:
+                return data?.choices?.[0]?.message?.reasoning_content ?? '';
+            case chat_completion_sources.OPENROUTER:
+                return data?.choices?.[0]?.message?.reasoning ?? '';
+            case chat_completion_sources.MAKERSUITE:
+                return data?.responseContent?.parts?.filter(part => part.thought)?.map(part => part.text)?.join('\n\n') ?? '';
+        }
+    }
-    return content;
+    return '';
+}
 /**

     return getMessage;
+}
-export async function saveReply(type, getMessage, fromStreaming, title, swipes) {
+export async function saveReply(type, getMessage, fromStreaming, title, swipes, reasoning) {
     if (type != 'append' && type != 'continue' && type != 'appendFinal' && chat.length && (chat[chat.length - 1]['swipe_id'] === undefined ||
         chat[chat.length - 1]['is_user'])) {
         type = 'normal';

             chat[chat.length - 1]['send_date'] = getMessageTimeStamp();
             chat[chat.length - 1]['extra']['api'] = getGeneratingApi();
             chat[chat.length - 1]['extra']['model'] = getGeneratingModel();
+            chat[chat.length - 1]['extra']['reasoning'] = reasoning;
             if (power_user.message_token_count_enabled) {
-                chat[chat.length - 1]['extra']['token_count'] = await getTokenCountAsync(chat[chat.length - 1]['mes'], 0);
+                const tokenCountText = (reasoning || '') + chat[chat.length - 1]['mes'];
+                chat[chat.length - 1]['extra']['token_count'] = await getTokenCountAsync(tokenCountText, 0);
+            }
             const chat_id = (chat.length - 1);
             await eventSource.emit(event_types.MESSAGE_RECEIVED, chat_id);

         chat[chat.length - 1]['send_date'] = getMessageTimeStamp();
         chat[chat.length - 1]['extra']['api'] = getGeneratingApi();
         chat[chat.length - 1]['extra']['model'] = getGeneratingModel();
+        chat[chat.length - 1]['extra']['reasoning'] += reasoning;
         if (power_user.message_token_count_enabled) {
-            chat[chat.length - 1]['extra']['token_count'] = await getTokenCountAsync(chat[chat.length - 1]['mes'], 0);
+            const tokenCountText = (reasoning || '') + chat[chat.length - 1]['mes'];
+            chat[chat.length - 1]['extra']['token_count'] = await getTokenCountAsync(tokenCountText, 0);
+        }
         const chat_id = (chat.length - 1);
         await eventSource.emit(event_types.MESSAGE_RECEIVED, chat_id);

         chat[chat.length - 1]['send_date'] = getMessageTimeStamp();
         chat[chat.length - 1]['extra']['api'] = getGeneratingApi();
         chat[chat.length - 1]['extra']['model'] = getGeneratingModel();
+        chat[chat.length - 1]['extra']['reasoning'] += reasoning;
         if (power_user.message_token_count_enabled) {
-            chat[chat.length - 1]['extra']['token_count'] = await getTokenCountAsync(chat[chat.length - 1]['mes'], 0);
+            const tokenCountText = (reasoning || '') + chat[chat.length - 1]['mes'];
+            chat[chat.length - 1]['extra']['token_count'] = await getTokenCountAsync(tokenCountText, 0);
+        }
         const chat_id = (chat.length - 1);
         await eventSource.emit(event_types.MESSAGE_RECEIVED, chat_id);

         chat[chat.length - 1]['send_date'] = getMessageTimeStamp();
         chat[chat.length - 1]['extra']['api'] = getGeneratingApi();
         chat[chat.length - 1]['extra']['model'] = getGeneratingModel();
+        chat[chat.length - 1]['extra']['reasoning'] = reasoning;
         if (power_user.trim_spaces) {
             getMessage = getMessage.trim();
+        }

         chat[chat.length - 1]['gen_finished'] = generationFinished;
         if (power_user.message_token_count_enabled) {
-            chat[chat.length - 1]['extra']['token_count'] = await getTokenCountAsync(chat[chat.length - 1]['mes'], 0);
+            const tokenCountText = (reasoning || '') + chat[chat.length - 1]['mes'];
+            chat[chat.length - 1]['extra']['token_count'] = await getTokenCountAsync(tokenCountText, 0);
+        }
         if (selected_group) {

+    }
+}
-function closeMessageEditor() {
+/**
+ * Closes the message editor.
+ * @param {'message'|'reasoning'|'all'} what What to close. Default is 'all'.
+ */
+export function closeMessageEditor(what = 'all') {
+    if (what === 'message' || what === 'all') {
         if (this_edit_mes_id) {
             $(`#chat .mes[mesid="${this_edit_mes_id}"] .mes_edit_cancel`).click();
+        }
+    }
+    if (what === 'reasoning' || what === 'all') {
+        document.querySelectorAll('.reasoning_edit_textarea').forEach((el) => {
+            const cancelButton = el.closest('.mes')?.querySelector('.mes_reasoning_edit_cancel');
+            if (cancelButton instanceof HTMLElement) {
+                cancelButton.click();
+            }
+        });
+    }
+}
 export function setGenerationProgress(progress) {
     if (!progress) {

@@ -8483,7 +8552,8 @@ function swipe_left() { // when we swipe left..but no generation.
8483	}	8552	}
8484		8553
8485	const swipeMessage = $('#chat').find(`[mesid="${chat.length - 1}"]`);	8554	const swipeMessage = $('#chat').find(`[mesid="${chat.length - 1}"]`);
8486	const tokenCount = await getTokenCountAsync(chat[chat.length - 1].mes, 0);	8555	const tokenCountText = (chat[chat.length - 1]?.extra?.reasoning \|\| '') + chat[chat.length - 1].mes;
		8556	const tokenCount = await getTokenCountAsync(tokenCountText, 0);
8487	chat[chat.length - 1]['extra']['token_count'] = tokenCount;	8557	chat[chat.length - 1]['extra']['token_count'] = tokenCount;
8488	swipeMessage.find('.tokenCounterDisplay').text(`${tokenCount}t`);	8558	swipeMessage.find('.tokenCounterDisplay').text(`${tokenCount}t`);
8489	}	8559	}

                     // resets the timer
                     swipeMessage.find('.mes_timer').html('');
                     swipeMessage.find('.tokenCounterDisplay').text('');
+                    swipeMessage.find('.mes_reasoning').html('');
                 } else {
                     //console.log('showing previously generated swipe candidate, or "..."');
                     //console.log('onclick right swipe calling addOneMessage');

@@ -8657,7 +8728,8 @@ const swipe_right = () => {
8657	chat[chat.length - 1].extra = {};	8728	chat[chat.length - 1].extra = {};
8658	}	8729	}
8659		8730
8660	const tokenCount = await getTokenCountAsync(chat[chat.length - 1].mes, 0);	8731	const tokenCountText = (chat[chat.length - 1]?.extra?.reasoning \|\| '') + chat[chat.length - 1].mes;
		8732	const tokenCount = await getTokenCountAsync(tokenCountText, 0);
8661	chat[chat.length - 1]['extra']['token_count'] = tokenCount;	8733	chat[chat.length - 1]['extra']['token_count'] = tokenCount;
8662	swipeMessage.find('.tokenCounterDisplay').text(`${tokenCount}t`);	8734	swipeMessage.find('.tokenCounterDisplay').text(`${tokenCount}t`);
8663	}	8735	}

@@ -9459,7 +9531,8 @@ function addDebugFunctions() {
9459	message.extra = {};	9531	message.extra = {};
9460	}	9532	}
9461		9533
9462	message.extra.token_count = await getTokenCountAsync(message.mes, 0);	9534	const tokenCountText = (message?.extra?.reasoning \|\| '') + message.mes;
		9535	message.extra.token_count = await getTokenCountAsync(tokenCountText, 0);
9463	}	9536	}
9464		9537
9465	await saveChatConditional();	9538	await saveChatConditional();

     $(document).keyup(function (e) {
         if (e.key === 'Escape') {
-            const isEditVisible = $('#curEditTextarea').is(':visible');
+            const isEditVisible = $('#curEditTextarea').is(':visible') || $('.reasoning_edit_textarea').length > 0;
             if (isEditVisible && power_user.auto_save_msg_edits === false) {
-                closeMessageEditor();
+                closeMessageEditor('all');
                 $('#send_textarea').focus();
                 return;
+            }
             if (isEditVisible && power_user.auto_save_msg_edits === true) {
                 $(`#chat .mes[mesid="${this_edit_mes_id}"] .mes_edit_done`).click();
+                closeMessageEditor('reasoning');
                 $('#send_textarea').focus();
                 return;
+            }

public/scripts/kai-settings.js+1 -1 Viewed

@@ -188,7 +188,7 @@ export async function generateKoboldWithStreaming(generate_data, signal) {
188	if (data?.token) {	188	if (data?.token) {
189	text += data.token;	189	text += data.token;
190	}	190	}
191	yield { text, swipes: [], toolCalls: [] };	191	yield { text, swipes: [], toolCalls: [], state: {} };
192	}	192	}
193	};	193	};
194	}	194	}

public/scripts/nai-settings.js+1 -1 Viewed

@@ -746,7 +746,7 @@ export async function generateNovelWithStreaming(generate_data, signal) {
746	text += data.token;	746	text += data.token;
747	}	747	}
748		748
749	yield { text, swipes: [], logprobs: parseNovelAILogprobs(data.logprobs), toolCalls: [] };	749	yield { text, swipes: [], logprobs: parseNovelAILogprobs(data.logprobs), toolCalls: [], state: {} };
750	}	750	}
751	};	751	};
752	}	752	}

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

             let text = '';
             const swipes = [];
             const toolCalls = [];
-            const state = {};
+            const state = { reasoning: '' };
             while (true) {
                 const { done, value } = await reader.read();
                 if (done) return;

@@ -2113,7 +2113,7 @@ async function sendOpenAIRequest(type, messages, signal) {
2113		2113
2114	ToolManager.parseToolCalls(toolCalls, parsed);	2114	ToolManager.parseToolCalls(toolCalls, parsed);
2115		2115
2116	yield { text, swipes: swipes, logprobs: parseChatCompletionLogprobs(parsed), toolCalls: toolCalls };	2116	yield { text, swipes: swipes, logprobs: parseChatCompletionLogprobs(parsed), toolCalls: toolCalls, state: state };
2117	}	2117	}
2118	};	2118	};
2119	}	2119	}

     if (oai_settings.chat_completion_source === chat_completion_sources.CLAUDE) {
         return data?.delta?.text || '';
     } else if (oai_settings.chat_completion_source === chat_completion_sources.MAKERSUITE) {
-        return data?.candidates?.[0]?.content?.parts?.filter(x => oai_settings.show_thoughts || !x.thought)?.map(x => x.text)?.filter(x => x)?.join('\n\n') || '';
+        if (oai_settings.show_thoughts) {
+            state.reasoning += (data?.candidates?.[0]?.content?.parts?.filter(x =>  x.thought)?.map(x => x.text)?.[0] || '');
+        }
+        return data?.candidates?.[0]?.content?.parts?.filter(x => !x.thought)?.map(x => x.text)?.[0] || '';
     } else if (oai_settings.chat_completion_source === chat_completion_sources.COHERE) {
         return data?.delta?.message?.content?.text || data?.delta?.message?.tool_plan || '';
     } else if (oai_settings.chat_completion_source === chat_completion_sources.DEEPSEEK) {
-        const hadThoughts = state.hadThoughts;
+        if (oai_settings.show_thoughts) {
-        const thoughts = data.choices?.filter(x => oai_settings.show_thoughts || !x?.delta?.reasoning_content)?.[0]?.delta?.reasoning_content || '';
+            state.reasoning += (data.choices?.filter(x => x?.delta?.reasoning_content)?.[0]?.delta?.reasoning_content || '');
-        const content = data.choices?.[0]?.delta?.content || '';
+        }
-        state.hadThoughts = !!thoughts;
+        return data.choices?.[0]?.delta?.content || '';
-        const separator = hadThoughts && !thoughts ? '\n\n' : '';
+    } else if (oai_settings.chat_completion_source === chat_completion_sources.OPENROUTER) {
-        return [thoughts, separator, content].filter(x => x).join('\n\n');
+        if (oai_settings.show_thoughts) {
+            state.reasoning += (data.choices?.filter(x => x?.delta?.reasoning)?.[0]?.delta?.reasoning || '');
+        }
+        return data.choices?.[0]?.delta?.content ?? data.choices?.[0]?.message?.content ?? data.choices?.[0]?.text ?? '';
     } else  {
         return data.choices?.[0]?.delta?.content ?? data.choices?.[0]?.message?.content ?? data.choices?.[0]?.text ?? '';
+    }

public/scripts/power-user.js+8 -0 Viewed

         content: 'Write {{char}}\'s next reply in a fictional chat between {{char}} and {{user}}.',
     },
+    reasoning: {
+        add_to_prompts: false,
+        prefix: '<think>\n',
+        suffix: '\n</think>',
+        separator: '\n\n',
+        max_additions: 1,
+    },
     personas: {},
     default_persona: null,
     persona_descriptions: {},

public/scripts/reasoning.js+297 -0 Viewed

+import { chat, closeMessageEditor, saveChatConditional, saveSettingsDebounced, substituteParams, updateMessageBlock } from '../script.js';
+import { t } from './i18n.js';
+import { MacrosParser } from './macros.js';
+import { Popup } from './popup.js';
+import { power_user } from './power-user.js';
+import { SlashCommand } from './slash-commands/SlashCommand.js';
+import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './slash-commands/SlashCommandArgument.js';
+import { commonEnumProviders } from './slash-commands/SlashCommandCommonEnumsProvider.js';
+import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
+import { copyText } from './utils.js';
+/**
+ * Gets a message from a jQuery element.
+ * @param {Element} element
+ * @returns {{messageId: number, message: object, messageBlock: JQuery<HTMLElement>}}
+ */
+function getMessageFromJquery(element) {
+    const messageBlock = $(element).closest('.mes');
+    const messageId = Number(messageBlock.attr('mesid'));
+    const message = chat[messageId];
+    return { messageId: messageId, message, messageBlock };
+}
+/**
+ * Helper class for adding reasoning to messages.
+ * Keeps track of the number of reasoning additions.
+ */
+export class PromptReasoning {
+    static REASONING_PLACEHOLDER = '\u200B';
+    static REASONING_PLACEHOLDER_REGEX = new RegExp(`${PromptReasoning.REASONING_PLACEHOLDER}$`);
+    constructor() {
+        this.counter = 0;
+    }
+    /**
+     * Checks if the limit of reasoning additions has been reached.
+     * @returns {boolean} True if the limit of reasoning additions has been reached, false otherwise.
+     */
+    isLimitReached() {
+        if (!power_user.reasoning.add_to_prompts) {
+            return true;
+        }
+        return this.counter >= power_user.reasoning.max_additions;
+    }
+    /**
+     * Add reasoning to a message according to the power user settings.
+     * @param {string} content Message content
+     * @param {string} reasoning Message reasoning
+     * @returns {string} Message content with reasoning
+     */
+    addToMessage(content, reasoning) {
+        // Disabled or reached limit of additions
+        if (!power_user.reasoning.add_to_prompts || this.counter >= power_user.reasoning.max_additions) {
+            return content;
+        }
+        // No reasoning provided or a placeholder
+        if (!reasoning || reasoning === PromptReasoning.REASONING_PLACEHOLDER) {
+            return content;
+        }
+        // Increment the counter
+        this.counter++;
+        // Substitute macros in variable parts
+        const prefix = substituteParams(power_user.reasoning.prefix || '');
+        const separator = substituteParams(power_user.reasoning.separator || '');
+        const suffix = substituteParams(power_user.reasoning.suffix || '');
+        // Combine parts with reasoning and content
+        return `${prefix}${reasoning}${suffix}${separator}${content}`;
+    }
+}
+function loadReasoningSettings() {
+    $('#reasoning_add_to_prompts').prop('checked', power_user.reasoning.add_to_prompts);
+    $('#reasoning_add_to_prompts').on('change', function () {
+        power_user.reasoning.add_to_prompts = !!$(this).prop('checked');
+        saveSettingsDebounced();
+    });
+    $('#reasoning_prefix').val(power_user.reasoning.prefix);
+    $('#reasoning_prefix').on('input', function () {
+        power_user.reasoning.prefix = String($(this).val());
+        saveSettingsDebounced();
+    });
+    $('#reasoning_suffix').val(power_user.reasoning.suffix);
+    $('#reasoning_suffix').on('input', function () {
+        power_user.reasoning.suffix = String($(this).val());
+        saveSettingsDebounced();
+    });
+    $('#reasoning_separator').val(power_user.reasoning.separator);
+    $('#reasoning_separator').on('input', function () {
+        power_user.reasoning.separator = String($(this).val());
+        saveSettingsDebounced();
+    });
+    $('#reasoning_max_additions').val(power_user.reasoning.max_additions);
+    $('#reasoning_max_additions').on('input', function () {
+        power_user.reasoning.max_additions = Number($(this).val());
+        saveSettingsDebounced();
+    });
+}
+function registerReasoningSlashCommands() {
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'reasoning-get',
+        returns: ARGUMENT_TYPE.STRING,
+        helpString: t`Get the contents of a reasoning block of a message. Returns an empty string if the message does not have a reasoning block.`,
+        unnamedArgumentList: [
+            SlashCommandArgument.fromProps({
+                description: 'Message ID. If not provided, the message ID of the last message is used.',
+                typeList: ARGUMENT_TYPE.NUMBER,
+                enumProvider: commonEnumProviders.messages(),
+            }),
+        ],
+        callback: (_args, value) => {
+            const messageId = !isNaN(Number(value)) ? Number(value) : chat.length - 1;
+            const message = chat[messageId];
+            const reasoning = String(message?.extra?.reasoning ?? '');
+            return reasoning.replace(PromptReasoning.REASONING_PLACEHOLDER_REGEX, '');
+        },
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'reasoning-set',
+        returns: ARGUMENT_TYPE.STRING,
+        helpString: t`Set the reasoning block of a message. Returns the reasoning block content.`,
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'at',
+                description: 'Message ID. If not provided, the message ID of the last message is used.',
+                typeList: ARGUMENT_TYPE.NUMBER,
+                enumProvider: commonEnumProviders.messages(),
+            }),
+        ],
+        unnamedArgumentList: [
+            SlashCommandArgument.fromProps({
+                description: 'Reasoning block content.',
+                typeList: ARGUMENT_TYPE.STRING,
+            }),
+        ],
+        callback: async (args, value) => {
+            const messageId = !isNaN(Number(args[0])) ? Number(args[0]) : chat.length - 1;
+            const message = chat[messageId];
+            if (!message?.extra) {
+                return '';
+            }
+            message.extra.reasoning = String(value ?? '');
+            await saveChatConditional();
+            closeMessageEditor('reasoning');
+            updateMessageBlock(messageId, message);
+            return message.extra.reasoning;
+        },
+    }));
+}
+function registerReasoningMacros() {
+    MacrosParser.registerMacro('reasoningPrefix', () => power_user.reasoning.prefix, t`Reasoning Prefix`);
+    MacrosParser.registerMacro('reasoningSuffix', () => power_user.reasoning.suffix, t`Reasoning Suffix`);
+    MacrosParser.registerMacro('reasoningSeparator', () => power_user.reasoning.separator, t`Reasoning Separator`);
+}
+function setReasoningEventHandlers(){
+    $(document).on('click', '.mes_reasoning_copy', (e) => {
+        e.stopPropagation();
+        e.preventDefault();
+    });
+    $(document).on('click', '.mes_reasoning_edit', function (e) {
+        e.stopPropagation();
+        e.preventDefault();
+        const { message, messageBlock } = getMessageFromJquery(this);
+        if (!message?.extra) {
+            return;
+        }
+        const reasoning = String(message?.extra?.reasoning ?? '');
+        const chatElement = document.getElementById('chat');
+        const textarea = document.createElement('textarea');
+        const reasoningBlock = messageBlock.find('.mes_reasoning');
+        textarea.classList.add('reasoning_edit_textarea');
+        textarea.value = reasoning.replace(PromptReasoning.REASONING_PLACEHOLDER_REGEX, '');
+        $(textarea).insertBefore(reasoningBlock);
+        if (!CSS.supports('field-sizing', 'content')) {
+            const resetHeight = function () {
+                const scrollTop = chatElement.scrollTop;
+                textarea.style.height = '0px';
+                textarea.style.height = `${textarea.scrollHeight}px`;
+                chatElement.scrollTop = scrollTop;
+            };
+            textarea.addEventListener('input', resetHeight);
+            resetHeight();
+        }
+        textarea.focus();
+        textarea.setSelectionRange(textarea.value.length, textarea.value.length);
+        const textareaRect = textarea.getBoundingClientRect();
+        const chatRect = chatElement.getBoundingClientRect();
+        // Scroll if textarea bottom is below visible area
+        if (textareaRect.bottom > chatRect.bottom) {
+            const scrollOffset = textareaRect.bottom - chatRect.bottom;
+            chatElement.scrollTop += scrollOffset;
+        }
+    });
+    $(document).on('click', '.mes_reasoning_edit_done', async function (e) {
+        e.stopPropagation();
+        e.preventDefault();
+        const { message, messageId, messageBlock } = getMessageFromJquery(this);
+        if (!message?.extra) {
+            return;
+        }
+        const textarea = messageBlock.find('.reasoning_edit_textarea');
+        const reasoning = String(textarea.val());
+        message.extra.reasoning = reasoning;
+        await saveChatConditional();
+        updateMessageBlock(messageId, message);
+        textarea.remove();
+    });
+    $(document).on('click', '.mes_reasoning_edit_cancel', function (e) {
+        e.stopPropagation();
+        e.preventDefault();
+        const { messageBlock } = getMessageFromJquery(this);
+        const textarea = messageBlock.find('.reasoning_edit_textarea');
+        textarea.remove();
+    });
+    $(document).on('click', '.mes_edit_add_reasoning', async function () {
+        const { message, messageId } = getMessageFromJquery(this);
+        if (!message?.extra) {
+            return;
+        }
+        if (message.extra.reasoning) {
+            toastr.info(t`Reasoning already exists.`, t`Edit Message`);
+            return;
+        }
+        message.extra.reasoning = PromptReasoning.REASONING_PLACEHOLDER;
+        await saveChatConditional();
+        closeMessageEditor();
+        updateMessageBlock(messageId, message);
+    });
+    $(document).on('click', '.mes_reasoning_delete', async function (e) {
+        e.stopPropagation();
+        e.preventDefault();
+        const confirm = await Popup.show.confirm(t`Are you sure you want to clear the reasoning?`, t`Visible message contents will stay intact.`);
+        if (!confirm) {
+            return;
+        }
+        const { message, messageId } = getMessageFromJquery(this);
+        if (!message?.extra) {
+            return;
+        }
+        message.extra.reasoning = '';
+        await saveChatConditional();
+        updateMessageBlock(messageId, message);
+    });
+    $(document).on('pointerup', '.mes_reasoning_copy', async function () {
+        const { message } = getMessageFromJquery(this);
+        const reasoning = String(message?.extra?.reasoning ?? '').replace(PromptReasoning.REASONING_PLACEHOLDER_REGEX, '');
+        if (!reasoning) {
+            return;
+        }
+        await copyText(reasoning);
+        toastr.info(t`Copied!`, '', { timeOut: 2000 });
+    });
+}
+export function initReasoning() {
+    loadReasoningSettings();
+    setReasoningEventHandlers();
+    registerReasoningSlashCommands();
+    registerReasoningMacros();
+}

public/scripts/sse-stream.js+15 -0 Viewed

+                }
                 return;
+            }
+            else if (typeof json.choices[0].delta.reasoning === 'string' && json.choices[0].delta.reasoning.length > 0) {
+                for (let j = 0; j < json.choices[0].delta.reasoning.length; j++) {
+                    const str = json.choices[0].delta.reasoning[j];
+                    const isLastSymbol = j === json.choices[0].delta.reasoning.length - 1;
+                    const choiceClone = structuredClone(json.choices[0]);
+                    choiceClone.delta.reasoning = str;
+                    choiceClone.delta.content = isLastSymbol ? choiceClone.delta.content : '';
+                    const choices = [choiceClone];
+                    yield {
+                        data: { ...json, choices },
+                        chunk: str,
+                    };
+                }
+                return;
+            }
             else if (typeof json.choices[0].delta.content === 'string' && json.choices[0].delta.content.length > 0) {
                 for (let j = 0; j < json.choices[0].delta.content.length; j++) {
                     const str = json.choices[0].delta.content[j];

public/scripts/st-context.js+4 -0 Viewed

 import {
     activateSendButtons,
     addOneMessage,
+    appendMediaToMessage,
     callPopup,
     characters,
     chat,

     substituteParamsExtended,
     this_chid,
     updateChatMetadata,
+    updateMessageBlock,
 } from '../script.js';
 import {
     extension_settings,

         getCharacters,
         uuidv4,
         humanizedDateTime,
+        updateMessageBlock,
+        appendMediaToMessage,
     };
+}

public/scripts/textgen-settings.js+2 -1 Viewed

         let logprobs = null;
         const swipes = [];
         const toolCalls = [];
+        const state = {};
         while (true) {
             const { done, value } = await reader.read();
             if (done) return;

@@ -1004,7 +1005,7 @@ export async function generateTextGenWithStreaming(generate_data, signal) {
1004	logprobs = parseTextgenLogprobs(newText, data.choices?.[0]?.logprobs \|\| data?.completion_probabilities);	1005	logprobs = parseTextgenLogprobs(newText, data.choices?.[0]?.logprobs \|\| data?.completion_probabilities);
1005	}	1006	}
1006		1007
1007	yield { text, swipes, logprobs, toolCalls };	1008	yield { text, swipes, logprobs, toolCalls, state };
1008	}	1009	}
1009	};	1010	};
1010	}	1011	}

public/style.css+106 -21 Viewed

     filter: grayscale(25%);
+}
-.mes_text table {
+.mes_text table,
+.mes_reasoning table {
     border-spacing: 0;
     border-collapse: collapse;
     margin-bottom: 10px;
+}
 .mes_text td,
-.mes_text th {
+.mes_text th,
+.mes_reasoning td,
+.mes_reasoning th {
     border: 1px solid;
     border-collapse: collapse;
     padding: 0.25em;
+}
-.mes_text p {
+.mes_text p,
+.mes_reasoning p {
     margin-top: 0;
     margin-bottom: 10px;
+}
-.mes_text li tt {
+.mes_text li tt,
+.mes_reasoning li tt {
     display: inline-block;
+}
 .mes_text ol,
-.mes_text ul {
+.mes_text ul,
+.mes_reasoning ol,
+.mes_reasoning ul {
     margin-top: 5px;
     margin-bottom: 5px;
+}
 .mes_text br,
-.mes_bias br {
+.mes_bias br,
+.mes_reasoning br {
     content: ' ';
+}

     color: var(--SmartThemeQuoteColor);
+}
+.mes_reasoning {
+    display: block;
+    border: 1px solid var(--SmartThemeBorderColor);
+    background-color: var(--black30a);
+    border-radius: 5px;
+    padding: 5px;
+    margin: 5px 0;
+    overflow-y: auto;
+}
+.mes_reasoning_summary {
+    cursor: pointer;
+    position: relative;
+    margin: 2px;
+}
+@supports not selector(:has(*)) {
+    .mes_reasoning_details {
+        display: none !important;
+    }
+}
+.mes_bias:empty,
+.mes_reasoning:empty,
+.mes_reasoning_details:has(.mes_reasoning:empty),
+.mes_block:has(.edit_textarea) .mes_reasoning_details,
+.mes_reasoning_details:not([open]) .mes_reasoning_actions,
+.mes_reasoning_details:has(.reasoning_edit_textarea) .mes_reasoning,
+.mes_reasoning_details:not(:has(.reasoning_edit_textarea)) .mes_reasoning_actions .mes_button.mes_reasoning_edit_done,
+.mes_reasoning_details:not(:has(.reasoning_edit_textarea)) .mes_reasoning_actions .mes_button.mes_reasoning_edit_cancel,
+.mes_reasoning_details:has(.reasoning_edit_textarea) .mes_reasoning_actions .mes_button:not(.mes_reasoning_edit_done, .mes_reasoning_edit_cancel) {
+    display: none;
+}
+.mes_reasoning_actions {
+    position: absolute;
+    right: 0;
+    top: 0;
+    display: flex;
+    gap: 4px;
+    flex-wrap: nowrap;
+    justify-content: flex-end;
+    transition: all 200ms;
+    overflow-x: hidden;
+    padding: 1px;
+}
+.mes_reasoning_summary>span {
+    margin-left: 0.5em;
+}
 .mes_text i,
-.mes_text em {
+.mes_text em,
+.mes_reasoning i,
+.mes_reasoning em {
     color: var(--SmartThemeEmColor);
+}
-.mes_text u {
+.mes_text u,
+.mes_reasoning u {
     color: var(--SmartThemeUnderlineColor);
+}
-.mes_text q {
+.mes_text q,
+.mes_reasoning q {
     color: var(--SmartThemeQuoteColor);
+}
 .mes_text font[color] em,
-.mes_text font[color] i {
+.mes_text font[color] i,
-    color: inherit;
+.mes_text font[color] u,
-}
+.mes_text font[color] q,
+.mes_reasoning font[color] em,
-.mes_text font[color] q {
+.mes_reasoning font[color] i,
+.mes_reasoning font[color] u,
+.mes_reasoning font[color] q {
     color: inherit;
+}

     display: block;
+}
-.mes_text blockquote {
+.mes_text blockquote,
+.mes_reasoning blockquote {
     border-left: 3px solid var(--SmartThemeQuoteColor);
     padding-left: 10px;
     background-color: var(--black30a);

 .mes_text strong em,
 .mes_text strong,
 .mes_text h2,
-.mes_text h1 {
+.mes_text h1,
+.mes_reasoning strong em,
+.mes_reasoning strong,
+.mes_reasoning h2,
+.mes_reasoning h1 {
     font-weight: bold;
+}
-.mes_text pre code {
+.mes_text pre code,
+.mes_reasoning pre code {
     position: relative;
     display: block;
     overflow-x: auto;
     padding: 1em;
+}
-.mes_text img:not(.mes_img) {
+.mes_text img:not(.mes_img),
+.mes_reasoning img:not(.mes_img) {
     max-width: 100%;
     max-height: var(--doc-height);
+}

@@ -1022,6 +1095,11 @@ body .panelControlBar {
1022	/only affects bubblechat to make it sit nicely at the bottom/	1095	/only affects bubblechat to make it sit nicely at the bottom/
1023	}	1096	}
1024		1097
		1098	.last_mes:has(.mes_text:empty):has(.mes_reasoning_details[open]) .mes_reasoning:not(:empty) {
		1099	margin-bottom: 30px;
		1100	}
		1101
		1102	.last_mes .mes_reasoning,
1025	.last_mes .mes_text {	1103	.last_mes .mes_text {
1026	padding-right: 30px;	1104	padding-right: 30px;
1027	}	1105	}

     overflow-y: clip;
+}
-.mes_text {
+.mes_text,
+.mes_reasoning {
     font-weight: 500;
     line-height: calc(var(--mainFontSize) + .5rem);
+    max-width: 100%;
+    overflow-wrap: anywhere;
+}
+.mes_text {
     padding-left: 0;
     padding-top: 5px;
     padding-bottom: 5px;
-    max-width: 100%;
-    overflow-wrap: anywhere;
+}
 br {

@@ -4150,10 +4232,12 @@ input[type="range"]::-webkit-slider-thumb {
4150	align-items: center;	4232	align-items: center;
4151	}	4233	}
4152		4234
		4235	.mes_reasoning_edit_cancel,
4153	.mes_edit_cancel.menu_button {	4236	.mes_edit_cancel.menu_button {
4154	background-color: var(--crimson70a);	4237	background-color: var(--crimson70a);
4155	}	4238	}
4156		4239
		4240	.mes_reasoning_edit_done,
4157	.mes_edit_done.menu_button {	4241	.mes_edit_done.menu_button {
4158	background-color: var(--okGreen70a);	4242	background-color: var(--okGreen70a);
4159	}	4243	}

     opacity: 1;
+}
+.reasoning_edit_textarea,
 .edit_textarea {
     padding: 5px;
     margin: 0;

src/endpoints/backends/chat-completions.js+13 -7 Viewed

     const model = String(request.body.model);
     const stream = Boolean(request.body.stream);
     const showThoughts = Boolean(request.body.show_thoughts);
+    const isThinking = model.includes('thinking');
     const generationConfig = {
         stopSequences: request.body.stop,

@@ -329,6 +330,12 @@ async function sendMakerSuiteRequest(request, response) {
329	body.systemInstruction = prompt.system_instruction;	330	body.systemInstruction = prompt.system_instruction;
330	}	331	}
331		332
		333	if (isThinking && showThoughts) {
		334	generationConfig.thinkingConfig = {
		335	includeThoughts: true,
		336	};
		337	}
		338
332	return body;	339	return body;
333	}	340	}
334		341

             controller.abort();
         });
-        const isThinking = model.includes('thinking');
         const apiVersion = isThinking ? 'v1alpha' : 'v1beta';
         const responseType = (stream ? 'streamGenerateContent' : 'generateContent');

             const responseContent = candidates[0].content ?? candidates[0].output;
             console.log('Google AI Studio response:', responseContent);
-            if (Array.isArray(responseContent?.parts) && isThinking && !showThoughts) {
+            const responseText = typeof responseContent === 'string' ? responseContent : responseContent?.parts?.filter(part => !part.thought)?.map(part => part.text)?.join('\n\n');
-                responseContent.parts = responseContent.parts.filter(part => !part.thought);
-            }
-            const responseText = typeof responseContent === 'string' ? responseContent : responseContent?.parts?.map(part => part.text)?.join('\n\n');
             if (!responseText) {
                 let message = 'Google AI Studio Candidate text empty';
                 console.log(message, generateResponseJson);

@@ -399,7 +401,7 @@ async function sendMakerSuiteRequest(request, response) {
399	}	401	}
400		402
401	// Wrap it back to OAI format	403	// Wrap it back to OAI format
402	const reply = { choices: [{ 'message': { 'content': responseText } }] };	404	const reply = { choices: [{ 'message': { 'content': responseText } }], responseContent };
403	return response.send(reply);	405	return response.send(reply);
404	}	406	}
405	} catch (error) {	407	} catch (error) {

             bodyParams['route'] = 'fallback';
+        }
+        if (request.body.show_thoughts) {
+            bodyParams['include_reasoning'] = true;
+        }
         let cachingAtDepth = getConfigValue('claude.cachingAtDepth', -1);
         if (Number.isInteger(cachingAtDepth) && cachingAtDepth >= 0 && request.body.model?.startsWith('anthropic/claude-3')) {
             cachingAtDepthForOpenRouterClaude(request.body.messages, cachingAtDepth);