Merge branch 'staging' into support-multiple-expressions

25ffc4ac4ae9ac54e877c25266aeec1e4bb64d73

Wolfsblvt <wolfsblvt@gmail.com>

Parents: 5c30244627bd2184f9e126c1fc205e2e020ab0b3 72e1dcb3f9667cba0e512016f86eab172cc96469

.github/readme.md+1 -1 Viewed

 . Open your Command Line
 . Run the following command
-`docker create --name='sillytavern' --net='[DockerNet]' -p '8000:8000/tcp' -v '[plugins]':'/home/node/app/plugins':'rw' -v '[config]':'/home/node/app/config':'rw' -v '[data]':'/home/node/app/data':'rw' -v '[extensions]':'/home/node/app/public/scripts/extensions/third-party':'rw' 'ghcr.io/sillytavern/sillytavern:[version]'`
+`docker run --name='sillytavern' --net='[DockerNet]' -p '8000:8000/tcp' -v '[plugins]':'/home/node/app/plugins':'rw' -v '[config]':'/home/node/app/config':'rw' -v '[data]':'/home/node/app/data':'rw' -v '[extensions]':'/home/node/app/public/scripts/extensions/third-party':'rw' 'ghcr.io/sillytavern/sillytavern:[version]'`
 > Note that 8000 is a default listening port. Don't forget to use an appropriate port if you change it in the config.

public/css/toggle-dependent.css+5 -0 Viewed

     display: none;
+}
+label[for="trim_spaces"]:not(:has(input:checked)) small {
+    color: var(--warning);
+    opacity: 1;
+}
 #claude_function_prefill_warning {
     display: none;
     color: red;

public/index.html+70 -28 Viewed

                                                 <input type="checkbox" id="skip_special_tokens_textgenerationwebui" />
                                                 <small data-i18n="Skip Special Tokens">Skip Special Tokens</small>
                                             </label>
+                                            <label data-tg-type="openrouter" class="checkbox_label flexGrow flexShrink" for="include_reasoning_textgenerationwebui">
+                                                <input type="checkbox" id="include_reasoning_textgenerationwebui" />
+                                                <small data-i18n="Request Model Reasoning">Request Model Reasoning</small>
+                                            </label>
                                             <label data-tg-type="ooba, aphrodite, tabby" class="checkbox_label  flexGrow flexShrink" for="temperature_last_textgenerationwebui">
                                                 <input type="checkbox" id="temperature_last_textgenerationwebui" />
                                                 <label>

                                             </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="Request model reasoning">Request model reasoning</span>
                                                 <i class="opacity50p fa-solid fa-circle-info" title="Gemini 2.0 Thinking / DeepSeek Reasoner"></i>
                                             </span>
                                         </label>
                                         <div class="toggle-description justifyLeft marginBot5">
-                                            <span data-i18n="Display the model's internal thoughts in the response.">
+                                            <span data-i18n="Allows the model to return its thinking process.">
-                                                Display the model's internal thoughts in the response.
+                                                Allows the model to return its thinking process.
                                             </span>
                                         </div>
                                     </div>

                             <h4 data-i18n="Perplexity Model">Perplexity Model</h4>
                             <select id="model_perplexity_select">
                                 <optgroup label="Perplexity Sonar Models">
+                                    <option value="sonar">sonar</option>
+                                    <option value="sonar-pro">sonar-pro</option>
+                                    <option value="sonar-reasoning">sonar-reasoning</option>
+                                </optgroup>
+                                <optgroup label="Deprecated Models">
+                                    <!-- These are scheduled for deprecation after 2/22/2025 -->
                                     <option value="llama-3.1-sonar-small-128k-online">llama-3.1-sonar-small-128k-online</option>
                                     <option value="llama-3.1-sonar-large-128k-online">llama-3.1-sonar-large-128k-online</option>
                                     <option value="llama-3.1-sonar-huge-128k-online">llama-3.1-sonar-huge-128k-online</option>
-                                </optgroup>
+                                    <!-- These are not listed on the site anymore -->
-                                <optgroup label="Perplexity Chat Models">
                                     <option value="llama-3.1-sonar-small-128k-chat">llama-3.1-sonar-small-128k-chat</option>
                                     <option value="llama-3.1-sonar-large-128k-chat">llama-3.1-sonar-large-128k-chat</option>
                                 </optgroup>
-                                <optgroup label="Open-Source Models">
-                                    <option value="llama-3.1-8b-instruct">llama-3.1-8b-instruct</option>
-                                    <option value="llama-3.1-70b-instruct">llama-3.1-70b-instruct</option>
-                                </optgroup>
-                                <optgroup label="Deprecated Models">
-                                    <option value="llama-3-sonar-small-32k-chat">llama-3-sonar-small-32k-chat</option>
-                                    <option value="llama-3-sonar-small-32k-online">llama-3-sonar-small-32k-online</option>
-                                    <option value="llama-3-sonar-large-32k-chat">llama-3-sonar-large-32k-chat</option>
-                                    <option value="llama-3-sonar-large-32k-online">llama-3-sonar-large-32k-online</option>
-                                    <option value="sonar-small-chat">sonar-small-chat</option>
-                                    <option value="sonar-small-online">sonar-small-online</option>
-                                    <option value="sonar-medium-chat">sonar-medium-chat</option>
-                                    <option value="sonar-medium-online">sonar-medium-online</option>
-                                    <option value="llama-3-8b-instruct">llama-3-8b-instruct</option>
-                                    <option value="llama-3-70b-instruct">llama-3-70b-instruct</option>
-                                    <option value="mistral-7b-instruct">mistral-7b-instruct (v0.2)</option>
-                                    <option value="mixtral-8x7b-instruct">mixtral-8x7b-instruct</option>
-                                </optgroup>
                             </select>
                         </div>
                         <form id="cohere_form" data-source="cohere" action="javascript:void(null);" method="post" enctype="multipart/form-data">

                             </div>
                         </div>
                         <div>
+                            <h4 class="standoutHeader">
+                                <span data-i18n="Reasoning">Reasoning</span>
+                            </h4>
+                            <div>
+                                <label class="checkbox_label" for="reasoning_auto_parse" title="Automatically parse reasoning blocks from main content between the reasoning prefix/suffix. Both fields must be defined and non-empty." data-i18n="[title]reasoning_auto_parse">
+                                    <input id="reasoning_auto_parse" type="checkbox" />
+                                    <small data-i18n="Auto-Parse Reasoning">
+                                        Auto-Parse Reasoning
+                                    </small>
+                                </label>
+                                <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+2 -2 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",
+    "Request model reasoning": "Demander 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.",
+    "Allows the model to return its thinking process.": "Permet au modèle de retourner son processus de réflexion.",
     "Confirm token parsing with": "Confirmer l'analyse des tokens avec",
     "openai_logit_bias_no_items": "Aucun élément",
     "api_no_connection": "Pas de connection...",

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

     "Use system prompt": "使用系统提示词",
     "Merges_all_system_messages_desc_1": "合并所有系统消息，直到第一条具有非系统角色的消息，然后通过",
     "Merges_all_system_messages_desc_2": "字段发送。",
-    "Show model thoughts": "展示思维链",
+    "Request model reasoning": "请求思维链",
-    "Display the model's internal thoughts in the response.": "展示模型在回复时的内部思维链。",
+    "Allows the model to return its thinking process.": "允许模型返回其思维过程。",
     "Assistant Prefill": "AI预填",
     "Expand the editor": "展开编辑器",
     "Start Claude's answer with...": "以如下内容开始Claude的回答...",

public/locales/zh-tw.json+2 -2 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": "顯示模型思維鏈",
+    "Request model reasoning": "請求模型思維鏈",
-    "Display the model's internal thoughts in the response.": "在回應中顯示模型的思維鏈（內部思考過程）。",
+    "Allows the model to return its thinking process.": "讓模型回傳其思考過程。",
     "Generic (OpenAI-compatible) [LM Studio, LiteLLM, etc.]": "通用（兼容 OpenAI）[LM Studio, LiteLLM 等]",
     "Model ID (optional)": "模型 ID（可選）",
     "DeepSeek API Key": "DeepSeek API 金鑰",

public/script.js+186 -89 Viewed

     resetMovableStyles,
     forceCharacterEditorTokenize,
     applyPowerUserSettings,
+    generatedTextFiltered,
 } from './scripts/power-user.js';
 import {

     toggleDrawer,
     isElementInViewport,
     copyText,
+    escapeHtml,
 } from './scripts/utils.js';
 import { debounce_timeout } from './scripts/constants.js';

 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();

  * @param {boolean} isUser If the message was sent by the user
  * @param {number} messageId Message index in chat array
  * @param {object} [sanitizerOverrides] DOMPurify sanitizer option overrides
+ * @param {boolean} [isReasoning] If the message is reasoning output
  * @returns {string} HTML string
  */
