7d937b36 · permissionBRICK/SillyTavern

public/script.js+8 -6 Viewed

         return '';
+    }
     if (Number(messageId) === 0 && !isSystem && !isUser && !isReasoning) {
         const mesBeforeReplace = mes;
         const chatMessage = chat[messageId];
         mes = substituteParams(mes, undefined, ch_name);

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

             const timestamps = [];
             for await (const { text, swipes, logprobs, toolCalls, state } of this.generator()) {
                 timestamps.push(Date.now());
                 if (this.isStopped || this.abortController.signal.aborted) {
                     return;
+                }

     const reasoning = new PromptReasoning();
     for (let i = coreChat.length - 1; i >= 0; i--) {
 -        if (reasoning.isLimitReached()) {
 -            break;
 -        }
         const depth = coreChat.length - i - 1;
 +        const isPrefix = isContinue && i === coreChat.length - 1;
         coreChat[i] = {
             ...coreChat[i],
             mes: reasoning.addToMessage(

                     regex_placement.REASONING,
                     { isPrompt: true, depth: depth },
                 ),
 +                isPrefix,
             ),
         };
 +        if (reasoning.isLimitReached()) {
 +            break;
 +        }
+    }
     // Determine token limit

public/scripts/backgrounds.js+14 -4 Viewed

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

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

     $('#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/reasoning.js+12 -3 Viewed

      * 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;
+        }

         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 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: [

     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: [

     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: [

     MacrosParser.registerMacro('reasoningSeparator', () => power_user.reasoning.separator, t`Reasoning Separator`);
+}
 function setReasoningEventHandlers() {
     $(document).on('click', '.mes_reasoning_copy', (e) => {
         e.stopPropagation();
         e.preventDefault();

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

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

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

Merge branch 'staging' into text-completion-include-reasoning