Add generation type triggers to world info (#4286) * Add generation type triggers to world info * Simplify includes check * Refactor getEntryField validation and default value handling * Remove invalid attribute * Check for a valid trigger

c292f6416322ba39892c580f4901a28566b6b9ad

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

Signed

Parents: 786d8f43db00c2c3d640cdf485c3e1b7406c0e4b

public/css/world-info.css+7 -0 Viewed

     display: none;
+}
+.world_entry label[for="__invisible"] {
+    visibility: hidden;
+    pointer-events: none;
+    opacity: 0;
+    width: 0;
+}
 #WIMultiSelector .select2-container .select2-selection--multiple {
     max-height: 25vh;
     overflow-y: auto;

public/index.html+24 -0 Viewed

                             </select>
                         </div>
                     </div>
+                    <div class="flex4">
+                        <div class="flex-container justifySpaceBetween">
+                            <small>
+                                <span data-i18n="Filter to Generation Triggers">
+                                    Filter to Generation Triggers
+                                </span>
+                            </small>
+                            <!-- Not a real control. Used to make label heights even. -->
+                            <label class="checkbox_label" for="__invisible">
+                                <input type="checkbox" name="__invisible">
+                                <span><small>&nbsp;</small></span>
+                            </label>
+                        </div>
+                        <div class="range-block-range">
+                            <select name="triggers" multiple>
+                                <option data-i18n="Normal" value="normal">Normal</option>
+                                <option data-i18n="Continue" value="continue">Continue</option>
+                                <option data-i18n="Impersonate" value="impersonate">Impersonate</option>
+                                <option data-i18n="Swipe" value="swipe">Swipe</option>
+                                <option data-i18n="Regenerate" value="regenerate">Regenerate</option>
+                                <option data-i18n="Quiet" value="quiet">Quiet</option>
+                            </select>
+                        </div>
+                    </div>
                 </div>
                 <div name="WIEntryBottomControls" class="flex-container flex1 justifySpaceBetween world_entry_form_horizontal">
                     <div class="flex-container flexFlowColumn flexNoGap  wi-enter-footer-text">

public/script.js+3 -1 Viewed

     renderPaginationDropdown,
     paginationDropdownChangeHandler,
 } from './scripts/utils.js';
-import { debounce_timeout, IGNORE_SYMBOL } from './scripts/constants.js';
+import { debounce_timeout, GENERATION_TYPE_TRIGGERS, IGNORE_SYMBOL } from './scripts/constants.js';
 import { cancelDebouncedMetadataSave, doDailyExtensionUpdatesCheck, extension_settings, initExtensions, loadExtensionSettings, runGenerationInterceptors, saveMetadataDebounced } from './scripts/extensions.js';
 import { COMMENT_NAME_DEFAULT, CONNECT_API_MAP, executeSlashCommandsOnChatInput, initDefaultSlashCommands, isExecutingCommandsFromChatInput, pauseScriptExecution, stopScriptExecution, UNIQUE_APIS } from './scripts/slash-commands.js';

     // Make quiet prompt available for WIAN
     setExtensionPrompt('QUIET_PROMPT', quiet_prompt || '', extension_prompt_types.IN_PROMPT, 0, true);
     const chatForWI = coreChat.map(x => world_info_include_names ? `${x.name}: ${x.mes}` : x.mes).reverse();
+    /** @type {import('./scripts/world-info.js').WIGlobalScanData} */
     const globalScanData = {
         personaDescription: persona,
         characterDescription: description,

         characterDepthPrompt: charDepthPrompt,
         scenario: scenario,
         creatorNotes: creatorNotes,
+        trigger: GENERATION_TYPE_TRIGGERS.includes(type) ? type : 'normal',
     };
     const { worldInfoString, worldInfoBefore, worldInfoAfter, worldInfoExamples, worldInfoDepth } = await getWorldInfoPrompt(chatForWI, this_max_context, dryRun, globalScanData);
     setExtensionPrompt('QUIET_PROMPT', '', extension_prompt_types.IN_PROMPT, 0, true);

