28bad647 · permissionBRICK/SillyTavern

default/config.yaml+2 -2 Viewed

   # 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 in MB
+  # The maximum amount of memory that parsed character cards can use. Set to 0 to disable memory caching.
-  cardsCacheCapacity: 100
+  memoryCacheCapacity: '100mb'
 # Allow secret keys exposure via API
 allowKeysExposure: false

post-install.js+2 -2 Viewed

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

src/endpoints/characters.js+7 -8 Viewed

 import { importRisuSprites } from './sprites.js';
 const defaultAvatarPath = './public/img/ai4.png';
-// KV-store for parsed character data
-const cacheCapacity = Number(getConfigValue('performance.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

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

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

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 {number} maxMemoryInBytes - The maximum allowed memory in bytes for string values.
+     * @param {string} cacheCapacity - Maximum memory usage in human-readable format (e.g., '1 GB').
      */
-    constructor(maxMemoryInBytes) {
+    constructor(cacheCapacity) {
-        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;
+        }

Use human-readable memory cache capacity in config