Add shallow character load mode

383806325a0dca99ad4b4fa3f257c868600ff0ab

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

Parents: 70f762c006151886c978069430703768ee0d8a0d

public/index.html+7 -0 Viewed

                                     <option data-i18n="tag_import_existing" value="4">Existing</option>
                                 </select>
                             </div>
+                            <label class="checkbox_label" for="shallow_characters" data-i18n="[title]Experimental feature. May behave unstable and have compatibility issues." title="Experimental feature. May behave unstable and have compatibility issues.">
+                                <input id="shallow_characters" type="checkbox" />
+                                <small data-i18n="Lazy Load Characters">
+                                    Lazy Load Characters
+                                </small>
+                                <i class="fa-solid fa-flask"></i>
+                            </label>
                             <label class="checkbox_label" for="fuzzy_search_checkbox" title="Use fuzzy matching, and search characters in the list by all data fields, not just by a name substring." data-i18n="[title]Use fuzzy matching, and search characters in the list by all data fields, not just by a name substring">
                                 <input id="fuzzy_search_checkbox" type="checkbox" />
                                 <small data-i18n="Advanced Character Search">Advanced Character Search</small>

public/script.js+37 -1 Viewed

         method: 'POST',
         headers: getRequestHeaders(),
         body: JSON.stringify({
-            '': '',
+            shallow: power_user.shallow_characters,
         }),
     });
     if (response.ok === true) {

     setGenerationProgress(0);
     generation_started = new Date();
+    // Prevent generation from shallow characters
+    await unshallowCharacter(this_chid);
     // Occurs every time, even if the generation is aborted due to slash commands execution
     await eventSource.emit(event_types.GENERATION_STARTED, type, { automatic_trigger, force_name2, quiet_prompt, quietToLoud, skipWIAN, force_chid, signal, quietImage }, dryRun);

+    }
+}
+/**
+ * Loads all the data of a shallow character.
+ * @param {string|undefined} characterId Array index
+ * @returns {Promise<void>} Promise that resolves when the character is unshallowed
+ */
+export async function unshallowCharacter(characterId) {
+    if (characterId === undefined) {
+        console.warn('Undefined character cannot be unshallowed');
+        return;
+    }
+    const character = characters[characterId];
+    if (!character) {
+        console.warn('Character not found:', characterId);
+        return;
+    }
+    // Character is not shallow
+    if (!character.shallow) {
+        return;
+    }
+    const avatar = character.avatar;
+    if (!avatar) {
+        console.warn('Character has no avatar field:', characterId);
+        return;
+    }
+    await getOneCharacter(avatar);
+}
 export async function getChat() {
     //console.log('/api/chats/get -- entered for -- ' + characters[this_chid].name);
     try {
+        await unshallowCharacter(this_chid);
         const response = await $.ajax({
             type: 'POST',
             url: '/api/chats/get',

public/scripts/group-chats.js+33 -4 Viewed

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

     // Run validation before any loading
     validateGroup(group);
+    await unshallowGroupMembers(groupId);
     const chat_id = group.chat_id;
     const data = await loadGroupChat(chat_id);

+    }
     try {
+        await unshallowGroupMembers(selected_group);
         throwIfAborted();
         hideSwipeButtons();
         is_group_generating = true;

     saveGroupDebounced(group, reload);
+}
+/**
+ * Unshallows all definitions of group members.
+ * @param {string} groupId Id of the group
+ * @returns {Promise<void>} Promise that resolves when all group members are unshallowed
+ */
+export async function unshallowGroupMembers(groupId) {
+    const group = groups.find(x => x.id == groupId);
+    if (!group) {
+        return;
+    }
+    const members = group.members;
+    if (!Array.isArray(members)) {
+        return;
+    }
+    for (const member of members) {
+        const index = characters.findIndex(x => x.avatar === member);
+        if (index === -1) {
+            continue;
+        }
+        await unshallowCharacter(String(index));
+    }
+}
 let groupAutoModeAbortController = null;
 async function groupChatAutoModeWorker() {

     await generateGroupWrapper(true, 'auto', { signal: groupAutoModeAbortController.signal });
+}
-async function modifyGroupMember(chat_id, groupMember, isDelete) {
+async function modifyGroupMember(groupId, groupMember, isDelete) {
     const id = groupMember.data('id');
-    const thisGroup = groups.find((x) => x.id == chat_id);
+    const thisGroup = groups.find((x) => x.id == groupId);
     const membersArray = thisGroup?.members ?? newGroupMembers;
     if (isDelete) {

@@ -1173,6 +1200,7 @@ async function modifyGroupMember(chat_id, groupMember, isDelete) {
1173	}	1200	}
1174		1201
1175	if (openGroupId) {	1202	if (openGroupId) {
		1203	await unshallowGroupMembers(openGroupId);
1176	await editGroup(openGroupId, false, false);	1204	await editGroup(openGroupId, false, false);
1177	updateGroupAvatar(thisGroup);	1205	updateGroupAvatar(thisGroup);
1178	}	1206	}

@@ -1638,7 +1666,7 @@ async function onGroupActionClick(event) {
1638	}	1666	}
1639		1667
1640	if (action === 'view') {	1668	if (action === 'view') {
1641	openCharacterDefinition(member);	1669	await openCharacterDefinition(member);
1642	}	1670	}
1643		1671
1644	if (action === 'speak') {	1672	if (action === 'speak') {

     return false;
+}
-function openCharacterDefinition(characterSelect) {
+async function openCharacterDefinition(characterSelect) {
     if (is_group_generating) {
         toastr.warning(t`Can't peek a character while group reply is being generated`);
         console.warn('Can\'t peek a character def while group reply is being generated');

         return;
+    }
+    await unshallowCharacter(chid);
     setCharacterId(chid);
     select_selected_character(chid);
     // Gentle nudge to recalculate tokens

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

     forbid_external_media: true,
     external_media_allowed_overrides: [],
     external_media_forbidden_overrides: [],
+    shallow_characters: false,
 };
 let themes = [];

     $('#auto-connect-checkbox').prop('checked', power_user.auto_connect);
     $('#auto-load-chat-checkbox').prop('checked', power_user.auto_load_chat);
     $('#forbid_external_media').prop('checked', power_user.forbid_external_media);
+    $('#shallow_characters').prop('checked', power_user.shallow_characters);
     for (const theme of themes) {
         const option = document.createElement('option');

         await exportTheme();
     });
+    $('#shallow_characters').on('input', function () {
+        power_user.shallow_characters = !!$(this).prop('checked');
+        saveSettingsDebounced();
+        toastr.info('Reload the page for this setting to take effect');
+    });
     $(document).on('click', '#debug_table [data-debug-function]', function () {
         const functionId = $(this).data('debug-function');
         const functionRecord = debug_functions.find(f => f.functionId === functionId);

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

     updateMessageBlock,
     printMessages,
     clearChat,
+    unshallowCharacter,
 } from '../script.js';
 import {
     extension_settings,

     renderExtensionTemplateAsync,
     writeExtensionField,
 } from './extensions.js';
-import { groups, openGroupChat, selected_group } from './group-chats.js';
+import { groups, openGroupChat, selected_group, unshallowGroupMembers } from './group-chats.js';
 import { addLocaleData, getCurrentLocale, t, translate } from './i18n.js';
 import { hideLoader, showLoader } from './loader.js';
 import { MacrosParser } from './macros.js';

         clearChat,
         ChatCompletionService,
         TextCompletionService,
+        unshallowCharacter,
+        unshallowGroupMembers,
     };
+}

src/endpoints/characters.js+36 -4 Viewed

 };
 /**
+ * Only get fields that are used to display the character list.
+ * @param {object} character Character object
+ * @returns {{shallow: true, [key: string]: any}} Shallow character
+ */
+const toShallow = (character) => {
+    return {
+        name: character.name,
+        avatar: character.avatar,
+        chat: character.chat,
+        fav: character.fav,
+        date_added: character.date_added,
+        create_date: character.create_date,
+        date_last_chat: character.date_last_chat,
+        chat_size: character.chat_size,
+        data_size: character.data_size,
+        data: {
+            name: _.get(character, 'data.name', ''),
+            character_version: _.get(character, 'data.character_version', ''),
+            creator: _.get(character, 'data.creator', ''),
+            creator_notes: _.get(character, 'data.creator_notes', ''),
+            extensions: {
+                fav: _.get(character, 'data.extensions.fav', false),
+            },
+        },
+        shallow: true,
+    };
+};
+/**
  * processCharacter - Process a given character, read its data and calculate its statistics.
+ *
  * @param  {string} item The name of the character.
  * @param  {import('../users.js').UserDirectoryList} directories User directories
+ * @param  {object} options Options for the character processing
+ * @param  {boolean} options.shallow If true, only return the core character's metadata
  * @return {Promise<object>}     A Promise that resolves when the character processing is done.
  */
-const processCharacter = async (item, directories) => {
+const processCharacter = async (item, directories, { shallow }) => {
     try {
         const imgFile = path.join(directories.characters, item);
         const imgData = await readCharacterData(imgFile);

         character['chat_size'] = chatSize;
         character['date_last_chat'] = dateLastChat;
         character['data_size'] = calculateDataSize(jsonObject?.data);
-        return character;
+        return shallow ? toShallow(character) : character;
+    }
     catch (err) {
         console.error(`Could not process character: ${item}`);

  */
 router.post('/all', jsonParser, async function (request, response) {
     try {
+        const shallow = !!request.body.shallow;
         const files = fs.readdirSync(request.user.directories.characters);
         const pngFiles = files.filter(file => file.endsWith('.png'));
-        const processingPromises = pngFiles.map(file => processCharacter(file, request.user.directories));
+        const processingPromises = pngFiles.map(file => processCharacter(file, request.user.directories, { shallow }));
         const data = (await Promise.all(processingPromises)).filter(c => c.name);
         return response.send(data);
     } catch (err) {

             return response.sendStatus(404);
+        }
-        const data = await processCharacter(item, request.user.directories);
+        const data = await processCharacter(item, request.user.directories, { shallow: false });
         return response.send(data);
     } catch (err) {