-export function messageFormatting(mes, ch_name, isSystem, isUser, messageId, sanitizerOverrides = {}) {
+export function messageFormatting(mes, ch_name, isSystem, isUser, messageId, sanitizerOverrides = {}, isReasoning = false) {
     if (!mes) {
         return '';
+    }
-    if (Number(messageId) === 0 && !isSystem && !isUser) {
+    if (Number(messageId) === 0 && !isSystem && !isUser && !isReasoning) {
         const mesBeforeReplace = mes;
         const chatMessage = chat[messageId];
         mes = substituteParams(mes, undefined, ch_name);

     if (!isSystem) {
         function getRegexPlacement() {
             try {
+                if (isReasoning) {
+                    return regex_placement.REASONING;
+                }
                 if (isUser) {
                     return regex_placement.USER_INPUT;
                 } else if (chat[messageId]?.extra?.type === 'narrator') {

         mes = mes.replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+    }
+    // Make sure reasoning strings are always shown, even if they include "<" or ">"
+    [power_user.reasoning.prefix, power_user.reasoning.suffix].forEach((reasoningString) => {
+        if (!reasoningString || !reasoningString.trim().length) {
+            return;
+        }
+        // Only replace the first occurrence of the reasoning string
+        if (mes.includes(reasoningString)) {
+            mes = mes.replace(reasoningString, escapeHtml(reasoningString));
+        }
+    });
     if (!isSystem) {
         // Save double quotes in tags as a special character to prevent them from being encoded
         if (!power_user.encode_tags) {

     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_text').html(messageFormatting(text, message.name, message.is_system, message.is_user, messageId, {}, false));
+    messageElement.find('.mes_reasoning').html(messageFormatting(message.extra?.reasoning ?? '', '', false, false, messageId, {}, true));
     addCopyToCodeBlocks(messageElement);
     appendMediaToMessage(message, messageElement);
+}

         mes.is_user,
         chat.indexOf(mes),
         sanitizerOverrides,
+        false,
     );
-    const bias = messageFormatting(mes.extra?.bias ?? '', '', false, false, -1);
+    const bias = messageFormatting(mes.extra?.bias ?? '', '', false, false, -1, {}, false);
+    const reasoning = messageFormatting(mes.extra?.reasoning ?? '', '', false, false, chat.indexOf(mes), {}, true);
     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) {

         (main_api == 'openai' &&
             oai_settings.stream_openai &&
             !noStreamSources.includes(oai_settings.chat_completion_source) &&
-            !(oai_settings.chat_completion_source == chat_completion_sources.OPENAI && oai_settings.openai_model.startsWith('o1-')) &&
+            !(oai_settings.chat_completion_source == chat_completion_sources.OPENAI && (oai_settings.openai_model.startsWith('o1') || oai_settings.openai_model.startsWith('o3'))) &&
             !(oai_settings.chat_completion_source == chat_completion_sources.MAKERSUITE && oai_settings.google_model.includes('bison')))
         || (main_api == 'kobold' && kai_settings.streaming_kobold && kai_flags.can_use_streaming)
         || (main_api == 'novel' && nai_settings.streaming_novel)

         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 +3134,7 @@ class StreamingProcessor {
3101	this.messageTextDom = this.messageDom?.querySelector('.mes_text');	3134	this.messageTextDom = this.messageDom?.querySelector('.mes_text');
3102	this.messageTimerDom = this.messageDom?.querySelector('.mes_timer');	3135	this.messageTimerDom = this.messageDom?.querySelector('.mes_timer');
3103	this.messageTokenCounterDom = this.messageDom?.querySelector('.tokenCounterDisplay');	3136	this.messageTokenCounterDom = this.messageDom?.querySelector('.tokenCounterDisplay');
		3137	this.messageReasoningDom = this.messageDom?.querySelector('.mes_reasoning');
3104	}	3138	}
3105	}	3139	}
3106		3140

             this.sendTextarea.dispatchEvent(new Event('input', { bubbles: true }));
+        }
         else {
-            await saveReply(this.type, text, true);
+            await saveReply(this.type, text, true, '', [], '');
             messageId = chat.length - 1;
             this.#checkDomElements(messageId);
             this.showMessageButtons(messageId);

             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'] = power_user.trim_spaces ? this.reasoning.trim() : this.reasoning;
+                if (this.messageReasoningDom instanceof HTMLElement) {
+                    const formattedReasoning = messageFormatting(this.reasoning, '', false, false, messageId, {}, true);
+                    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`;

                 chat[messageId].is_system,
                 chat[messageId].is_user,
                 messageId,
+                {},
+                false,
             );
             if (this.messageTextDom instanceof HTMLElement) {
                 this.messageTextDom.innerHTML = formattedText;
+            }
+            const timePassed = formatGenerationTimer(this.timeStarted, currentTime, currentTokenCount);
             if (this.messageTimerDom instanceof HTMLElement) {
                 this.messageTimerDom.textContent = timePassed.timerValue;
                 this.messageTimerDom.title = timePassed.timerTitle;
+            }
             this.setFirstSwipe(messageId);
+        }

         unblockGeneration();
         generatedPromptCache = '';
-        //console.log("Generated text size:", text.length, text)
         const isAborted = this.abortController.signal.aborted;
-        if (power_user.auto_swipe && !isAborted) {
+        if (!isAborted && power_user.auto_swipe && generatedTextFiltered(text)) {
-            function containsBlacklistedWords(str, blacklist, threshold) {
+            return swipe_right();
-                const regex = new RegExp(`\\b(${blacklist.join('|')})\\b`, 'gi');
-                const matches = str.match(regex) || [];
-                return matches.length >= threshold;
-            }
-            const generatedTextFiltered = (text) => {
-                if (text) {
-                    if (power_user.auto_swipe_minimum_length) {
-                        if (text.length < power_user.auto_swipe_minimum_length && text.length !== 0) {
-                            console.log('Generated text size too small');
-                            return true;
-                        }
+        }
-                    if (power_user.auto_swipe_blacklist_threshold) {
-                        if (containsBlacklistedWords(text, power_user.auto_swipe_blacklist, power_user.auto_swipe_blacklist_threshold)) {
-                            console.log('Generated text has blacklisted words');
-                            return true;
-                        }
-                    }
-                }
-                return false;
-            };
-            if (generatedTextFiltered(text)) {
-                swipe_right();
-                return;
-            }
-        }
         playMessageSound();
+    }

+    }
     /**
-     * @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) {
+                if (this.isStopped || this.abortController.signal.aborted) {
                     return;
+                }

@@ -3355,6 +3375,7 @@ class StreamingProcessor {
3355	if (logprobs) {	3375	if (logprobs) {
3356	this.messageLogprobs.push(...(Array.isArray(logprobs) ? logprobs : [logprobs]));	3376	this.messageLogprobs.push(...(Array.isArray(logprobs) ? logprobs : [logprobs]));
3357	}	3377	}
		3378	this.reasoning = getRegexedString(state?.reasoning ?? '', regex_placement.REASONING);
3358	await eventSource.emit(event_types.STREAM_TOKEN_RECEIVED, text);	3379	await eventSource.emit(event_types.STREAM_TOKEN_RECEIVED, text);
3359	await sw.tick(() => this.onProgressStreaming(this.messageId, this.continueMessage + text));	3380	await sw.tick(() => this.onProgressStreaming(this.messageId, this.continueMessage + text));
3360	}	3381	}

         };
     }));
+    const reasoning = new PromptReasoning();
+    for (let i = coreChat.length - 1; i >= 0; i--) {
+        const depth = coreChat.length - i - 1;
+        const isPrefix = isContinue && i === coreChat.length - 1;
+        coreChat[i] = {
+            ...coreChat[i],
+            mes: reasoning.addToMessage(
+                coreChat[i].mes,
+                getRegexedString(
+                    String(coreChat[i].extra?.reasoning ?? ''),
+                    regex_placement.REASONING,
+                    { isPrompt: true, depth: depth },
+                ),
+                isPrefix,
+            ),
+        };
+        if (reasoning.isLimitReached()) {
+            break;
+        }
+    }
     // Determine token limit
     let this_max_context = getMaxContextSize();

         //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);
         messageChunk = cleanUpMessage(getMessage, isImpersonate, isContinue, false);
+        reasoning = getRegexedString(reasoning, regex_placement.REASONING);
+        if (power_user.trim_spaces) {
+            reasoning = reasoning.trim();
+        }
         if (isContinue) {
             getMessage = continue_mag + getMessage;

@@ -4768,10 +4816,10 @@ export async function Generate(type, { automatic_trigger, force_name2, quiet_pro
4768	else {	4816	else {
4769	// Without streaming we'll be having a full message on continuation. Treat it as a last chunk.	4817	// Without streaming we'll be having a full message on continuation. Treat it as a last chunk.
4770	if (originalType !== 'continue') {	4818	if (originalType !== 'continue') {
4771	({ type, getMessage } = await saveReply(type, getMessage, false, title, swipes));	4819	({ type, getMessage } = await saveReply(type, getMessage, false, title, swipes, reasoning));
4772	}	4820	}
4773	else {	4821	else {
4774	({ type, getMessage } = await saveReply('appendFinal', getMessage, false, title, swipes));	4822	({ type, getMessage } = await saveReply('appendFinal', getMessage, false, title, swipes, reasoning));
4775	}	4823	}
4776		4824
4777	// This relies on `saveReply` having been called to add the message to the chat, so it must be last.	4825	// This relies on `saveReply` having been called to add the message to the chat, so it must be last.

+        }
         const isAborted = abortController && abortController.signal.aborted;
-        if (power_user.auto_swipe && !isAborted) {
+        if (!isAborted && power_user.auto_swipe && generatedTextFiltered(getMessage)) {
-            console.debug('checking for autoswipeblacklist on non-streaming message');
-            function containsBlacklistedWords(getMessage, blacklist, threshold) {
-                console.debug('checking blacklisted words');
-                const regex = new RegExp(`\\b(${blacklist.join('|')})\\b`, 'gi');
-                const matches = getMessage.match(regex) || [];
-                return matches.length >= threshold;
-            }
-            const generatedTextFiltered = (getMessage) => {
-                if (power_user.auto_swipe_blacklist_threshold) {
-                    if (containsBlacklistedWords(getMessage, power_user.auto_swipe_blacklist, power_user.auto_swipe_blacklist_threshold)) {
-                        console.debug('Generated text has blacklisted words');
-                        return true;
-                    }
-                }
-                return false;
-            };
-            if (generatedTextFiltered(getMessage)) {
-                console.debug('swiping right automatically');
             is_send_press = false;
-                swipe_right();
+            return swipe_right();
-                // TODO: do we want to resolve after an auto-swipe?
-                return;
-            }
+        }
         console.debug('/api/chats/save called by /Generate');

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

+    }
+}
-    const content = getTextContext();
+/**
+ * Extracts the reasoning from the response data.
+ * @param {object} data Response data
+ * @returns {string} Extracted reasoning
+ */
+function extractReasoningFromData(data) {
+    switch (main_api) {
+        case 'textgenerationwebui':
+            switch (textgen_settings.type) {
+                case textgen_types.OPENROUTER:
+                    return data?.choices?.[0]?.reasoning ?? '';
+            }
+            break;
-    if (main_api === 'openai' && oai_settings.chat_completion_source === chat_completion_sources.DEEPSEEK && oai_settings.show_thoughts) {
+        case 'openai':
-        const thoughts = data?.choices?.[0]?.message?.reasoning_content ?? '';
+            if (!oai_settings.show_thoughts) break;
-        return [thoughts, content].filter(x => x).join('\n\n');
+            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') ?? '';
+            }
+            break;
+    }
-    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) {

     return { type, getMessage };
+}
+export function syncCurrentSwipeInfoExtras() {
+    if (!chat.length) {
+        return;
+    }
+    const currentMessage = chat[chat.length - 1];
+    if (currentMessage && Array.isArray(currentMessage.swipe_info) && typeof currentMessage.swipe_id === 'number') {
+        const swipeInfo = currentMessage.swipe_info[currentMessage.swipe_id];
+        if (swipeInfo && typeof swipeInfo === 'object') {
+            swipeInfo.extra = structuredClone(currentMessage.extra);
+        }
+    }
+}
 function saveImageToMessage(img, mes) {
     if (mes && img.image) {
         if (!mes.extra || typeof mes.extra !== 'object') {

         mes.is_system,
         mes.is_user,
         this_edit_mes_id,
+        {},
+        false,
     ));
     mesBlock.find('.mes_bias').empty();
-    mesBlock.find('.mes_bias').append(messageFormatting(bias, '', false, false, -1));
+    mesBlock.find('.mes_bias').append(messageFormatting(bias, '', false, false, -1, {}, false));
     saveChatDebounced();
+}

             mes.is_system,
             mes.is_user,
             this_edit_mes_id,
+            {},
+            false,
         ),
     );
     mesBlock.find('.mes_bias').empty();
-    mesBlock.find('.mes_bias').append(messageFormatting(bias, '', false, false, -1));
+    mesBlock.find('.mes_bias').append(messageFormatting(bias, '', false, false, -1, {}, false));
     appendMediaToMessage(mes, div.closest('.mes'));
     addCopyToCodeBlocks(div.closest('.mes'));

+    }
+}
-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) {

         streamingProcessor.onStopStreaming();
+    }
+    // Make sure ad-hoc changes to extras are saved before swiping away
+    syncCurrentSwipeInfoExtras();
     const swipe_duration = 120;
     const swipe_range = '700px';
     chat[chat.length - 1]['swipe_id']--;

@@ -8483,7 +8570,8 @@ function swipe_left() { // when we swipe left..but no generation.
8483	}	8570	}
8484		8571
8485	const swipeMessage = $('#chat').find(`[mesid="${chat.length - 1}"]`);	8572	const swipeMessage = $('#chat').find(`[mesid="${chat.length - 1}"]`);
8486	const tokenCount = await getTokenCountAsync(chat[chat.length - 1].mes, 0);	8573	const tokenCountText = (chat[chat.length - 1]?.extra?.reasoning \|\| '') + chat[chat.length - 1].mes;
		8574	const tokenCount = await getTokenCountAsync(tokenCountText, 0);
8487	chat[chat.length - 1]['extra']['token_count'] = tokenCount;	8575	chat[chat.length - 1]['extra']['token_count'] = tokenCount;
8488	swipeMessage.find('.tokenCounterDisplay').text(`${tokenCount}t`);	8576	swipeMessage.find('.tokenCounterDisplay').text(`${tokenCount}t`);
8489	}	8577	}

         return unblockGeneration();
+    }
+    // Make sure ad-hoc changes to extras are saved before swiping away
+    syncCurrentSwipeInfoExtras();
     const swipe_duration = 200;
     const swipe_range = 700;
     //console.log(swipe_range);

                     // 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 +8749,8 @@ const swipe_right = () => {
8657	chat[chat.length - 1].extra = {};	8749	chat[chat.length - 1].extra = {};
8658	}	8750	}
8659		8751
8660	const tokenCount = await getTokenCountAsync(chat[chat.length - 1].mes, 0);	8752	const tokenCountText = (chat[chat.length - 1]?.extra?.reasoning \|\| '') + chat[chat.length - 1].mes;
		8753	const tokenCount = await getTokenCountAsync(tokenCountText, 0);
8661	chat[chat.length - 1]['extra']['token_count'] = tokenCount;	8754	chat[chat.length - 1]['extra']['token_count'] = tokenCount;
8662	swipeMessage.find('.tokenCounterDisplay').text(`${tokenCount}t`);	8755	swipeMessage.find('.tokenCounterDisplay').text(`${tokenCount}t`);
8663	}	8756	}

@@ -9459,7 +9552,8 @@ function addDebugFunctions() {
9459	message.extra = {};	9552	message.extra = {};
9460	}	9553	}
9461		9554
9462	message.extra.token_count = await getTokenCountAsync(message.mes, 0);	9555	const tokenCountText = (message?.extra?.reasoning \|\| '') + message.mes;
		9556	message.extra.token_count = await getTokenCountAsync(tokenCountText, 0);
9463	}	9557	}
9464		9558
9465	await saveChatConditional();	9559	await saveChatConditional();

                 chat[this_edit_mes_id].is_system,
                 chat[this_edit_mes_id].is_user,
                 this_edit_mes_id,
+                {},
+                false,
             ));
         appendMediaToMessage(chat[this_edit_mes_id], $(this).closest('.mes'));
         addCopyToCodeBlocks($(this).closest('.mes'));

     $(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/authors-note.js+1 -1 Viewed

         namedArgumentList: [],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'position', [ARGUMENT_TYPE.STRING], false, false, null, ['system', 'user', 'assistant'],
+                'role', [ARGUMENT_TYPE.STRING], false, false, null, ['system', 'user', 'assistant'],
             ),
         ],
         helpString: `

public/scripts/backgrounds.js+19 -9 Viewed

     });
+}
+/**
+ * Locks the background for the current chat
+ * @param {Event} e Click event
+ * @returns {string} Empty string
+ */
 function onLockBackgroundClick(e) {
-    e.stopPropagation();
+    e?.stopPropagation();
     const chatName = getCurrentChatId();

         return '';
+    }
-    const relativeBgImage = getUrlParameter(this);
+    const relativeBgImage = getUrlParameter(this) ?? background_settings.url;
     saveBackgroundMetadata(relativeBgImage);
     setCustomBackground();

     return '';
+}
+/**
+ * Locks the background for the current chat
+ * @param {Event} e Click event
+ * @returns {string} Empty string
+ */
 function onUnlockBackgroundClick(e) {
-    e.stopPropagation();
+    e?.stopPropagation();
     removeBackgroundMetadata();
     unsetCustomBackground();
     highlightLockedBackground();

  */
 function setFittingClass(fitting) {
     const backgrounds = $('#bg1, #bg_custom');
-    backgrounds.toggleClass('cover', fitting === 'cover');
+    for (const option of ['cover', 'contain', 'stretch', 'center']) {
-    backgrounds.toggleClass('contain', fitting === 'contain');
+        backgrounds.toggleClass(option, option === fitting);
-    backgrounds.toggleClass('stretch', fitting === 'stretch');
+    }
-    backgrounds.toggleClass('center', fitting === 'center');
+    background_settings.fitting = fitting;
+}
 function onBackgroundFilterInput() {

     $('#add_bg_button').on('change', onBackgroundUploadSelected);
     $('#bg-filter').on('input', onBackgroundFilterInput);
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({ name: 'lockbg',
-        callback: onLockBackgroundClick,
+        callback: () => onLockBackgroundClick(new CustomEvent('click')),
         aliases: ['bglock'],
         helpString: 'Locks a background for the currently selected chat',
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({ name: 'unlockbg',
-        callback: onUnlockBackgroundClick,
+        callback: () => onUnlockBackgroundClick(new CustomEvent('click')),
         aliases: ['bgunlock'],
         helpString: 'Unlocks a background for the currently selected chat',
     }));

public/scripts/extensions/connection-manager/index.js+4 -0 Viewed

     'api-url',
     'model',
     'proxy',
+    'stop-strings',
 ];
 const TC_COMMANDS = [

     'context',
     'instruct-state',
     'tokenizer',
+    'stop-strings',
 ];
 const FANCY_NAMES = {

     'instruct': 'Instruct Template',
     'context': 'Context Template',
     'tokenizer': 'Tokenizer',
+    'stop-strings': 'Custom Stopping Strings',
 };
 /**

  * @property {string} [context] Context Template
  * @property {string} [instruct-state] Instruct Mode
  * @property {string} [tokenizer] Tokenizer
+ * @property {string} [stop-strings] Custom Stopping Strings
  * @property {string[]} [exclude] Commands to exclude
  */

public/scripts/extensions/quick-reply/src/SlashCommandHandler.js+4 -0 Viewed

+        }
+    }
     getQuickReply(args) {
+        if (!args.id && !args.label) {
+            toastr.error('Please provide a valid id or label.');
+            return '';
+        }
         try {
             return JSON.stringify(this.api.getQrByLabel(args.set, args.id !== undefined ? Number(args.id) : args.label));
         } catch (ex) {

public/scripts/extensions/regex/editor.html+6 -0 Viewed

                         <span data-i18n="World Info">World Info</span>
                     </label>
                 </div>
+                <div data-i18n="[title]ext_regex_reasoning_desc" title="Reasoning block contents. When 'Only Format Prompt' is checked, it will also affect the reasoning contents added to the prompt.">
+                    <label class="checkbox flex-container">
+                        <input type="checkbox" name="replace_position" value="6">
+                        <span data-i18n="Reasoning">Reasoning</span>
+                    </label>
+                </div>
                 <div class="flex-container wide100p marginTop5">
                     <div class="flex1 flex-container flexNoGap">
                         <small data-i18n="[title]ext_regex_min_depth_desc" title="When applied to prompts or display, only affect messages that are at least N levels deep. 0 = last message, 1 = penultimate message, etc. Only counts WI entries @Depth and usable messages, i.e. not hidden or system.">

public/scripts/extensions/regex/engine.js+2 -1 Viewed

     SLASH_COMMAND: 3,
     // 4 - sendAs (legacy)
     WORLD_INFO: 5,
+    REASONING: 6,
 };
 export const substitute_find_regex = {

             // Script applies to Generate and input is Generate
             (script.promptOnly && isPrompt) ||
             // Script applies to all cases when neither "only"s are true, but there's no need to do it when `isMarkdown`, the as source (chat history) should already be changed beforehand
-            (!script.markdownOnly && !script.promptOnly && !isMarkdown)
+            (!script.markdownOnly && !script.promptOnly && !isMarkdown && !isPrompt)
         ) {
             if (isEdit && !script.runOnEdit) {
                 console.debug(`getRegexedString: Skipping script ${script.scriptName} because it does not run on edit`);

public/scripts/extensions/regex/index.js+1 -1 Viewed

  * @property {string} replaceString - The replace string
  * @property {string[]} trimStrings - The trim strings
  * @property {string?} findRegex - The find regex
- * @property {string?} substituteRegex - The substitute regex
+ * @property {number?} substituteRegex - The substitute regex
  */
 /**

public/scripts/extensions/tts/alltalk.js+10 -6 Viewed

@@ -388,7 +388,7 @@ class AllTalkTtsProvider {
388	}	388	}
389		389
390	async fetchRvcVoiceObjects() {	390	async fetchRvcVoiceObjects() {
391	if (this.settings.server_version == 'v2') {	391	if (this.settings.server_version == 'v1') {
392	console.log('Skipping RVC voices fetch for V1 server');	392	console.log('Skipping RVC voices fetch for V1 server');
393	return [];	393	return [];
394	}	394	}

                 console.error('fetchTtsGeneration Error Response Text:', errorText);
                 throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
             const data = await response.json();
-            // Handle V1/V2 URL differences
+            // V1 returns a complete URL, V2 returns a relative path
-            const outputUrl = this.settings.server_version === 'v1'
+            if (this.settings.server_version === 'v1') {
-                ? data.output_file_url  // V1 returns full URL
+                // V1: Use the complete URL directly from the response
-                : `${this.settings.provider_endpoint}${data.output_file_url}`; // V2 returns relative path
+                return data.output_file_url;
+            } else {
+                // V2: Combine the endpoint with the relative path
+                return `${this.settings.provider_endpoint}${data.output_file_url}`;
+            }
-            return outputUrl;
         } catch (error) {
             console.error('[fetchTtsGeneration] Exception caught:', error);
             throw error;

public/scripts/extensions/tts/index.js+48 -5 Viewed

 import { GoogleTranslateTtsProvider } from './google-translate.js';
 const UPDATE_INTERVAL = 1000;
+const wrapper = new ModuleWorkerWrapper(moduleWorker);
 let voiceMapEntries = [];
 let voiceMap = {}; // {charName:voiceid, charName2:voiceid2}

@@ -118,7 +119,7 @@ async function onNarrateOneMessage() {
118	}	119	}
119		120
120	resetTtsPlayback();	121	resetTtsPlayback();
121	ttsJobQueue.push(message);	122	processAndQueueTtsMessage(message);
122	moduleWorker();	123	moduleWorker();
123	}	124	}
124		125

+    }
     resetTtsPlayback();
-    ttsJobQueue.push({ mes: text, name: name });
+    processAndQueueTtsMessage({ mes: text, name: name });
     await moduleWorker();
     // Return back to the chat voices

     return processing;
+}
+/**
+ * Splits a message into lines and adds each non-empty line to the TTS job queue.
+ * @param {Object} message - The message object to be processed.
+ * @param {string} message.mes - The text of the message to be split into lines.
+ * @param {string} message.name - The name associated with the message.
+ * @returns {void}
+ */
+function processAndQueueTtsMessage(message) {
+    if (!extension_settings.tts.narrate_by_paragraphs) {
+        ttsJobQueue.push(message);
+        return;
+    }
+    const lines = message.mes.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.length === 0) {
+            continue;
+        }
+        ttsJobQueue.push(
+            Object.assign({}, message, {
+                mes: line,
+            }),
+        );
+    }
+}
 function debugTtsPlayback() {
     console.log(JSON.stringify(
+        {

@@ -326,7 +357,7 @@ function onAudioControlClicked() {
326	resetTtsPlayback();	357	resetTtsPlayback();
327	} else {	358	} else {
328	// Default play behavior if not processing or playing is to play the last message.	359	// Default play behavior if not processing or playing is to play the last message.
329	ttsJobQueue.push(context.chat[context.chat.length - 1]);	360	processAndQueueTtsMessage(context.chat[context.chat.length - 1]);
330	}	361	}
331	updateUiAudioPlayState();	362	updateUiAudioPlayState();
332	}	363	}

     audioQueueProcessorReady = true;
     currentAudioJob = null;
     // updateUiPlayState();
+    wrapper.update();
+}
 /**

@@ -440,7 +472,7 @@ async function processTtsQueue() {
440	}	472	}
441		473
442	if (extension_settings.tts.skip_tags) {	474	if (extension_settings.tts.skip_tags) {
443	text = text.replace(/<.?>.?<\/.*?>/g, '').trim();	475	text = text.replace(/<.?>[\s\S]?<\/.*?>/g, '').trim();
444	}	476	}
445		477
446	if (!extension_settings.tts.pass_asterisks) {	478	if (!extension_settings.tts.pass_asterisks) {

     $('#tts_narrate_quoted').prop('checked', extension_settings.tts.narrate_quoted_only);
     $('#tts_auto_generation').prop('checked', extension_settings.tts.auto_generation);
     $('#tts_periodic_auto_generation').prop('checked', extension_settings.tts.periodic_auto_generation);
+    $('#tts_narrate_by_paragraphs').prop('checked', extension_settings.tts.narrate_by_paragraphs);
     $('#tts_narrate_translated_only').prop('checked', extension_settings.tts.narrate_translated_only);
     $('#tts_narrate_user').prop('checked', extension_settings.tts.narrate_user);
     $('#tts_pass_asterisks').prop('checked', extension_settings.tts.pass_asterisks);

     saveSettingsDebounced();
+}
+function onNarrateByParagraphsClick() {
+    extension_settings.tts.narrate_by_paragraphs = !!$('#tts_narrate_by_paragraphs').prop('checked');
+    saveSettingsDebounced();
+}
 function onNarrateDialoguesClick() {
     extension_settings.tts.narrate_dialogues_only = !!$('#tts_narrate_dialogues').prop('checked');

     lastChatId = context.chatId;
     console.debug(`Adding message from ${message.name} for TTS processing: "${message.mes}"`);
+    if (extension_settings.tts.periodic_auto_generation) {
         ttsJobQueue.push(message);
+    } else {
+        processAndQueueTtsMessage(message);
+    }
+}
 async function onMessageDeleted() {

         $('#tts_pass_asterisks').on('click', onPassAsterisksClick);
         $('#tts_auto_generation').on('click', onAutoGenerationClick);
         $('#tts_periodic_auto_generation').on('click', onPeriodicAutoGenerationClick);
+        $('#tts_narrate_by_paragraphs').on('click', onNarrateByParagraphsClick);
         $('#tts_narrate_user').on('click', onNarrateUserClick);
         $('#playback_rate').on('input', function () {

     loadSettings(); // Depends on Extension Controls and loadTtsProvider
     loadTtsProvider(extension_settings.tts.currentProvider); // No dependencies
     addAudioControl(); // Depends on Extension Controls
-    const wrapper = new ModuleWorkerWrapper(moduleWorker);
     setInterval(wrapper.update.bind(wrapper), UPDATE_INTERVAL); // Init depends on all the things
     eventSource.on(event_types.MESSAGE_SWIPED, resetTtsPlayback);
     eventSource.on(event_types.CHAT_CHANGED, onChatChanged);

public/scripts/extensions/tts/settings.html+4 -0 Viewed

                     <input type="checkbox" id="tts_periodic_auto_generation">
                     <small data-i18n="Narrate by paragraphs (when streaming)">Narrate by paragraphs (when streaming)</small>
                 </label>
+                <label class="checkbox_label" for="tts_narrate_by_paragraphs">
+                    <input type="checkbox" id="tts_narrate_by_paragraphs">
+                    <small data-i18n="Narrate by paragraphs (when not streaming)">Narrate by paragraphs (when not streaming)</small>
+                </label>
                 <label class="checkbox_label" for="tts_narrate_quoted">
                     <input type="checkbox" id="tts_narrate_quoted">
                     <small data-i18n="Only narrate quotes">Only narrate "quotes"</small>

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/loader.js+27 -6 Viewed

+    }
     return new Promise((resolve) => {
-        // Spinner blurs/fades out
+        const spinner = $('#load-spinner');
-        $('#load-spinner').on('transitionend webkitTransitionEnd oTransitionEnd MSTransitionEnd', function () {
+        if (!spinner.length) {
+            console.warn('Spinner element not found, skipping animation');
+            cleanup();
+            return;
+        }
+        // Check if transitions are enabled
+        const transitionDuration = spinner[0] ? getComputedStyle(spinner[0]).transitionDuration : '0s';
+        const hasTransitions = parseFloat(transitionDuration) > 0;
+        if (hasTransitions) {
+            Promise.race([
+                new Promise((r) => setTimeout(r, 500)), // Fallback timeout
+                new Promise((r) => spinner.one('transitionend webkitTransitionEnd oTransitionEnd MSTransitionEnd', r)),
+            ]).finally(cleanup);
+        } else {
+            cleanup();
+        }
+        function cleanup() {
             $('#loader').remove();
             // Yoink preloader entirely; it only exists to cover up unstyled content while loading JS
             // If it's present, we remove it once and then it's gone.
             yoinkPreloader();
-            loaderPopup.complete(POPUP_RESULT.AFFIRMATIVE).then(() => {
+            loaderPopup.complete(POPUP_RESULT.AFFIRMATIVE)
+                .catch((err) => console.error('Error completing loaderPopup:', err))
+                .finally(() => {
                     loaderPopup = null;
                     resolve();
                 });
-        });
+        }
-        $('#load-spinner')
+        // Apply the styles
-            .css({
+        spinner.css({
             'filter': 'blur(15px)',
             'opacity': '0',
         });

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+31 -34 Viewed

     ai21_model: 'jamba-1.5-large',
     mistralai_model: 'mistral-large-latest',
     cohere_model: 'command-r-plus',
-    perplexity_model: 'llama-3.1-70b-instruct',
+    perplexity_model: 'sonar-pro',
     groq_model: 'llama-3.1-70b-versatile',
     nanogpt_model: 'gpt-4o-mini',
     zerooneai_model: 'yi-large',

     names_behavior: character_names_behavior.DEFAULT,
     continue_postfix: continue_postfix_types.SPACE,
     custom_prompt_post_processing: custom_prompt_post_processing_types.NONE,
-    show_thoughts: false,
+    show_thoughts: true,
     seed: -1,
     n: 1,
 };

     ai21_model: 'jamba-1.5-large',
     mistralai_model: 'mistral-large-latest',
     cohere_model: 'command-r-plus',
-    perplexity_model: 'llama-3.1-70b-instruct',
+    perplexity_model: 'sonar-pro',
     groq_model: 'llama-3.1-70b-versatile',
     nanogpt_model: 'gpt-4o-mini',
     zerooneai_model: 'yi-large',

     names_behavior: character_names_behavior.DEFAULT,
     continue_postfix: continue_postfix_types.SPACE,
     custom_prompt_post_processing: custom_prompt_post_processing_types.NONE,
-    show_thoughts: false,
+    show_thoughts: true,
     seed: -1,
     n: 1,
 };

         // Unordered prompts without marker
         { role: 'system', content: impersonationPrompt, identifier: 'impersonate' },
         { role: 'system', content: quietPrompt, identifier: 'quietPrompt' },
-        { role: 'system', content: bias, identifier: 'bias' },
         { role: 'system', content: groupNudge, identifier: 'groupNudge' },
+        { role: 'assistant', content: bias, identifier: 'bias' },
     ];
     // Tavern Extras - Summary

     const isQuiet = type === 'quiet';
     const isImpersonate = type === 'impersonate';
     const isContinue = type === 'continue';
-    const stream = oai_settings.stream_openai && !isQuiet && !isScale && !(isGoogle && oai_settings.google_model.includes('bison')) && !(isOAI && oai_settings.openai_model.startsWith('o1-'));
+    const stream = oai_settings.stream_openai && !isQuiet && !isScale && !(isGoogle && oai_settings.google_model.includes('bison')) && !(isOAI && (oai_settings.openai_model.startsWith('o1') || oai_settings.openai_model.startsWith('o3')));
     const useLogprobs = !!power_user.request_token_probabilities;
     const canMultiSwipe = oai_settings.n > 1 && !isContinue && !isImpersonate && !isQuiet && (isOAI || isCustom);

         'user_name': name1,
         'char_name': name2,
         'group_names': getGroupNames(),
-        'show_thoughts': Boolean(oai_settings.show_thoughts),
+        'include_reasoning': Boolean(oai_settings.show_thoughts),
     };
     // Empty array will produce a validation error

         await ToolManager.registerFunctionToolsOpenAI(generate_data);
+    }
-    if (isOAI && oai_settings.openai_model.startsWith('o1-')) {
+    if (isOAI && (oai_settings.openai_model.startsWith('o1') || oai_settings.openai_model.startsWith('o3'))) {
         generate_data.messages.forEach((msg) => {
             if (msg.role === 'system') {
                 msg.role = 'user';

             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 ?? '';
+    }

@@ -4021,7 +4027,7 @@ function getMaxContextOpenAI(value) {
4021	if (oai_settings.max_context_unlocked) {	4027	if (oai_settings.max_context_unlocked) {
4022	return unlocked_max;	4028	return unlocked_max;
4023	}	4029	}
4024	else if (value.startsWith('o1-')) {	4030	else if (value.startsWith('o1') \|\| value.startsWith('o3')) {
4025	return max_128k;	4031	return max_128k;
4026	}	4032	}
4027	else if (value.includes('chatgpt-4o-latest') \|\| value.includes('gpt-4-turbo') \|\| value.includes('gpt-4o') \|\| value.includes('gpt-4-1106') \|\| value.includes('gpt-4-0125') \|\| value.includes('gpt-4-vision')) {	4033	else if (value.includes('chatgpt-4o-latest') \|\| value.includes('gpt-4-turbo') \|\| value.includes('gpt-4o') \|\| value.includes('gpt-4-1106') \|\| value.includes('gpt-4-0125') \|\| value.includes('gpt-4-vision')) {

         if (oai_settings.max_context_unlocked) {
             $('#openai_max_context').attr('max', unlocked_max);
+        }
+        else if (['sonar', 'sonar-reasoning'].includes(oai_settings.perplexity_model)) {
+            $('#openai_max_context').attr('max', 127000);
+        }
+        else if (['sonar-pro'].includes(oai_settings.perplexity_model)) {
+            $('#openai_max_context').attr('max', 200000);
+        }
         else if (oai_settings.perplexity_model.includes('llama-3.1')) {
             const isOnline = oai_settings.perplexity_model.includes('online');
             const contextSize = isOnline ? 128 * 1024 - 4000 : 128 * 1024;
             $('#openai_max_context').attr('max', contextSize);
+        }
-        else if (['llama-3-sonar-small-32k-chat', 'llama-3-sonar-large-32k-chat'].includes(oai_settings.perplexity_model)) {
-            $('#openai_max_context').attr('max', max_32k);
-        }
-        else if (['llama-3-sonar-small-32k-online', 'llama-3-sonar-large-32k-online'].includes(oai_settings.perplexity_model)) {
-            $('#openai_max_context').attr('max', 28000);
-        }
-        else if (['sonar-small-chat', 'sonar-medium-chat', 'codellama-70b-instruct', 'mistral-7b-instruct', 'mixtral-8x7b-instruct', 'mixtral-8x22b-instruct'].includes(oai_settings.perplexity_model)) {
-            $('#openai_max_context').attr('max', max_16k);
-        }
-        else if (['llama-3-8b-instruct', 'llama-3-70b-instruct'].includes(oai_settings.perplexity_model)) {
-            $('#openai_max_context').attr('max', max_8k);
-        }
-        else if (['sonar-small-online', 'sonar-medium-online'].includes(oai_settings.perplexity_model)) {
-            $('#openai_max_context').attr('max', 12000);
-        }
         else {
-            $('#openai_max_context').attr('max', max_4k);
+            $('#openai_max_context').attr('max', max_128k);
+        }
         oai_settings.openai_max_context = Math.min(Number($('#openai_max_context').attr('max')), oai_settings.openai_max_context);
         $('#openai_max_context').val(oai_settings.openai_max_context).trigger('input');

public/scripts/power-user.js+92 -2 Viewed

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

+}
 /**
+ * Checks if the generated text should be filtered based on the auto-swipe settings.
+ * @param {string} text The text to check
+ * @returns {boolean} If the generated text should be filtered
+ */
+export function generatedTextFiltered(text) {
+    /**
+     * Checks if the given text contains any of the blacklisted words.
+     * @param {string} text The text to check
+     * @param {string[]} blacklist The list of blacklisted words
+     * @param {number} threshold The number of blacklisted words that need to be present to trigger the check
+     * @returns {boolean} Whether the text contains blacklisted words
+     */
+    function containsBlacklistedWords(text, blacklist, threshold) {
+        const regex = new RegExp(`\\b(${blacklist.join('|')})\\b`, 'gi');
+        const matches = text.match(regex) || [];
+        return matches.length >= threshold;
+    }
+    // Make sure a generated text is non-empty
+    // Otherwise we might get in a loop with a broken API
+    text = text.trim();
+    if (text.length > 0) {
+        if (power_user.auto_swipe_minimum_length) {
+            if (text.length < power_user.auto_swipe_minimum_length) {
+                console.log('Generated text size too small');
+                return true;
+            }
+        }
+        if (power_user.auto_swipe_blacklist.length && power_user.auto_swipe_blacklist_threshold) {
+            if (containsBlacklistedWords(text, power_user.auto_swipe_blacklist, power_user.auto_swipe_blacklist_threshold)) {
+                console.log('Generated text has blacklisted words');
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
  * Gets the custom stopping strings from the power user settings.
  * @param {number | undefined} limit Number of strings to return. If 0 or undefined, returns all strings.
  * @returns {string[]} An array of custom stopping strings

         helpString: 'Start a new chat with a random character. If an argument is provided, only considers characters that have the specified tag.',
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
-        name: 'delmode',
+        name: 'del',
         callback: doDelMode,
-        aliases: ['del'],
+        aliases: ['delete', 'delmode'],
         unnamedArgumentList: [
             new SlashCommandArgument(
                 'optional number', [ARGUMENT_TYPE.NUMBER], false,

         ],
         helpString: 'activates a movingUI preset by name',
     }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'stop-strings',
+        aliases: ['stopping-strings', 'custom-stopping-strings', 'custom-stop-strings'],
+        helpString: `
+            <div>
+                Sets a list of custom stopping strings. Gets the list if no value is provided.
+            </div>
+            <div>
+                <strong>Examples:</strong>
+            </div>
+            <ul>
+                <li>Value must be a JSON-serialized array: <pre><code class="language-stscript">/stop-strings ["goodbye", "farewell"]</code></pre></li>
+                <li>Pipe characters must be escaped with a backslash: <pre><code class="language-stscript">/stop-strings ["left\\|right"]</code></pre></li>
+            </ul>
+        `,
+        returns: ARGUMENT_TYPE.LIST,
+        unnamedArgumentList: [
+            SlashCommandArgument.fromProps({
+                description: 'list of strings',
+                typeList: [ARGUMENT_TYPE.LIST],
+                acceptsMultiple: false,
+                isRequired: false,
+            }),
+        ],
+        callback: (_, value) => {
+            if (String(value ?? '').trim()) {
+                const parsedValue = ((x) => { try { return JSON.parse(x.toString()); } catch { return null; } })(value);
+                if (!parsedValue || !Array.isArray(parsedValue)) {
+                    throw new Error('Invalid list format. The value must be a JSON-serialized array of strings.');
+                }
+                parsedValue.forEach((item, index) => {
+                    parsedValue[index] = String(item);
+                });
+                power_user.custom_stopping_strings = JSON.stringify(parsedValue);
+                $('#custom_stopping_strings').val(power_user.custom_stopping_strings);
+                saveSettingsDebounced();
+            }
+            return power_user.custom_stopping_strings;
+        },
+    }));
 });

public/scripts/preset-manager.js+1 -0 Viewed

             'tabby_model',
             'derived',
             'generic_model',
+            'include_reasoning',
         ];
         const settings = Object.assign({}, getSettingsByApiId(this.apiId));

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

