4d81dfb0 · permissionBRICK/SillyTavern

default/config.yaml+8 -2 Viewed

 # -- DATA CONFIGURATION --
 # Root directory for user data storage
 dataRoot: ./data
 -# The maximum amount of memory that parsed character cards can use in MB
 -cardsCacheCapacity: 100
 # -- SERVER CONFIGURATION --
 # Listen for incoming connections
 listen: false

   # Maximum thumbnail dimensions per type [width, height]
   dimensions: { 'bg': [160, 90], 'avatar': [96, 144] }
 +# PERFORMANCE-RELATED CONFIGURATION
 +performance:
 +  # Enables lazy loading of character cards. Improves performances with large card libraries.
 +  # May have compatibility issues with some extensions.
 +  lazyLoadCharacters: false
 +  # The maximum amount of memory that parsed character cards can use. Set to 0 to disable memory caching.
 +  memoryCacheCapacity: '100mb'
++
 # Allow secret keys exposure via API
 allowKeysExposure: false
 # Skip new default content checks

package-lock.json+9 -0 Viewed

                 "bing-translate-api": "^4.0.2",
                 "body-parser": "^1.20.2",
                 "bowser": "^2.11.0",
 +                "bytes": "^3.1.2",
                 "chalk": "^5.4.1",
                 "command-exists": "^1.2.9",
                 "compression": "^1.8.0",

             },
             "devDependencies": {
                 "@types/archiver": "^6.0.3",
 +                "@types/bytes": "^3.1.5",
                 "@types/command-exists": "^1.2.3",
                 "@types/compression": "^1.7.5",
                 "@types/cookie-parser": "^1.4.8",

                 "@types/node": "*"
+            }
         },
 +        "node_modules/@types/bytes": {
 +            "version": "3.1.5",
 +            "resolved": "https://registry.npmjs.org/@types/bytes/-/bytes-3.1.5.tgz",
 +            "integrity": "sha512-VgZkrJckypj85YxEsEavcMmmSOIzkUHqWmM4CCyia5dc54YwsXzJ5uT4fYxBQNEXx+oF1krlhgCbvfubXqZYsQ==",
 +            "dev": true,
 +            "license": "MIT"
 +        },
         "node_modules/@types/cacheable-request": {
             "version": "6.0.3",
             "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz",

package.json+3 -1 Viewed

         "bing-translate-api": "^4.0.2",
         "body-parser": "^1.20.2",
         "bowser": "^2.11.0",
 +        "bytes": "^3.1.2",
         "chalk": "^5.4.1",
         "command-exists": "^1.2.9",
         "compression": "^1.8.0",

     "version": "1.12.12",
     "scripts": {
         "start": "node server.js",
 +        "debug": "node --inspect server.js",
         "electron": "electron ./src/electron",
 -        "debug": "node server.js --inspect",
         "start:deno": "deno run --allow-run --allow-net --allow-read --allow-write --allow-sys --allow-env server.js",
         "start:bun": "bun server.js",
         "start:no-csrf": "node server.js --disableCsrf",

     "main": "server.js",
     "devDependencies": {
         "@types/archiver": "^6.0.3",
 +        "@types/bytes": "^3.1.5",
         "@types/command-exists": "^1.2.3",
         "@types/compression": "^1.7.5",
         "@types/cookie-parser": "^1.4.8",

post-install.js+5 -0 Viewed

         newKey: 'logging.minLogLevel',
         migrate: (value) => value,
     },
 +    {
 +        oldKey: 'cardsCacheCapacity',
 +        newKey: 'performance.memoryCacheCapacity',
 +        migrate: (value) => `${value}mb`,
 +    },
     // uncomment one release after 1.12.13
     /*
+    {

public/script.js+38 -3 Viewed

     const response = await fetch('/api/characters/all', {
         method: 'POST',
         headers: getRequestHeaders(),
         body: JSON.stringify({}),
 -            '': '',
 -        }),
     });
     if (response.ok === true) {
         characters.splice(0, characters.length);

     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;
 +    }
++
 +    /** @type {import('./scripts/char-data.js').v1CharData} */
 +    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/RossAscends-mods.js+4 -1 Viewed

     const entities = getEntitiesList({ doFilter: false });
     const container = $('#right-nav-panel .hotswap');
 -    const favs = entities.filter(x => x.item.fav || x.item.fav == 'true');
 +    // Hard limit is required because even if all hotswaps don't fit the screen, their images would still be loaded
 +    // 25 is roughly calculated as the maximum number of favs that can fit an ultrawide monitor with the default theme
 +    const FAVS_LIMIT = 25;
 +    const favs = entities.filter(x => x.item.fav || x.item.fav == 'true').slice(0, FAVS_LIMIT);
     //helpful instruction message if no characters are favorited
     if (favs.length == 0) {

public/scripts/char-data.js+1 -0 Viewed

  * @property {string} chat - name of the current chat file chat
  * @property {string} avatar - file name of the avatar image (acts as a unique identifier)
  * @property {string} json_data - the full raw JSON data of the character
 + * @property {boolean?} shallow - if the data is shallow (lazy-loaded)
  */
 export default 0;// now this file is a module

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_idgroupId, groupMember, isDelete) {
     const id = groupMember.data('id');
     const thisGroup = groups.find((x) => x.id == chat_idgroupId);
     const membersArray = thisGroup?.members ?? newGroupMembers;
     if (isDelete) {

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

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

     return false;
+}
 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/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, 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+47 -15 Viewed

 import { importRisuSprites } from './sprites.js';
 const defaultAvatarPath = './public/img/ai4.png';
 -// KV-store for parsed character data
 -const cacheCapacity = Number(getConfigValue('cardsCacheCapacity', 100, 'number')); // MB
 // With 100 MB limit it would take roughly 3000 characters to reach this limit
 -const characterDataCache = new MemoryLimitedMap(1024 * 1024 * cacheCapacity);
 +const memoryCacheCapacity = getConfigValue('performance.memoryCacheCapacity', '100mb');
 +const memoryCache = new MemoryLimitedMap(memoryCacheCapacity);
 // Some Android devices require tighter memory management
 const isAndroid = process.platform === 'android';
 +// Use shallow character data for the character list
 +const useShallowCharacters = !!getConfigValue('performance.lazyLoadCharacters', false, 'boolean');
 /**
  * Reads the character card from the specified image file.

 async function readCharacterData(inputFile, inputFormat = 'png') {
     const stat = fs.statSync(inputFile);
     const cacheKey = `${inputFile}-${stat.mtimeMs}`;
     if (characterDataCachememoryCache.has(cacheKey)) {
         return characterDataCachememoryCache.get(cacheKey);
+    }
     const result = parse(inputFile, inputFormat);
     !isAndroid && characterDataCachememoryCache.set(cacheKey, result);
     return result;
+}

@@ -60,12 +61,12 @@ async function readCharacterData(inputFile, inputFormat = 'png') {
60	61	async function writeCharacterData(inputFile, data, outputFile, request, crop = undefined) {
61	62	try {
62	63	// Reset the cache
63	64	for (const key of characterDataCachememoryCache.keys()) {
64	65	if (Buffer.isBuffer(inputFile)) {
65	66	break;
66	67	}
67	68	if (key.startsWith(inputFile)) {
68	69	characterDataCachememoryCache.delete(key);
69	70	break;
70	71	}
71	72	}

 };
 /**
 + * 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 {
 +        shallow: true,
 +        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),
 +            },
 +        },
 +    };
 +};
++
 +/**
  * 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, { 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}`);

     try {
         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, { shallow: useShallowCharacters }));
         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, { shallow: false });
         return response.send(data);
     } catch (err) {

 });
 router.post('/chats', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
 -    if (!request.body) return response.sendStatus(400);
 +    try {
 +        if (!request.body) return response.sendStatus(400);
             const characterDirectory = (request.body.avatar_url).replace('.png', '');
 -    try {
         const chatsDirectory = path.join(request.user.directories.chats, characterDirectory);
         if (!fs.existsSync(chatsDirectory)) {

src/util.js+8 -7 Viewed

 import { default as simpleGit } from 'simple-git';
 import chalk from 'chalk';
 import { LOG_LEVELS } from './constants.js';
 +import bytes from 'bytes';
 /**
  * Parsed config object.

 export class MemoryLimitedMap {
     /**
      * Creates an instance of MemoryLimitedMap.
      * @param {numberstring} maxMemoryInBytescacheCapacity - The maximum allowedMaximum memory usage in byteshuman-readable forformat string(e.g., values'1 GB').
      */
     constructor(maxMemoryInBytescacheCapacity) {
 -        if (typeof maxMemoryInBytes !== 'number' || maxMemoryInBytes <= 0 || isNaN(maxMemoryInBytes)) {
 +        this.maxMemory = bytes.parse(cacheCapacity) ?? 0;
 -            console.warn('Invalid maxMemoryInBytes, using a fallback value of 1 GB.');
 -            maxMemoryInBytes = 1024 * 1024 * 1024; // 1 GB
 -        }
 -        this.maxMemory = maxMemoryInBytes;
         this.currentMemory = 0;
         this.map = new Map();
         this.queue = [];

      * @param {string} value
      */
     set(key, value) {
 +        if (this.maxMemory <= 0) {
 +            return;
 +        }
++
         if (typeof key !== 'string' || typeof value !== 'string') {
             return;
+        }

Merge pull request #3614 from SillyTavern/char-shallow Lazy load characters