Reprint non-tainted group chat on switching personas (#4603) * fix: reprint non-tainted group chat on switching personas * feat: mark chat as tainted when sending user message * feat: mark chat as tainted when adding custom messages or captions * feat: export createOrEditCharacter function and integrate it into retriggerFirstMessageOnEmptyChat * fix: optimize loadPersonaForCurrentChat by storing current chat ID in a variable * Improve conditions of first message retrigger --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

9463d1a1529255b0fd390eeb60f9a4d6fd9ef656

Wolfsblvt <wolfsblvt@gmail.com>

Signed

Parents: befb2ffb78612198ca1bf95b10f84e55ba027e15

public/script.js+3 -1 Viewed

 // Saved here for performance reasons
 const messageTemplate = $('#message_template .mes');
-const chatElement = $('#chat');
+export const chatElement = $('#chat');
 let dialogueResolve = null;
 let dialogueCloseStop = false;

     await populateFileAttachment(message);
     statMesProcess(message, 'user', characters, this_chid, '');
+    chat_metadata['tainted'] = true;
     if (typeof insertAt === 'number' && insertAt >= 0 && insertAt <= chat.length) {
         chat.splice(insertAt, 0, message);
         await saveChatConditional();

public/scripts/extensions/caption/index.js+2 -1 Viewed

 import { ensureImageFormatSupported, getBase64Async, getFileExtension, isTrueBoolean, saveBase64AsFile } from '../../utils.js';
 import { getContext, getApiUrl, doExtrasFetch, extension_settings, modules, renderExtensionTemplateAsync } from '../../extensions.js';
-import { appendMediaToMessage, eventSource, event_types, getRequestHeaders, saveChatConditional, saveSettingsDebounced, substituteParamsExtended } from '../../../script.js';
+import { appendMediaToMessage, chat_metadata, eventSource, event_types, getRequestHeaders, saveChatConditional, saveSettingsDebounced, substituteParamsExtended } from '../../../script.js';
 import { getMessageTimeStamp } from '../../RossAscends-mods.js';
 import { SECRET_KEYS, secret_state } from '../../secrets.js';
 import { getMultimodalCaption } from '../shared.js';

             inline_image: !!extension_settings.caption.show_in_chat,
         },
     };
+    chat_metadata['tainted'] = true;
     context.chat.push(message);
     const messageId = context.chat.length - 1;
     await eventSource.emit(event_types.MESSAGE_SENT, messageId);

public/scripts/group-chats.js+9 -8 Viewed

     depth_prompt_role_default,
     shouldAutoContinue,
     unshallowCharacter,
+    chatElement,
 } from '../script.js';
 import { printTagList, createTagMapFromList, applyTagsOnCharacterSelect, tag_map, applyTagsOnGroupSelect } from './tags.js';
 import { FILTER_TYPES, FilterHelper } from './filters.js';

     const chat_id = group.chat_id;
     const data = await loadGroupChat(chat_id);
     const metadata = group.chat_metadata ?? {};
-    let freshChat = false;
+    const freshChat = !metadata.tainted;
     await loadItemizedPrompts(getCurrentChatId());