+import { chat, closeMessageEditor, event_types, eventSource, saveChatConditional, saveSettingsDebounced, substituteParams, updateMessageBlock } from '../script.js';
+import { getRegexedString, regex_placement } from './extensions/regex/engine.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, escapeRegex, isFalseBoolean } 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
+     * @param {boolean} isPrefix Whether this is the last message prefix
+     * @returns {string} Message content with reasoning
+     */
+    addToMessage(content, reasoning, isPrefix) {
+        // Disabled or reached limit of additions
+        if (!isPrefix && (!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 only
+        if (isPrefix && !content) {
+            return `${prefix}${reasoning}`;
+        }
+        // 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();
+    });
+    $('#reasoning_auto_parse').prop('checked', power_user.reasoning.auto_parse);
+    $('#reasoning_auto_parse').on('change', function () {
+        power_user.reasoning.auto_parse = !!$(this).prop('checked');
+        saveSettingsDebounced();
+    });
+}
+function registerReasoningSlashCommands() {
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'reasoning-get',
+        aliases: ['get-reasoning'],
+        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',
+        aliases: ['set-reasoning'],
+        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.at)) ? Number(args.at) : 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;
+        },
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'reasoning-parse',
+        aliases: ['parse-reasoning'],
+        returns: 'reasoning string',
+        helpString: t`Extracts the reasoning block from a string using the Reasoning Formatting settings.`,
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'regex',
+                description: 'Whether to apply regex scripts to the reasoning content.',
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'true',
+                isRequired: false,
+                enumProvider: commonEnumProviders.boolean('trueFalse'),
+            }),
+        ],
+        unnamedArgumentList: [
+            SlashCommandArgument.fromProps({
+                description: 'input string',
+                typeList: [ARGUMENT_TYPE.STRING],
+            }),
+        ],
+        callback: (args, value) => {
+            if (!value) {
+                return '';
+            }
+            if (!power_user.reasoning.prefix || !power_user.reasoning.suffix) {
+                toastr.warning(t`Both prefix and suffix must be set in the Reasoning Formatting settings.`);
+                return String(value);
+            }
+            const parsedReasoning = parseReasoningFromString(String(value));
+            if (!parsedReasoning) {
+                return '';
+            }
+            const applyRegex = !isFalseBoolean(String(args.regex ?? ''));
+            return applyRegex
+                ? getRegexedString(parsedReasoning.reasoning, regex_placement.REASONING)
+                : parsedReasoning.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 = getRegexedString(String(textarea.val()), regex_placement.REASONING, { isEdit: true });
+        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 });
+    });
+}
+/**
+ * Parses reasoning from a string using the power user reasoning settings.
+ * @typedef {Object} ParsedReasoning
+ * @property {string} reasoning Reasoning block
+ * @property {string} content Message content
+ * @param {string} str Content of the message
+ * @returns {ParsedReasoning|null} Parsed reasoning block and message content
+ */
+function parseReasoningFromString(str) {
+    // Both prefix and suffix must be defined
+    if (!power_user.reasoning.prefix || !power_user.reasoning.suffix) {
+        return null;
+    }
+    try {
+        const regex = new RegExp(`${escapeRegex(power_user.reasoning.prefix)}(.*?)${escapeRegex(power_user.reasoning.suffix)}`, 's');
+        let didReplace = false;
+        let reasoning = '';
+        let content = String(str).replace(regex, (_match, captureGroup) => {
+            didReplace = true;
+            reasoning = captureGroup;
+            return '';
+        });
+        if (didReplace && power_user.trim_spaces) {
+            reasoning = reasoning.trim();
+            content = content.trim();
+        }
+        return { reasoning, content };
+    } catch (error) {
+        console.error('[Reasoning] Error parsing reasoning block', error);
+        return null;
+    }
+}
+function registerReasoningAppEvents() {
+    eventSource.makeFirst(event_types.MESSAGE_RECEIVED, (/** @type {number} */ idx) => {
+        if (!power_user.reasoning.auto_parse) {
+            return;
+        }
+        console.debug('[Reasoning] Auto-parsing reasoning block for message', idx);
+        const message = chat[idx];
+        if (!message) {
+            console.warn('[Reasoning] Message not found', idx);
+            return null;
+        }
+        if (!message.mes || message.mes === '...') {
+            console.debug('[Reasoning] Message content is empty or a placeholder', idx);
+            return null;
+        }
+        const parsedReasoning = parseReasoningFromString(message.mes);
+        // No reasoning block found
+        if (!parsedReasoning) {
+            return;
+        }
+        // Make sure the message has an extra object
+        if (!message.extra || typeof message.extra !== 'object') {
+            message.extra = {};
+        }
+        const contentUpdated = !!parsedReasoning.reasoning || parsedReasoning.content !== message.mes;
+        // If reasoning was found, add it to the message
+        if (parsedReasoning.reasoning) {
+            message.extra.reasoning = getRegexedString(parsedReasoning.reasoning, regex_placement.REASONING);
+        }
+        // Update the message text if it was changed
+        if (parsedReasoning.content !== message.mes) {
+            message.mes = parsedReasoning.content;
+        }
+        // Find if a message already exists in DOM and must be updated
+        if (contentUpdated) {
+            const messageRendered = document.querySelector(`.mes[mesid="${idx}"]`) !== null;
+            if (messageRendered) {
+                console.debug('[Reasoning] Updating message block', idx);
+                updateMessageBlock(idx, message);
+            }
+        }
+    });
+}
+export function initReasoning() {
+    loadReasoningSettings();
+    setReasoningEventHandlers();
+    registerReasoningSlashCommands();
+    registerReasoningMacros();
+    registerReasoningAppEvents();
+}