public/scripts/constants.js+12 -0 Viewed

  * https://ai.google.dev/gemini-api/docs/video-understanding#supported-formats
  */
 export const VIDEO_EXTENSIONS = ['mp4', 'avi', 'mov', 'wmv', 'flv', 'webm', '3gp', 'mkv', 'mpg'];
+/**
+ * Known generation triggers that can be passed to Generate function.
+ */
+export const GENERATION_TYPE_TRIGGERS = [
+    'normal',
+    'continue',
+    'impersonate',
+    'swipe',
+    'regenerate',
+    'quiet',
+];

public/scripts/world-info.js+85 -25 Viewed

 import { getTokenCountAsync } from './tokenizers.js';
 import { power_user } from './power-user.js';
 import { getTagKeyForEntity } from './tags.js';
-import { debounce_timeout } from './constants.js';
+import { debounce_timeout, GENERATION_TYPE_TRIGGERS } from './constants.js';
 import { getRegexedString, regex_placement } from './extensions/regex/engine.js';
 import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { SlashCommand } from './slash-commands/SlashCommand.js';

  * @property {string} characterDepthPrompt Character depth prompt (sometimes referred to as character notes)
  * @property {string} scenario Character defined scenario
  * @property {string} creatorNotes Character creator notes
+ * @property {string} trigger The type that triggered the scan, e.g. 'normal', 'continue', etc.
  */
 /**

  * @typedef TimedEffectType Type of timed effect
  * @type {'sticky'|'cooldown'|'delay'}
  */
+/**
+ * @typedef {object} WIPromptResult
+ * @property {string} worldInfoString - Complete world info string
+ * @property {string} worldInfoBefore - World info that goes before the prompt
+ * @property {string} worldInfoAfter - World info that goes after the prompt
+ * @property {Array} worldInfoExamples - Array of example entries
+ * @property {Array} worldInfoDepth - Array of depth entries
+ * @property {Array} anBefore - Array of entries before Author's Note
+ * @property {Array} anAfter - Array of entries after Author's Note
+ */
+/**
+ * @typedef {object} WIActivated
+ * @property {string} worldInfoBefore The world info before the chat.
+ * @property {string} worldInfoAfter The world info after the chat.
+ * @property {any[]} EMEntries The entries for examples.
+ * @property {any[]} WIDepthEntries The depth entries.
+ * @property {any[]} ANBeforeEntries The entries before Author's Note.
+ * @property {any[]} ANAfterEntries The entries after Author's Note.
+ * @property {Set<any>} allActivatedEntries All entries.
+ */
+/**
+ * @typedef {object} WIEntryFieldDefinition
+ * @property {any} default - Default value for the field
+ * @property {string} type - Type of the field, can be 'string', 'number', 'boolean', 'array', 'enum'
+ * @property {boolean} [excludeFromTemplate=false] - Whether to exclude this field from the template
+ * @property {(value: any) => boolean} [arrayFilter] - Optional filter function for array fields to filter out unwanted values
+ */
 // End typedef area
 /**

  * @param {number} maxContext - The maximum context size of the generation.
  * @param {boolean} isDryRun - If true, the function will not emit any events.
  * @param {WIGlobalScanData} globalScanData Chat independent context to be scanned
- * @typedef {object} WIPromptResult
- * @property {string} worldInfoString - Complete world info string
- * @property {string} worldInfoBefore - World info that goes before the prompt
- * @property {string} worldInfoAfter - World info that goes after the prompt
- * @property {Array} worldInfoExamples - Array of example entries
- * @property {Array} worldInfoDepth - Array of depth entries
- * @property {Array} anBefore - Array of entries before Author's Note
- * @property {Array} anAfter - Array of entries after Author's Note
  * @returns {Promise<WIPromptResult>} The world info string and depth.
  */
 export async function getWorldInfoPrompt(chat, maxContext, isDryRun, globalScanData) {

@@ -1139,7 +1162,7 @@ function registerWorldInfoSlashCommands() {
1139	return '';	1162	return '';
1140	}	1163	}
1141		1164
1142	if (newWorldInfoEntryTemplate[field] === undefined) {	1165	if (!Object.hasOwn(newWorldInfoEntryDefinition, field)) {
1143	toastr.warning('Valid field name is required');	1166	toastr.warning('Valid field name is required');
1144	return '';	1167	return '';
1145	}	1168	}

