Merge branch 'staging' into group-join-examples

c51e27fb6903b4ec797d94e65a7479c950b714b9

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

Parents: 73614f2f8d97646a62f60859eefa8a01cb0de44f f056e6a89cc4a4e3857f5848dff7da8c8c7a3dae

public/script.js+26 -30 Viewed

 let this_del_mes = -1;
 //message editing and chat scroll position persistence
 var this_edit_mes_chname = '';
 var this_edit_mes_id;
 -var scroll_holder = 0;
 -var is_use_scroll_holder = false;
 //settings
 export let settings;

         chooseBogusFolder($(this), tagId);
     });
 -    /**
 +    const cssAutofit = CSS.supports('field-sizing', 'content');
 -     * Sets the scroll height of the edit textarea to fit the content.
 +    if (!cssAutofit) {
 -     * @param {HTMLTextAreaElement} e Textarea element to auto-fit
 +        /**
 -     */
 +         * Sets the scroll height of the edit textarea to fit the content.
 -    function autoFitEditTextArea(e) {
 +         * @param {HTMLTextAreaElement} e Textarea element to auto-fit
 -        scroll_holder = chatElement[0].scrollTop;
 +         */
 -        e.style.height = '0px';
 +        function autoFitEditTextArea(e) {
 -        const newHeight = e.scrollHeight + 4;
 +            e.style.height = '0px';
 -        e.style.height = `${newHeight}px`;
 +            const newHeight = e.scrollHeight + 4;
 -        is_use_scroll_holder = true;
 +            e.style.height = `${newHeight}px`;
 +        }
 +        const autoFitEditTextAreaDebounced = debounce(autoFitEditTextArea, debounce_timeout.short);
 +        document.addEventListener('input', e => {
 +            if (e.target instanceof HTMLTextAreaElement && e.target.classList.contains('edit_textarea')) {
 +                const scrollbarShown = e.target.clientWidth < e.target.offsetWidth && e.target.offsetHeight >= window.innerHeight * 0.75;
 +                const immediately = (e.target.scrollHeight > e.target.offsetHeight && !scrollbarShown) || e.target.value === '';
 +                immediately ? autoFitEditTextArea(e.target) : autoFitEditTextAreaDebounced(e.target);
 +            }
 +        });
+    }
 -    const autoFitEditTextAreaDebounced = debounce(autoFitEditTextArea, debounce_timeout.short);