public/scripts/slash-commands.js+68 -33 Viewed

     showMoreMessages,
     stopGeneration,
     substituteParams,
+    syncCurrentSwipeInfoExtras,
     system_avatar,
     system_message_types,
     this_chid,

 import { addEphemeralStoppingString, chat_styles, flushEphemeralStoppingStrings, power_user } from './power-user.js';
 import { SERVER_INPUTS, textgen_types, textgenerationwebui_settings } from './textgen-settings.js';
 import { decodeTextTokens, getAvailableTokenizers, getFriendlyTokenizerName, getTextTokens, getTokenCountAsync, selectTokenizer } from './tokenizers.js';
-import { debounce, delay, equalsIgnoreCaseAndAccents, findChar, getCharIndex, isFalseBoolean, isTrueBoolean, onlyUnique, showFontAwesomePicker, stringToRange, trimToEndSentence, trimToStartSentence, waitUntilCondition } from './utils.js';
+import { debounce, delay, equalsIgnoreCaseAndAccents, findChar, getCharIndex, isFalseBoolean, isTrueBoolean, onlyUnique, regexFromString, showFontAwesomePicker, stringToRange, trimToEndSentence, trimToStartSentence, waitUntilCondition } from './utils.js';
 import { registerVariableCommands, resolveVariable } from './variables.js';
 import { background_settings } from './backgrounds.js';
 import { SlashCommandClosure } from './slash-commands/SlashCommandClosure.js';

         returns: 'uppercase string',
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'string', [ARGUMENT_TYPE.STRING], true, false,
+                'text to affect', [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
         helpString: 'Converts the provided string to uppercase.',

         returns: 'lowercase string',
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'string', [ARGUMENT_TYPE.STRING], true, false,
+                'text to affect', [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
         helpString: 'Converts the provided string to lowercase.',

         ],
         unnamedArgumentList: [
             new SlashCommandArgument(
-                'string', [ARGUMENT_TYPE.STRING], true, false,
+                'text to affect', [ARGUMENT_TYPE.STRING], true, false,
             ),
         ],
         helpString: `

             return '';
         },
     }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'replace',
+        aliases: ['re'],
+        callback: (async ({ mode = 'literal', pattern, replacer = '' }, text) => {
+            if (pattern === '')
+                throw new Error('Argument of \'pattern=\' cannot be empty');
+            switch (mode) {
+                case 'literal':
+                    return text.replaceAll(pattern, replacer);
+                case 'regex':
+                    return text.replace(regexFromString(pattern), replacer);
+                default:
+                    throw new Error('Invalid \'/replace mode=\' argument specified!');
+            }
+        }),
+        returns: 'replaced text',
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'mode',
+                description: 'Replaces occurrence(s) of a pattern',
+                typeList: [ARGUMENT_TYPE.STRING],
+                defaultValue: 'literal',
+                enumList: ['literal', 'regex'],
+            }),
+            new SlashCommandNamedArgument(
+                'pattern', 'pattern to search with', [ARGUMENT_TYPE.STRING], true, false,
+            ),
+            new SlashCommandNamedArgument(
+                'replacer', 'replacement text for matches', [ARGUMENT_TYPE.STRING], false, false, '',
+            ),
+        ],
+        unnamedArgumentList: [
+            new SlashCommandArgument(
+                'text to affect', [ARGUMENT_TYPE.STRING], true, false,
+            ),
+        ],
+        helpString: `
+            <div>
+                Replaces text within the provided string based on the pattern.
+            </div>
+            <div>
+                If <code>mode</code> is <code>literal</code> (or omitted), <code>pattern</code> is a literal search string (case-sensitive).<br />
+                If <code>mode</code> is <code>regex</code>, <code>pattern</code> is parsed as an ECMAScript Regular Expression.<br />
+                The <code>replacer</code> replaces based on the <code>pattern</code> in the input text.<br />
+                If <code>replacer</code> is omitted, the replacement(s) will be an empty string.<br />
+            </div>
+            <div>
+                <strong>Example:</strong>
+                <pre>/let x Blue house and blue car ||                                                                        </pre>
+                <pre>/replace pattern="blue" {{var::x}}                                | /echo  |/# Blue house and  car     ||</pre>
+                <pre>/replace pattern="blue" replacer="red" {{var::x}}                 | /echo  |/# Blue house and red car  ||</pre>
+                <pre>/replace mode=regex pattern="/blue/i" replacer="red" {{var::x}}   | /echo  |/# red house and blue car  ||</pre>
+                <pre>/replace mode=regex pattern="/blue/gi" replacer="red" {{var::x}}  | /echo  |/# red house and red car   ||</pre>
+            </div>
+        `,
+    }));
     registerVariableCommands();
+}

     const newSwipeId = lastMessage.swipes.length - 1;
     if (isTrueBoolean(args.switch)) {
+        // Make sure ad-hoc changes to extras are saved before swiping away
+        syncCurrentSwipeInfoExtras();
         lastMessage.swipe_id = newSwipeId;
         lastMessage.mes = lastMessage.swipes[newSwipeId];
+        lastMessage.extra = structuredClone(lastMessage.swipe_info?.[newSwipeId]?.extra ?? lastMessage.extra ?? {});
+    }
     await saveChatConditional();

         return '';
+    }
-    if (is_group_generating) {
-        toastr.warning('Cannot run /memberremove command while the group reply is generating.');
-        return '';
-    }
     const chid = findGroupMemberId(arg);
     if (chid === undefined) {

+}
 async function sendUserMessageCallback(args, text) {
-    if (!text) {
+    text = String(text ?? '').trim();
-        toastr.warning('You must specify text to send');
-        return;
-    }
-    text = text.trim();
     const compact = isTrueBoolean(args?.compact);
     const bias = extractMessageBias(text);

+}
 export async function sendMessageAs(args, text) {
-    if (!text) {
-        toastr.warning('You must specify text to send as');
-        return '';
-    }
     let name = args.name?.trim();
-    let mesText;
     if (!name) {
         const namelessWarningKey = 'sendAsNamelessWarningShown';

         name = name2;
+    }
-    mesText = text.trim();
+    let mesText = String(text ?? '').trim();
     // Requires a regex check after the slash command is pushed to output
     mesText = getRegexedString(mesText, regex_placement.SLASH_COMMAND, { characterOverride: name });

+}
 export async function sendNarratorMessage(args, text) {
-    if (!text) {
+    text = String(text ?? '');
-        toastr.warning('You must specify text to send');
-        return '';
-    }
     const name = chat_metadata[NARRATOR_NAME_KEY] || NARRATOR_NAME_DEFAULT;
     // Messages that do nothing but set bias will be hidden from the context
     const bias = extractMessageBias(text);

+}
 async function sendCommentMessage(args, text) {
-    if (!text) {
-        toastr.warning('You must specify text to send');
-        return '';
-    }
     const compact = isTrueBoolean(args?.compact);
     const message = {
         name: COMMENT_NAME_DEFAULT,
         is_user: false,
         is_system: true,
         send_date: getMessageTimeStamp(),
-        mes: substituteParams(text.trim()),
+        mes: substituteParams(String(text ?? '').trim()),
         force_avatar: comment_avatar,
         extra: {
             type: system_message_types.COMMENT,

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+15 -0 Viewed

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

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

 import { tokenizers, getTextTokens, getTokenCount, getTokenCountAsync, getTokenizerModel } from './tokenizers.js';
 import { ToolManager } from './tool-calling.js';
 import { timestampToMoment, uuidv4 } from './utils.js';
+import { getGlobalVariable, getLocalVariable, setGlobalVariable, setLocalVariable } from './variables.js';
 export function getContext() {
     return {

         getCharacters,
         uuidv4,
         humanizedDateTime,
+        updateMessageBlock,
+        appendMediaToMessage,
+        variables: {
+            local: {
+                get: getLocalVariable,
+                set: setLocalVariable,
+            },
+            global: {
+                get: getGlobalVariable,
+                set: setGlobalVariable,
+            },
+        },
     };
+}

public/scripts/textgen-models.js+6 -0 Viewed

     'xAI',
     'Cloudflare',
     'SF Compute',
+    'Minimax',
+    'Nineteen',
+    'Liquid',
+    'Nebius',
+    'Chutes',
+    'Kluster',
     '01.AI',
     'HuggingFace',
     'Mancer',

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

     //truncation_length: 2048,
     ban_eos_token: false,
     skip_special_tokens: true,
+    include_reasoning: true,
     streaming: false,
     mirostat_mode: 0,
     mirostat_tau: 5,

     'add_bos_token',
     'ban_eos_token',
     'skip_special_tokens',
+    'include_reasoning',
     'streaming',
     'mirostat_mode',
     'mirostat_tau',

     for (const [type, selector] of Object.entries(SERVER_INPUTS)) {
         const control = $(selector);
         control.val(settings.server_urls[type] ?? '').on('input', function () {
-            settings.server_urls[type] = String($(this).val());
+            settings.server_urls[type] = String($(this).val()).trim();
             saveSettingsDebounced();
         });
+    }

             'add_bos_token_textgenerationwebui': true,
             'temperature_last_textgenerationwebui': true,
             'skip_special_tokens_textgenerationwebui': true,
+            'include_reasoning_textgenerationwebui': true,
             'top_a_textgenerationwebui': 0,
             'top_a_counter_textgenerationwebui': 0,
             'mirostat_mode_textgenerationwebui': 0,

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

@@ -1002,9 +1006,10 @@ export async function generateTextGenWithStreaming(generate_data, signal) {
1002	const newText = data?.choices?.[0]?.text \|\| data?.content \|\| '';	1006	const newText = data?.choices?.[0]?.text \|\| data?.content \|\| '';
1003	text += newText;	1007	text += newText;
1004	logprobs = parseTextgenLogprobs(newText, data.choices?.[0]?.logprobs \|\| data?.completion_probabilities);	1008	logprobs = parseTextgenLogprobs(newText, data.choices?.[0]?.logprobs \|\| data?.completion_probabilities);
		1009	state.reasoning += data?.choices?.[0]?.reasoning ?? '';
1005	}	1010	}
1006		1011
1007	yield { text, swipes, logprobs, toolCalls };	1012	yield { text, swipes, logprobs, toolCalls, state };
1008	}	1013	}
1009	};	1014	};
1010	}	1015	}

         'truncation_length': max_context,
         'ban_eos_token': settings.ban_eos_token,
         'skip_special_tokens': settings.skip_special_tokens,
+        'include_reasoning': settings.include_reasoning,
         'top_a': settings.top_a,
         'tfs': settings.tfs,
         'epsilon_cutoff': [OOBA, MANCER].includes(settings.type) ? settings.epsilon_cutoff : undefined,

public/scripts/tokenizers.js+3 -0 Viewed

@@ -679,6 +679,9 @@ export function getTokenizerModel() {
679	}	679	}
680		680
681	if (oai_settings.chat_completion_source === chat_completion_sources.PERPLEXITY) {	681	if (oai_settings.chat_completion_source === chat_completion_sources.PERPLEXITY) {
		682	if (oai_settings.perplexity_model.includes('sonar-reasoning')) {
		683	return deepseekTokenizer;
		684	}
682	if (oai_settings.perplexity_model.includes('llama-3') \|\| oai_settings.perplexity_model.includes('llama3')) {	685	if (oai_settings.perplexity_model.includes('llama-3') \|\| oai_settings.perplexity_model.includes('llama3')) {
683	return llama3Tokenizer;	686	return llama3Tokenizer;
684	}	687	}

public/scripts/utils.js+7 -7 Viewed

 /**
  * Run an action once an animation on a control ends. If the control has no animation, the action will be executed immediately.
- *
+ * The action will be executed after the animation ends or after the timeout, whichever comes first.
  * @param {HTMLElement} control - The control element to listen for animation end event
  * @param {(control:*?) => void} callback - The callback function to be executed when the animation ends
+ * @param {number} [timeout=500] - The timeout in milliseconds to wait for the animation to end before executing the callback
  */
-export function runAfterAnimation(control, callback) {
+export function runAfterAnimation(control, callback, timeout = 500) {
     if (hasAnimation(control)) {
-        const onAnimationEnd = () => {
+        Promise.race([
-            control.removeEventListener('animationend', onAnimationEnd);
+            new Promise((r) => setTimeout(r, timeout)), // Fallback timeout
-            callback(control);
+            new Promise((r) => control.addEventListener('animationend', r, { once: true })),
-        };
+        ]).finally(() => callback(control));
-        control.addEventListener('animationend', onAnimationEnd);
     } else {
         callback(control);
+    }

public/scripts/variables.js+4 -4 Viewed

 const MAX_LOOPS = 100;
-function getLocalVariable(name, args = {}) {
+export function getLocalVariable(name, args = {}) {
     if (!chat_metadata.variables) {
         chat_metadata.variables = {};
+    }

@@ -45,7 +45,7 @@ function getLocalVariable(name, args = {}) {
45	return (localVariable?.trim?.() === '' \|\| isNaN(Number(localVariable))) ? (localVariable \|\| '') : Number(localVariable);	45	return (localVariable?.trim?.() === '' \|\| isNaN(Number(localVariable))) ? (localVariable \|\| '') : Number(localVariable);
46	}	46	}
47		47
48	function setLocalVariable(name, value, args = {}) {	48	export function setLocalVariable(name, value, args = {}) {
49	if (!name) {	49	if (!name) {
50	throw new Error('Variable name cannot be empty or undefined.');	50	throw new Error('Variable name cannot be empty or undefined.');
51	}	51	}

     return value;
+}
-function getGlobalVariable(name, args = {}) {
+export function getGlobalVariable(name, args = {}) {
     let globalVariable = extension_settings.variables.global[args.key ?? name];
     if (args.index !== undefined) {
         try {

@@ -102,7 +102,7 @@ function getGlobalVariable(name, args = {}) {
102	return (globalVariable?.trim?.() === '' \|\| isNaN(Number(globalVariable))) ? (globalVariable \|\| '') : Number(globalVariable);	102	return (globalVariable?.trim?.() === '' \|\| isNaN(Number(globalVariable))) ? (globalVariable \|\| '') : Number(globalVariable);
103	}	103	}
104		104
105	function setGlobalVariable(name, value, args = {}) {	105	export function setGlobalVariable(name, value, args = {}) {
106	if (!name) {	106	if (!name) {
107	throw new Error('Variable name cannot be empty or undefined.');	107	throw new Error('Variable name cannot be empty or undefined.');
108	}	108	}

public/style.css+111 -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 q i,
+.mes_text q em {
+    color: inherit;
+}
+.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 +1100,11 @@ body .panelControlBar {
1022	/only affects bubblechat to make it sit nicely at the bottom/	1100	/only affects bubblechat to make it sit nicely at the bottom/
1023	}	1101	}
1024		1102
		1103	.last_mes:has(.mes_text:empty):has(.mes_reasoning_details[open]) .mes_reasoning:not(:empty) {
		1104	margin-bottom: 30px;
		1105	}
		1106
		1107	.last_mes .mes_reasoning,
1025	.last_mes .mes_text {	1108	.last_mes .mes_text {
1026	padding-right: 30px;	1109	padding-right: 30px;
1027	}	1110	}

     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 +4237,12 @@ input[type="range"]::-webkit-slider-thumb {
4150	align-items: center;	4237	align-items: center;
4151	}	4238	}
4152		4239
		4240	.mes_reasoning_edit_cancel,
4153	.mes_edit_cancel.menu_button {	4241	.mes_edit_cancel.menu_button {
4154	background-color: var(--crimson70a);	4242	background-color: var(--crimson70a);
4155	}	4243	}
4156		4244
		4245	.mes_reasoning_edit_done,
4157	.mes_edit_done.menu_button {	4246	.mes_edit_done.menu_button {
4158	background-color: var(--okGreen70a);	4247	background-color: var(--okGreen70a);
4159	}	4248	}

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

src/constants.js+1 -0 Viewed

     'prompt',
     'stop',
     'provider',
+    'include_reasoning',
 ];
 // https://github.com/vllm-project/vllm/blob/0f8a91401c89ac0a8018def3756829611b57727f/vllm/entrypoints/openai/protocol.py#L220

src/endpoints/backends/chat-completions.js+14 -8 Viewed

     const model = String(request.body.model);
     const stream = Boolean(request.body.stream);
-    const showThoughts = Boolean(request.body.show_thoughts);
+    const showThoughts = Boolean(request.body.include_reasoning);
+    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.include_reasoning) {
+            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);

src/endpoints/search.js+14 -3 Viewed

 router.post('/searxng', jsonParser, async (request, response) => {
     try {
-        const { baseUrl, query, preferences } = request.body;
+        const { baseUrl, query, preferences, categories } = request.body;
         if (!baseUrl || !query) {
             console.log('Missing required parameters for /searxng');

         if (preferences) {
             searchParams.append('preferences', preferences);
+        }
+        if (categories) {
+            searchParams.append('categories', categories);
+        }
         searchUrl.search = searchParams.toString();
         const searchResult = await fetch(searchUrl, { headers: visitHeaders });

             return response.sendStatus(400);
+        }
-        const { query } = request.body;
+        const { query, include_images } = request.body;
         const body = {
             query: query,

             topic: 'general',
             include_answer: true,
             include_raw_content: false,
-            include_images: false,
+            include_images: !!include_images,
             include_image_descriptions: false,
             include_domains: [],
             max_results: 10,

 router.post('/visit', jsonParser, async (request, response) => {
     try {
         const url = request.body.url;
+        const html = Boolean(request.body.html ?? true);
         if (!url) {
             console.log('No url provided for /visit');

+        }
         const contentType = String(result.headers.get('content-type'));
+        if (html) {
             if (!contentType.includes('text/html')) {
                 console.log(`Visit failed, content-type is ${contentType}, expected text/html`);
                 return response.sendStatus(500);

             const text = await result.text();
             return response.send(text);
+        }
+        response.setHeader('Content-Type', contentType);
+        const buffer = await result.arrayBuffer();
+        return response.send(Buffer.from(buffer));
     } catch (error) {
         console.log(error);
         return response.sendStatus(500);

src/endpoints/stable-diffusion.js+1 -1 Viewed

 comfy.post('/generate', jsonParser, async (request, response) => {
     try {
+        let item;
         const url = new URL(urlJoin(request.body.url, '/prompt'));
         const controller = new AbortController();

         /** @type {any} */
         const data = await promptResult.json();
         const id = data.prompt_id;
-        let item;
         const historyUrl = new URL(urlJoin(request.body.url, '/history'));
         while (true) {
             const result = await fetch(historyUrl);

src/endpoints/tokenizers.js+1 -1 Viewed

  * @returns {string} Tokenizer model to use
  */
 export function getTokenizerModel(requestModel) {
-    if (requestModel.includes('o1-preview') || requestModel.includes('o1-mini')) {
+    if (requestModel.includes('o1-preview') || requestModel.includes('o1-mini') || requestModel.includes('o3-mini')) {
         return 'gpt-4o';
+    }