@@ -1167,7 +1190,7 @@ function registerWorldInfoSlashCommands() {
1167	}	1190	}
1168	break;	1191	break;
1169	default:	1192	default:
1170	fieldValue = entry[field];	1193	fieldValue = entry[field] ?? newWorldInfoEntryDefinition[field]?.default;
1171	}	1194	}
1172		1195
1173	if (fieldValue === undefined) {	1196	if (fieldValue === undefined) {

             return '';
+        }
-        if (newWorldInfoEntryTemplate[field] === undefined) {
+        if (!Object.hasOwn(newWorldInfoEntryDefinition, field)) {
             toastr.warning('Valid field name is required');
             return '';
+        }
+        // Init a default value for the field if it does not exist
+        if (!Object.hasOwn(entry, field)) {
+            entry[field] = newWorldInfoEntryDefinition[field].default;
+        }
+        // Use an array filter if it exists for the field
+        const arrayFilter = newWorldInfoEntryDefinition[field]?.arrayFilter || (() => true);
         // handle special cases, otherwise execute default logic
         let tagNames;
         let charNames;

                 break;
             default:
                 if (Array.isArray(entry[field])) {
-                    entry[field] = parseStringArray(value);
+                    entry[field] = parseStringArray(value).filter(arrayFilter);
                 } else if (typeof entry[field] === 'boolean') {
                     entry[field] = isTrueBoolean(value);
                 } else if (typeof entry[field] === 'number') {

     'sticky': 'extensions.sticky',
     'cooldown': 'extensions.cooldown',
     'delay': 'extensions.delay',
+    'triggers': 'extensions.triggers',
 };
 /** Checks the state of the current search, and adds/removes the search sorting option accordingly */

         automationIdInput.val(entry.automationId ?? '').trigger('input', { noSave: true });
         setTimeout(() => createEntryInputAutocomplete(automationIdInput, getAutomationIdCallback(data)), 1);
+        // Generation Type Triggers
+        const generationTypeTriggers = editTemplate.find('select[name="triggers"]');
+        generationTypeTriggers.data('uid', entry.uid);
+        generationTypeTriggers.on('input', async function (_, { noSave = false } = {}) {
+            const uid = $(this).data('uid');
+            const value = $(this).val();
+            data.entries[uid].triggers = Array.isArray(value) ? value : [];
+            setWIOriginalDataValue(data, uid, 'extensions.triggers', data.entries[uid].triggers);
+            !noSave && await saveWorldInfo(name, data);
+        });
+        if (!isMobile()) {
+            generationTypeTriggers.select2({
+                placeholder: t`All types (default)`,
+                width: '100%',
+                closeOnSelect: false,
+                allowClear: true,
+            });
+        }
+        generationTypeTriggers
+            .val(Array.isArray(entry.triggers) ? entry.triggers : [])
+            .trigger('input', { noSave: true })
+            .trigger('change');
         countTokensDebounced(counter, contentInput.val());
         editTemplate.find('.inline-drawer-content').css('display', 'none');

@@ -3652,7 +3707,7 @@ export async function deleteWorldInfoEntry(data, uid, { silent = false } = {}) {
3652	*	3707	*
3653	* Use `newEntryTemplate` if you just need the template that contains default values	3708	* Use `newEntryTemplate` if you just need the template that contains default values
3654	*	3709	*
3655	* @type {{[key: string]: { default: any, type: string, excludeFromTemplate?: boolean }}}	3710	* @type {{[key: string]: WIEntryFieldDefinition}}
3656	*/	3711	*/
3657	export const newWorldInfoEntryDefinition = {	3712	export const newWorldInfoEntryDefinition = {
3658	key: { default: [], type: 'array' },	3713	key: { default: [], type: 'array' },

     characterFilterNames: { default: [], type: 'array', excludeFromTemplate: true },
     characterFilterTags: { default: [], type: 'array', excludeFromTemplate: true },
     characterFilterExclude: { default: false, type: 'boolean', excludeFromTemplate: true },
+    triggers: { default: [], type: 'array', arrayFilter: (value) => GENERATION_TYPE_TRIGGERS.includes(value) },
 };
 export const newWorldInfoEntryTemplate = Object.fromEntries(

  * @param {number} maxContext The maximum context size of the generation.
  * @param {boolean} isDryRun Whether to perform a dry run.
  * @param {WIGlobalScanData} globalScanData Chat independent context to be scanned
- * @typedef {object} WIActivated
- * @property {string} worldInfoBefore The world info before the chat.
- * @property {string} worldInfoAfter The world info after the chat.
- * @property {any[]} EMEntries The entries for examples.
- * @property {any[]} WIDepthEntries The depth entries.
- * @property {any[]} ANBeforeEntries The entries before Author's Note.
- * @property {any[]} ANAfterEntries The entries after Author's Note.
- * @property {Set<any>} allActivatedEntries All entries.
  * @returns {Promise<WIActivated>} The world info activated.
  */
 //MARK: checkWorldInfo
 export async function checkWorldInfo(chat, maxContext, isDryRun, globalScanData) {
     const context = getContext();
     const buffer = new WorldInfoBuffer(chat, globalScanData);
-    console.debug(`[WI] --- START WI SCAN (on ${chat.length} messages)${isDryRun ? ' (DRY RUN)' : ''} ---`);
+    console.debug(`[WI] --- START WI SCAN (on ${chat.length} messages, trigger = ${globalScanData.trigger})${isDryRun ? ' (DRY RUN)' : ''} ---`);
     // Combine the chat

         // Loop and find all entries that can activate here
         let activatedNow = new Set();
-        for (let entry of sortedEntries) {
+        for (const entry of sortedEntries) {
             // Logging preparation
             let headerLogged = false;
             function log(...args) {

                 continue;
+            }
+            // Check for generation type trigger filter
+            if (Array.isArray(entry.triggers) && entry.triggers.length > 0) {
+                const isTriggered = entry.triggers.includes(globalScanData.trigger);
+                if (!isTriggered) {
+                    log(`skipped by generation type trigger filter (${globalScanData.trigger} ∉ ${entry.triggers})`);
+                    continue;
+                }
+            }
             // Check if this entry applies to the character or if it's excluded
             if (entry.characterFilter && entry.characterFilter?.names?.length > 0) {
                 const nameIncluded = entry.characterFilter.names.includes(getCharaFilename());

             sticky: null,
             cooldown: null,
             delay: null,
+            triggers: [],
         };
     });

             sticky: null,
             cooldown: null,
             delay: null,
+            triggers: [],
         };
     });

             sticky: null,
             cooldown: null,
             delay: null,
+            triggers: [],
         };
     });

             matchScenario: entry.extensions?.match_scenario ?? false,
             matchCreatorNotes: entry.extensions?.match_creator_notes ?? false,
             extensions: entry.extensions ?? {},
+            triggers: entry.extensions?.triggers || [],
         };
     });

src/endpoints/characters.js+1 -0 Viewed

                 match_character_depth_prompt: entry.matchCharacterDepthPrompt ?? false,
                 match_scenario: entry.matchScenario ?? false,
                 match_creator_notes: entry.matchCreatorNotes ?? false,
+                triggers: entry.triggers ?? [],
             },
         };