++
 -    document.addEventListener('input', e => {
 -        if (e.target instanceof HTMLTextAreaElement && e.target.classList.contains('edit_textarea')) {
 -            const scrollbarShown = e.target.clientWidth < e.target.offsetWidth && e.target.offsetHeight >= window.innerHeight * 0.75;
 -            const immediately = (e.target.scrollHeight > e.target.offsetHeight && !scrollbarShown) || e.target.value === '';
 -            immediately ? autoFitEditTextArea(e.target) : autoFitEditTextAreaDebounced(e.target);
 -        }
 -    });
     const chatElementScroll = document.getElementById('chat');
     const chatScrollHandler = function () {
         if (power_user.waifuMode) {

     };
     chatElementScroll.addEventListener('wheel', chatScrollHandler, { passive: true });
     chatElementScroll.addEventListener('touchmove', chatScrollHandler, { passive: true });
 -    chatElementScroll.addEventListener('scroll', function () {
 -        if (is_use_scroll_holder) {
 -            this.scrollTop = scroll_holder;
 -            is_use_scroll_holder = false;
 -        }
 -    }, { passive: true });
     $(document).on('click', '.mes', function () {
         //when a 'delete message' parent div is clicked

                 .closest('.mes_block')
                 .find('.mes_text')
                 .append(
                     '<textarea id=\'curEditTextarea\' class=\'edit_textarea mdHotkeys\' style=\'max-width:auto;\'></textarea>',
                 );
             $('#curEditTextarea').val(text);
             let edit_textarea = $(this)
                 .closest('.mes_block')
                 .find('.edit_textarea');
 -            edit_textarea.height(0);
 +            if (!cssAutofit) {
                             edit_textarea.height(edit_textarea[0].scrollHeight);
 +                edit_textarea.height(edit_textarea[0].scrollHeight);
 +            }
             edit_textarea.focus();
             edit_textarea[0].setSelectionRange(     //this sets the cursor at the end of the text
                 String(edit_textarea.val()).length,

public/scripts/RossAscends-mods.js+33 -1 Viewed

         saveSettingsDebounced();
     });
 +    const cssAutofit = CSS.supports('field-sizing', 'content');
++
 +    if (cssAutofit) {
 +        let lastHeight = chatBlock.offsetHeight;
 +        const chatBlockResizeObserver = new ResizeObserver((entries) => {
 +            for (const entry of entries) {
 +                if (entry.target !== chatBlock) {
 +                    continue;
 +                }
++
 +                const threshold = 1;
 +                const newHeight = chatBlock.offsetHeight;
 +                const deltaHeight = newHeight - lastHeight;
 +                const isScrollAtBottom = Math.abs(chatBlock.scrollHeight - chatBlock.scrollTop - newHeight) <= threshold;
++
 +                if (!isScrollAtBottom && Math.abs(deltaHeight) > threshold) {
 +                    chatBlock.scrollTop -= deltaHeight;
 +                }
 +                lastHeight = newHeight;
 +            }
 +        });
++
 +        chatBlockResizeObserver.observe(chatBlock);
 +    }
++
     sendTextArea.addEventListener('input', () => {
 +        saveUserInputDebounced();
++
 +        if (cssAutofit) {
 +            // Unset modifications made with a manual resize
 +            sendTextArea.style.height = 'auto';
 +            return;
 +        }
++
         const hasContent = sendTextArea.value !== '';
         const fitsCurrentSize = sendTextArea.scrollHeight <= sendTextArea.offsetHeight;
         const isScrollbarShown = sendTextArea.clientWidth < sendTextArea.offsetWidth;

         const needsDebounce = hasContent && (fitsCurrentSize || (isScrollbarShown && isHalfScreenHeight));
         if (needsDebounce) autoFitSendTextAreaDebounced();
         else autoFitSendTextArea();
 -        saveUserInputDebounced();
     });
     restoreUserInput();

public/scripts/extensions/expressions/index.js+52 -18 Viewed

 import { commonEnumProviders } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
 import { slashCommandReturnHelper } from '../../slash-commands/SlashCommandReturnHelper.js';
 import { SlashCommandClosure } from '../../slash-commands/SlashCommandClosure.js';
 +import { generateWebLlmChatPrompt, isWebLlmSupported } from '../shared.js';
 export { MODULE_NAME };
 const MODULE_NAME = 'expressions';

     local: 0,
     extras: 1,
     llm: 2,
 +    webllm: 3,
 };
 let expressionsList = null;

@@ -698,8 +700,8 @@ async function moduleWorker() {
698	700	}
699	701
700	702	// If using LLM api then check if streamingProcessor is finished to avoid sending multiple requests to the API
701	703	if (extension_settings.expressions.api === EXPRESSION_API.llm && context.streamingProcessor && !context.streamingProcessor.isFinished) {
702	704	return;
703	705	}
704	706
705	707	// API is busy

     extension_settings.expressions.talkinghead = newState; // Store setting
     saveSettingsDebounced();
     if (extension_settings.expressions.api == [EXPRESSION_API.local, ||EXPRESSION_API.llm, EXPRESSION_API.webllm].includes(extension_settings.expressions.api == EXPRESSION_API.llm)) {
         return;
+    }

             console.debug(`fuzzy search found: ${result[0].item} as closest for the LLM response:`, emotionResponse);
             return result[0].item;
+        }
 +        const lowerCaseResponse = String(emotionResponse || '').toLowerCase();
 +        for (const label of labels) {
 +            if (lowerCaseResponse.includes(label.toLowerCase())) {
 +                console.debug(`Found label ${label} in the LLM response:`, emotionResponse);
 +                return label;
 +            }
 +        }
+    }
     throw new Error('Could not parse emotion response ' + emotionResponse);