-    if (Array.isArray(data) && data.length) {
-        data[0].is_group = true;
-        chat.splice(0, chat.length, ...data);
-        await printMessages();
-    } else {
-        freshChat = !metadata.tainted;
     if (group && Array.isArray(group.members) && freshChat) {
+        chat.splice(0, chat.length);
+        chatElement.find('.mes').remove();
         for (let member of group.members) {
             const character = characters.find(x => x.avatar === member || x.name === member);
             if (!character) {

             await eventSource.emit(event_types.CHARACTER_MESSAGE_RENDERED, (chat.length - 1), 'first_message');
+        }
         await saveGroupChat(groupId, false);
-        }
+    } else if (Array.isArray(data) && data.length) {
+        data[0].is_group = true;
+        chat.splice(0, chat.length, ...data);
+        chatElement.find('.mes').remove();
+        await printMessages();
+    }
     updateChatMetadata(metadata, true);

public/scripts/personas.js+36 -19 Viewed

     characters,
     chat,
     chat_metadata,
+    createOrEditCharacter,
     default_user_avatar,
     eventSource,
     event_types,
+    getCurrentChatId,
     getRequestHeaders,
     getThumbnailUrl,
     groupToEntity,

 /** @type {FilterHelper} Filter helper for the persona list */
 export const personasFilter = new FilterHelper(debounce(getUserAvatars, debounce_timeout.quick));
+/** @type {string} The last loaded chat id to remember for persona loading */
+let personaLastLoadedChatId = null;
 /** @type {function(string): void} */
 let navigateToAvatar = () => { };

  * @param {boolean} [options.toastPersonaNameChange=true] Whether to show a toast when the persona name is changed
  * @param {boolean} [options.navigateToCurrent=false] Whether to navigate to the current persona after setting the avatar
  */
-export function setUserAvatar(imgfile, { toastPersonaNameChange = true, navigateToCurrent = false } = {}) {
+export async function setUserAvatar(imgfile, { toastPersonaNameChange = true, navigateToCurrent = false } = {}) {
+    const currentUserAvatar = user_avatar;
     user_avatar = imgfile && typeof imgfile === 'string' ? imgfile : $(this).attr('data-avatar-id');
+    if (currentUserAvatar === user_avatar) {
+        return;
+    }
     reloadUserAvatar();
     updatePersonaUIStates({ navigateToCurrent: navigateToCurrent });
     selectCurrentPersona({ toastPersonaNameChange: toastPersonaNameChange });
-    retriggerFirstMessageOnEmptyChat();
+    await retriggerFirstMessageOnEmptyChat();
     saveSettingsDebounced();
     $('.zoomed_avatar[forchar]').remove();
+}

 /**
  * Automatically selects a persona based on the given name if a matching persona exists.
  * @param {string} name - The name to search for
- * @returns {boolean} True if a matching persona was found and selected, false otherwise
+ * @returns {Promise<boolean>} True if a matching persona was found and selected, false otherwise
  */
-export function autoSelectPersona(name) {
+export async function autoSelectPersona(name) {
     for (const [key, value] of Object.entries(power_user.personas)) {
         if (value === name) {
             console.log(`Auto-selecting persona ${key} for name ${name}`);
-            setUserAvatar(key);
+            await setUserAvatar(key);
             return true;
+        }
+    }

  * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether a persona was selected
  */
 async function loadPersonaForCurrentChat({ doRender = false } = {}) {
+    const currentChatId = getCurrentChatId();
+    if (currentChatId === personaLastLoadedChatId) return;
+    personaLastLoadedChatId = currentChatId;
     // Cache persona list to check if they exist
     const userAvatars = await getUserAvatars(doRender);
     // Check if the user avatar is set and exists in the list of user avatars
     if (userAvatars.length && !userAvatars.includes(user_avatar)) {
         console.log(`User avatar ${user_avatar} not found in user avatars list, pick the first available one`);
-        setUserAvatar(userAvatars[0], { toastPersonaNameChange: false, navigateToCurrent: true });
+        await setUserAvatar(userAvatars[0], { toastPersonaNameChange: false, navigateToCurrent: true });
+    }
     // Define a persona for this chat

     // Persona avatar found, select it
     if (chatPersona && user_avatar !== chatPersona) {
         const willAutoLock = power_user.persona_auto_lock && user_avatar !== chat_metadata['persona'];
-        setUserAvatar(chatPersona, { toastPersonaNameChange: false, navigateToCurrent: true });
+        await setUserAvatar(chatPersona, { toastPersonaNameChange: false, navigateToCurrent: true });
         if (power_user.persona_show_notifications) {
             let message = t`Auto-selected persona based on ${connectType} connection.<br />Your messages will now be sent as ${power_user.personas[chatPersona]}.`;

@@ -1542,7 +1555,7 @@ async function loadPersonaForCurrentChat({ doRender = false } = {}) {
1542	}	1555	}
1543	// Even if it's the same persona, we still might need to auto-lock to chat if that's enabled	1556	// Even if it's the same persona, we still might need to auto-lock to chat if that's enabled
1544	else if (chatPersona && power_user.persona_auto_lock && !chat_metadata['persona']) {	1557	else if (chatPersona && power_user.persona_auto_lock && !chat_metadata['persona']) {
1545	lockPersona('chat');	1558	await lockPersona('chat');
1546	}	1559	}
1547		1560
1548	updatePersonaUIStates();	1561	updatePersonaUIStates();

     // One of the persona was selected. So load it.
     if (!isRemoving && selectedPersona) {
-        setUserAvatar(selectedPersona, { toastPersonaNameChange: false });
+        await setUserAvatar(selectedPersona, { toastPersonaNameChange: false });
         if (power_user.persona_show_notifications) {
             toastr.success(t`Selected persona ${power_user.personas[selectedPersona]} for current chat.`, t`Connected Persona Selected`);
+        }

 /**
  * Retriggers the first message to reload it from the char definition.
- *
- * Only works if only the first message is present, and not in group mode.
  */
-export function retriggerFirstMessageOnEmptyChat() {
+export async function retriggerFirstMessageOnEmptyChat() {
-    if (Number(this_chid) >= 0 && !selected_group && chat.length === 1) {
+    if (chat_metadata.tainted) {
-        $('#firstmessage_textarea').trigger('input');
+        return;
+    }
+    if (selected_group) {
+        await reloadCurrentChat();
+    }
+    if (!selected_group && Number(this_chid) >= 0 && chat.length === 1) {
+        await createOrEditCharacter();
+    }
+}

  * Sets a persona name and optionally an avatar.
  * @param {{mode: 'lookup' | 'temp' | 'all'}} namedArgs Named arguments
  * @param {string} name Name to set
- * @returns {string}
+ * @returns {Promise<string>}
  */
-function setNameCallback({ mode = 'all' }, name) {
+async function setNameCallback({ mode = 'all' }, name) {
     if (!name) {
         toastr.warning('You must specify a name to change to');
         return '';

         let persona = Object.entries(power_user.personas).find(([avatar, _]) => avatar === name)?.[1];
         if (!persona) persona = Object.entries(power_user.personas).find(([_, personaName]) => personaName.toLowerCase() === name.toLowerCase())?.[1];
         if (persona) {
-            autoSelectPersona(persona);
+            await autoSelectPersona(persona);
             return '';
         } else if (mode === 'lookup') {
             toastr.warning(`Persona ${name} not found`);

     $('#sync_name_button').on('click', syncUserNameToPersona);
     $('#avatar_upload_file').on('change', changeUserAvatar);
-    $(document).on('click', '#user_avatar_block .avatar-container', function () {
+    $(document).on('click', '#user_avatar_block .avatar-container', async function () {
         const imgfile = $(this).attr('data-avatar-id');
-        setUserAvatar(imgfile);
+        await setUserAvatar(imgfile);
     });
     $('#persona_rename_button').on('click', () => renamePersona(user_avatar));

public/scripts/slash-commands.js+8 -0 Viewed

         insertAt = chat.length + insertAt;
+    }
+    chat_metadata['tainted'] = true;
     if (!isNaN(insertAt) && insertAt >= 0 && insertAt <= chat.length) {
         chat.splice(insertAt, 0, message);
         await saveChatConditional();

         insertAt = chat.length + insertAt;
+    }
+    chat_metadata['tainted'] = true;
     if (!isNaN(insertAt) && insertAt >= 0 && insertAt <= chat.length) {
         chat.splice(insertAt, 0, message);
         await saveChatConditional();

         },
     };
+    chat_metadata['tainted'] = true;
     chat.push(message);
     await eventSource.emit(event_types.MESSAGE_SENT, (chat.length - 1));
     addOneMessage(message);

         insertAt = chat.length + insertAt;
+    }
+    chat_metadata['tainted'] = true;
     if (!isNaN(insertAt) && insertAt >= 0 && insertAt <= chat.length) {
         chat.splice(insertAt, 0, message);
         await saveChatConditional();