6efa36bd · permissionBRICK/SillyTavern

  */
 class WorldInfoBuffer {
     /**
      * @type {Map<string, object[]>} ArrayMap of entries that need to be activated no matter what
      */
     static externalActivations = []new Map();
     /**
      * @type {string[]} Array of messages sorted by ascending depth

+    }
     /**
      * Check ifGet the currentexternally activated version of the entry, isif externallythere activatedis one.
      * @param {object} entry WI entry to check
      * @returns {booleanobject|null} Truethe external version if the entry is forcefully activated, null otherwise
      */
     isExternallyActivatedgetExternallyActivated(entry) {
         // Entries could be copied with structuredClone, so we need to compare them by string representation
 -        return WorldInfoBuffer.externalActivations.some(x => JSON.stringify(x) === JSON.stringify(entry));
 +        return WorldInfoBuffer.externalActivations.get(`${entry.world}.${entry.uid}`);
+    }
     /**
      * Clean-up the external effects for entries.
      */
     resetExternalEffects() {
 -        WorldInfoBuffer.externalActivations.splice(0, WorldInfoBuffer.externalActivations.length);
 +        WorldInfoBuffer.externalActivations = new Map();
+    }
     /**

     worldInfoString = worldInfoBefore + worldInfoAfter;
     if (!isDryRun && activatedWorldInfo.allActivatedEntries && activatedWorldInfo.allActivatedEntries.size > 0) {
         const arg = Array.from(activatedWorldInfo.allActivatedEntries.values());
         await eventSource.emit(event_types.WORLD_INFO_ACTIVATED, arg);
+    }

     });
     eventSource.on(event_types.WORLDINFO_FORCE_ACTIVATE, (entries) => {
 -        WorldInfoBuffer.externalActivations.push(...entries);
 +        for (const entry of entries) {
 +            if (!Object.hasOwn(entry, 'world') || !Object.hasOwn(entry, 'uid')) {
 +                console.error('WORLDINFO_FORCE_ACTIVATE requires all entries to have both world and uid fields, entry IGNORED');
 +            } else {
 +                WorldInfoBuffer.externalActivations.set(`${entry.world}.${entry.uid}`, entry);
 +            }
 +        }
     });
     // Add slash commands

  * @param {string[]} chat The chat messages to scan, in reverse order.
  * @param {number} maxContext The maximum context size of the generation.
  * @param {boolean} isDryRun Whether to perform a dry run.
  * @typedef {{ worldInfoBefore: string, worldInfoAfter: string, EMEntries: any[], WIDepthEntries: any[], allActivatedEntries: SetMap<string, any> }} WIActivated
  * @returns {Promise<WIActivated>} The world info activated.
  */
 export async function checkWorldInfo(chat, maxContext, isDryRun) {

     let scanState = scan_state.INITIAL;
     let token_budget_overflowed = false;
     let count = 0;
     let allActivatedEntries = new SetMap();
     let failedProbabilityChecks = new Set();
     let allActivatedText = '';

     !isDryRun && timedEffects.checkTimedEffects();
     if (sortedEntries.length === 0) {
         return { worldInfoBefore: '', worldInfoAfter: '', WIDepthEntries: [], EMEntries: [], allActivatedEntries: new SetMap() };
+    }
     /** @type {number[]} Represents the delay levels for entries that are delayed until recursion */

@@ -3789,7 +3795,7 @@ export async function checkWorldInfo(chat, maxContext, isDryRun) {
3789	3795	}
3790	3796
3791	3797	// Already processed, considered and then skipped entries should still be skipped
3792	3798	if (failedProbabilityChecks.has(entry) \|\| allActivatedEntries.has(`${entry.world}.${entry.uid}`)) {
3793	3799	continue;
3794	3800	}
3795	3801

                 continue;
+            }
 +            if (buffer.getExternallyActivated(entry)) {
 +                log('externally activated');
 +                activatedNow.add(buffer.getExternallyActivated(entry));
 +                continue;
 +            }
++
             if (entry.decorators.includes('@@activate')) {
                 log('activated by @@activate decorator');
                 activatedNow.add(entry);

                 continue;
+            }
 -            if (buffer.isExternallyActivated(entry)) {
 -                log('externally activated');
 -                activatedNow.add(entry);
 -                continue;
 -            }
+-
             if (isSticky) {
                 log('activated because active sticky');
                 activatedNow.add(entry);

@@ -4039,7 +4045,7 @@ export async function checkWorldInfo(chat, maxContext, isDryRun) {
4039	4045	break;
4040	4046	}
4041	4047
4042		- allActivatedEntries.add(entry);
	4048	+ allActivatedEntries.set(`${entry.world}.${entry.uid}`, entry);
4043	4049	console.debug(`[WI] Entry ${entry.uid} activation successful, adding to prompt`, entry);
4044	4050	}
4045	4051

     // Appends from insertion order 999 to 1. Use unshift for this purpose
     // TODO (kingbri): Change to use WI Anchor positioning instead of separate top/bottom arrays
     [...allActivatedEntries.values()].sort(sortFn).forEach((entry) => {
         const regexDepth = entry.position === world_info_position.atDepth ? (entry.depth ?? DEFAULT_DEPTH) : null;
         const content = getRegexedString(entry.content, regex_placement.WORLD_INFO, { depth: regexDepth, isMarkdown: false, isPrompt: true });

         context.setExtensionPrompt(NOTE_MODULE_NAME, ANWithWI, chat_metadata[metadata_keys.position], chat_metadata[metadata_keys.depth], extension_settings.note.allowWIScan, chat_metadata[metadata_keys.role]);
+    }
     !isDryRun && timedEffects.setTimedEffects(Array.from(allActivatedEntries.values()));
     buffer.resetExternalEffects();
     timedEffects.cleanUp();
     console.log(`[WI] Adding ${allActivatedEntries.size} entries to prompt`, Array.from(allActivatedEntries.values()));
     console.debug('[WI] --- DONE ---');
     return { worldInfoBefore, worldInfoAfter, EMEntries, WIDepthEntries, allActivatedEntries: allActivatedEntries.values() };
+}
 /**

 /**
  * Filters entries by inclusion groups.
  * @param {object[]} newEntries Entries activated on current recursion level
  * @param {SetMap<string, object>} allActivatedEntries SetMap of all activated entries
  * @param {WorldInfoBuffer} buffer The buffer to use for scanning
  * @param {number} scanState The current scan state
  * @param {WorldInfoTimedEffects} timedEffects The timed effects currently active

             continue;
+        }
         if (Array.from(allActivatedEntries.values()).some(x => x.group === key)) {
             console.debug(`[WI] Skipping inclusion group check, group '${key}' was already activated`);
             // We need to forcefully deactivate all other entries in the group
             removeAllBut(group, null, false);

Expand WORLD_INFO_FORCE_ACTIVATE API to allow for dynamically modified Lorebook entries