+}
 +/**
 + * Gets the JSON schema for the LLM API.
 + * @param {string[]} emotions A list of emotions to search for.
 + * @returns {object} The JSON schema for the LLM API.
 + */
 +function getJsonSchema(emotions) {
 +    return {
 +        $schema: 'http://json-schema.org/draft-04/schema#',
 +        type: 'object',
 +        properties: {
 +            emotion: {
 +                type: 'string',
 +                enum: emotions,
 +            },
 +        },
 +        required: [
 +            'emotion',
 +        ],
 +    };
 +}
++
 function onTextGenSettingsReady(args) {
     // Only call if inside an API call
     if (inApiCall && extension_settings.expressions.api === EXPRESSION_API.llm && isJsonSchemaSupported()) {

             stop: [],
             stopping_strings: [],
             custom_token_bans: [],
             json_schema: {getJsonSchema(emotions),
 -                $schema: 'http://json-schema.org/draft-04/schema#',
 -                type: 'object',
 -                properties: {
 -                    emotion: {
 -                        type: 'string',
 -                        enum: emotions,
 -                    },
 -                },
 -                required: [
 -                    'emotion',
 -                ],
 -            },
         });
+    }
+}

                 const emotionResponse = await generateRaw(text, main_api, false, false, prompt);
                 return parseLlmResponse(emotionResponse, expressionsList);
+            }
 +            // Using WebLLM
 +            case EXPRESSION_API.webllm: {
 +                if (!isWebLlmSupported()) {
 +                    console.warn('WebLLM is not supported. Using fallback expression');
 +                    return getFallbackExpression();
 +                }
++
 +                const expressionsList = await getExpressionsList();
 +                const prompt = substituteParamsExtended(customPrompt, { labels: expressionsList }) || await getLlmPrompt(expressionsList);
 +                const messages = [
 +                    { role: 'user', content: text + '\n\n' + prompt },
 +                ];
++
 +                const emotionResponse = await generateWebLlmChatPrompt(messages);
 +                return parseLlmResponse(emotionResponse, expressionsList);
 +            }
             // Extras
             default: {
                 const url = new URL(getApiUrl());

     const tempApi = this.value;
     if (tempApi) {
         extension_settings.expressions.api = Number(tempApi);
         $('.expression_llm_prompt_block').toggle([EXPRESSION_API.llm, EXPRESSION_API.webllm].includes(extension_settings.expressions.api === EXPRESSION_API.llm));
         expressionsList = null;
         spriteCache = {};
         moduleWorker();

         await renderAdditionalExpressionSettings();
         $('#expression_api').val(extension_settings.expressions.api ?? EXPRESSION_API.extras);
         $('.expression_llm_prompt_block').toggle([EXPRESSION_API.llm, EXPRESSION_API.webllm].includes(extension_settings.expressions.api === EXPRESSION_API.llm));
         $('#expression_llm_prompt').val(extension_settings.expressions.llmPrompt ?? '');
         $('#expression_llm_prompt').on('input', function () {
             extension_settings.expressions.llmPrompt = $(this).val();

public/scripts/extensions/expressions/settings.html+2 -1 Viewed

                 <select id="expression_api" class="flex1 margin0">
                     <option value="0" data-i18n="Local">Local</option>
                     <option value="1" data-i18n="Extras">Extras</option>
                     <option value="2" data-i18n="LLMMain API">LLMMain API</option>
 +                    <option value="3" data-i18n="WebLLM Extension">WebLLM Extension</option>
                 </select>
             </div>
             <div class="expression_llm_prompt_block m-b-1 m-t-1">

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

     'Anthropic',
     'Google',
     'Google AI Studio',
 +    'Amazon Bedrock',
     'Groq',
     'SambaNova',
     'Cohere',

     'Featherless',
     'Inflection',
     'xAI',
 +    'Cloudflare',
 +    'SF Compute',
     '01.AI',
     'HuggingFace',
     'Mancer',

public/style.css+2 -0 Viewed

     text-shadow: 0px 0px calc(var(--shadowWidth) * 1px) var(--SmartThemeShadowColor);
     flex: 1;
     order: 3;
 +    field-sizing: content;
     --progColor: rgb(146, 190, 252);
     --progFlashColor: rgb(215, 136, 114);

     line-height: calc(var(--mainFontSize) + .25rem);
     max-height: 75vh;
     max-height: 75dvh;
 +    field-sizing: content;
+}
 #anchor_order {