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

@@ -1167,7 +1190,7 @@ function registerWorldInfoSlashCommands() {
1167	1190	}
1168	1191	break;
1169	1192	default:
1170	1193	fieldValue = entry[field] ?? newWorldInfoEntryDefinition[field]?.default;
1171	1194	}
1172	1195
1173	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).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	3708	* Use `newEntryTemplate` if you just need the template that contains default values
3654	3709	*
3655	3710	* @type {{[key: string]: { default: any, type: string, excludeFromTemplate?: boolean }WIEntryFieldDefinition}}
3656	3711	*/
3657	3712	export const newWorldInfoEntryDefinition = {
3658	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, trigger = ${globalScanData.trigger})${isDryRun ? ' (DRY RUN)' : ''} ---`);
     // Combine the chat

         // Loop and find all entries that can activate here
         let activatedNow = new Set();
         for (letconst 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 ?? [],
             },
         };