Add new WI position 'outlet' to expose WI entries triggered to be placed as macros literally anywhere (#4523) * feat: add outlet prompt support for world info entries * feat: add outlet name field with autocomplete for world info entries * feat: add outlet entries for world info support to WI parsing * feat: add tooltip and validation for WI outlet name entries * Trim macro outlet name Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * refactor: consolidate WI injection cleanup and fix strict equality comparison * fix: update outlet macro regex pattern to use double colon delimiter * fix: replace carriage returns with newlines in WI entry outlet tooltip * fix: add null checks and array validation for WI outlet entries handling * feat: add outletName field to world info entry definition schema (supports /setwientryfield command) * fix: add outletName field to export of character lore books * do not remove outlet name on position change, but filter out for auto complete * Match WI extensions field name Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com> * outlet name being used in char WI import too * docs: add outlet macro documentation to help template * be explicit about risu/novel/agnai wi not supporting outlets * Inject A/N and TC sysprompt after populating outlets --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

7cba4e88ab4c79257be3438138ceac327dda0aeb

Wolfsblvt <wolfsblvt@gmail.com>

Signed

Parents: 1fe8d96ab28bfc779840e74eff818e1cc86d14e6

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

     display: none;
+}
+.world_entry:not(:has(select[name="position"] option[value="7"]:checked)) .world_entry_form_control:has(input[name="outletName"]) {
+    display: none;
+}
 .world_entry label[for="__invisible"] {
     visibility: hidden;
     pointer-events: none;

public/index.html+10 -0 Viewed

                         </div>
                     </div>
                     <div name="perEntryOverridesBlock" class="flex-container wide100p alignitemscenter">
+                        <div class="world_entry_form_control flex1" title="Set the outlet name for this WI entry.&#10;&#10;WI entries with position 'outlet' will not be added to the prompt automatically. Instead, they will be collected and can be used as a macro in the prompt.&#10;Add {{outlet::YourName}} to the prompt in any place you want to add all WI entries this specific outlet." data-i18n="[title]wi_outlet_name">
+                            <small class="textAlignCenter">
+                                <span data-i18n="Outlet Name">Outlet Name</span>
+                                <div class="fa-solid fa-circle-info opacity50p"></div>
+                            </small>
+                            <input class="text_pole margin0" name="outletName" type="text" placeholder="Outlet Name" data-i18n="[placeholder]Outlet Name">
+                        </div>
                         <div class="world_entry_form_control flex1">
                             <small class="textAlignCenter" data-i18n="Scan Depth">Scan Depth</small>
                             <input class="text_pole margin0" name="scanDepth" type="number" placeholder="Use global setting" data-i18n="[placeholder]Use global setting" max="1000">

                                                 <option value="4" data-role="2" data-i18n="at Depth AI">
                                                     @D 🤖
                                                 </option>
+                                                <option value="7" data-role="" data-i18n="Outlet">
+                                                    ➡️ Outlet
+                                                </option>
                                             </select>
                                         </div>
                                         <div class="world_entry_form_control wi-enter-footer-text flex-container flexNoGap">

public/script.js+32 -25 Viewed

         creatorNotes,
     } = getCharacterCardFields();
-    if (main_api !== 'openai') {
-        if (power_user.sysprompt.enabled) {
-            system = power_user.prefer_character_prompt && system
-                ? substituteParams(system, name1, name2, (power_user.sysprompt.content ?? ''))
-                : baseChatReplace(power_user.sysprompt.content, name1, name2);
-            system = isInstruct ? substituteParams(system, name1, name2, power_user.sysprompt.content) : system;
-        } else {
-            // Nullify if it's not enabled
-            system = '';
-        }
-    }
     // Depth prompt (character-specific A/N)
     removeDepthPrompts();
     const groupDepthPrompts = getGroupDepthPrompts(selected_group, Number(this_chid));

     let mesExamplesArray = parseMesExamples(mesExamples, isInstruct);
-    //////////////////////////////////
-    // Extension added strings
-    // Set non-WI AN
-    setFloatingPrompt();
-    // Add persona description to prompt
-    addPersonaDescriptionExtensionPrompt();
     // Add WI to prompt (and also inject WI to AN value via hijack)
     // Make quiet prompt available for WIAN
     setExtensionPrompt(inject_ids.QUIET_PROMPT, quiet_prompt || '', extension_prompt_types.IN_PROMPT, 0, true);

         creatorNotes: creatorNotes,
         trigger: GENERATION_TYPE_TRIGGERS.includes(type) ? type : 'normal',
     };
-    const { worldInfoString, worldInfoBefore, worldInfoAfter, worldInfoExamples, worldInfoDepth } = await getWorldInfoPrompt(chatForWI, this_max_context, dryRun, globalScanData);
+    const { worldInfoString, worldInfoBefore, worldInfoAfter, worldInfoExamples, worldInfoDepth, outletEntries } = await getWorldInfoPrompt(chatForWI, this_max_context, dryRun, globalScanData);
     setExtensionPrompt(inject_ids.QUIET_PROMPT, '', extension_prompt_types.IN_PROMPT, 0, true);
     // Add message example WI

     if (skipWIAN !== true) {
         console.log('skipWIAN not active, adding WIAN');
         // Add all depth WI entries to prompt
-        flushWIDepthInjections();
+        flushWIInjections();
         if (Array.isArray(worldInfoDepth)) {
             worldInfoDepth.forEach((e) => {
                 const joinedEntries = e.entries.join('\n');
                 setExtensionPrompt(inject_ids.CUSTOM_WI_DEPTH_ROLE(e.depth, e.role), joinedEntries, extension_prompt_types.IN_CHAT, e.depth, false, e.role);
             });
+        }
+        if (outletEntries && typeof outletEntries === 'object' && Object.keys(outletEntries).length > 0) {
+            Object.entries(outletEntries).forEach(([key, value]) => {
+                setExtensionPrompt(inject_ids.CUSTOM_WI_OUTLET(key), value.join('\n'), extension_prompt_types.NONE, 0);
+            });
+        }
     } else {
         console.log('skipping WIAN');
+    }
+    // Set non-WI AN
+    setFloatingPrompt();
+    // Add persona description to prompt
+    addPersonaDescriptionExtensionPrompt();
+    // Prepare the system prompt for Text Completion APIs
+    if (main_api !== 'openai') {
+        if (power_user.sysprompt.enabled) {
+            system = power_user.prefer_character_prompt && system
+                ? substituteParams(system, name1, name2, (power_user.sysprompt.content ?? ''))
+                : baseChatReplace(power_user.sysprompt.content, name1, name2);
+            system = isInstruct ? substituteParams(system, name1, name2, power_user.sysprompt.content) : system;
+        } else {
+            // Nullify if it's not enabled
+            system = '';
+        }
+    }
     // Collect before / after story string injections
     const beforeScenarioAnchor = await getExtensionPrompt(extension_prompt_types.BEFORE_PROMPT);
     const afterScenarioAnchor = await getExtensionPrompt(extension_prompt_types.IN_PROMPT);

@@ -4751,10 +4756,12 @@ async function doChatInject(messages, isContinue) {
4751	return injectedIndices;	4756	return injectedIndices;
4752	}	4757	}
4753		4758
4754	function flushWIDepthInjections() {	4759	function flushWIInjections() {
4755	//prevent custom depth WI entries (which have unique random key names) from duplicating	4760	const depthPrefix = inject_ids.CUSTOM_WI_DEPTH;
		4761	const outletPrefix = inject_ids.CUSTOM_WI_OUTLET('');
		4762
4756	for (const key of Object.keys(extension_prompts)) {	4763	for (const key of Object.keys(extension_prompts)) {
4757	if (key.startsWith(inject_ids.CUSTOM_WI_DEPTH)) {	4764	if (key.startsWith(depthPrefix) \|\| key.startsWith(outletPrefix)) {
4758	delete extension_prompts[key];	4765	delete extension_prompts[key];
4759	}	4766	}
4760	}	4767	}

     showSwipeButtons();
     setGenerationProgress(0);
     flushEphemeralStoppingStrings();
-    flushWIDepthInjections();
+    flushWIInjections();
+}
 export function getNextMessageId(type) {

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

     DEPTH_PROMPT_INDEX: (index) => `DEPTH_PROMPT_${index}`,
     CUSTOM_WI_DEPTH: 'customDepthWI',
     CUSTOM_WI_DEPTH_ROLE: (depth, role) => `customDepthWI_${depth}_${role}`,
+    CUSTOM_WI_OUTLET: (key) => `customWIOutlet_${key}`,
 };
 export const COMETAPI_IGNORE_PATTERNS = [

public/scripts/macros.js+14 -1 Viewed

 import { Handlebars, moment, seedrandom, droll } from '../lib.js';
-import { chat, chat_metadata, main_api, getMaxContextSize, getCurrentChatId, substituteParams, eventSource, event_types } from '../script.js';
+import { chat, chat_metadata, main_api, getMaxContextSize, getCurrentChatId, substituteParams, eventSource, event_types, extension_prompts } from '../script.js';
 import { timestampToMoment, isDigitsOnly, getStringHash, escapeRegex, uuidv4 } from './utils.js';
 import { textgenerationwebui_banned_in_macros } from './textgen-settings.js';
 import { getInstructMacros } from './instruct-mode.js';
 import { getVariableMacros } from './variables.js';
 import { isMobile } from './RossAscends-mods.js';
+import { inject_ids } from './constants.js';
 /**
  * @typedef Macro

+}
 /**
+ * Returns the outlet prompt for a given outlet key.
+ * @param {string} key - The outlet key
+ * @returns {string} The outlet prompt
+ */
+function getOutletPrompt(key) {
+    const value = extension_prompts[inject_ids.CUSTOM_WI_OUTLET(key)]?.value;
+    // Macros should already be parsed, but we'll do it again just in case
+    return substituteParams(value);
+}
+/**
  * Substitutes {{macro}} parameters in a string.
  * @param {string} content - The string to substitute parameters in.
  * @param {EnvObject} env - Map of macro names to the values they'll be substituted with. If the param

         { regex: /{{datetimeformat +([^}]*)}}/gi, replace: (_, format) => moment().format(format) },
         { regex: /{{idle_duration}}/gi, replace: () => getTimeSinceLastMessage() },
         { regex: /{{time_UTC([-+]\d+)}}/gi, replace: (_, offset) => moment().utc().utcOffset(parseInt(offset, 10)).format('LT') },
+        { regex: /{{outlet::(.+?)}}/gi, replace: (_, key) => getOutletPrompt(key.trim()) || '' },
         getTimeDiffMacro(),
         getBannedWordsMacro(),
         getRandomReplaceMacro(),

public/scripts/templates/macros.html+1 -0 Viewed

     <li><tt>&lcub;&lcub;char&rcub;&rcub;</tt> – <span data-i18n="help_macros_16">the Character's name</span></li>
     <li><tt>&lcub;&lcub;version&rcub;&rcub;</tt> – <span data-i18n="help_macros_17">the Character's version number</span></li>
     <li><tt>&lcub;&lcub;charDepthPrompt&rcub;&rcub;</tt> – <span data-i18n="help_macros_charDepthPrompt">the Character's @ Depth Note</span></li>
+    <li><tt>&lcub;&lcub;outlet::(name)&rcub;&rcub;</tt> – <span data-i18n="help_macros_outletName">the WI entry content for the outlet with the specified name</span></li>
     <li><tt>&lcub;&lcub;group&rcub;&rcub;</tt> – <span data-i18n="help_macros_18">a comma-separated list of group member names (including muted) or the character name in solo chats. Alias: &lcub;&lcub;charIfNotGroup&rcub;&rcub;</span></li>
     <li><tt>&lcub;&lcub;groupNotMuted&rcub;&rcub;</tt> – <span data-i18n="help_groupNotMuted">the same as &lcub;&lcub;group&rcub;&rcub;, but excludes muted members</span></li>
     <li><tt>&lcub;&lcub;model&rcub;&rcub;</tt> – <span data-i18n="help_macros_19">a text generation model name for the currently selected API. </span><b data-i18n="Can be inaccurate!">Can be inaccurate!</b></li>

public/scripts/world-info.js+118 -40 Viewed

  * @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
+ * @property {{[key: string]: string[]}} outletEntries - Array of entries to be added to an outlet
  */
 /**

  * @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 {{[key: string]: string[]}} outletEntries - Array of entries to be added to an outlet
  * @property {Set<any>} allActivatedEntries All entries.
  */

     atDepth: 4,
     EMTop: 5,
     EMBottom: 6,
+    outlet: 7,
 };
 export const wi_anchor_position = {

         worldInfoDepth: activatedWorldInfo.WIDepthEntries ?? [],
         anBefore: activatedWorldInfo.ANBeforeEntries ?? [],
         anAfter: activatedWorldInfo.ANAfterEntries ?? [],
+        outletEntries: activatedWorldInfo.outletEntries ?? {},
     };
+}

         contentInput.val(entry.content).trigger('input', { skipCount: true, noSave: true });
         editTemplate.find('.editor_maximize').attr('data-for', contentInputId);
+        // Outlet name
+        const outletNameInput = editTemplate.find('input[name="outletName"]');
+        outletNameInput.data('uid', entry.uid);
+        outletNameInput.on('input', async function (_, { noSave = false } = {}) {
+            const uid = $(this).data('uid');
+            const value = $(this).val();
+            data.entries[uid].outletName = value;
+            setWIOriginalDataValue(data, uid, 'extensions.outlet_name', data.entries[uid].outletName);
+            !noSave && await saveWorldInfo(name, data);
+        });
+        outletNameInput.val(entry.outletName ?? '').trigger('input', { noSave: true });
+        setTimeout(() => createEntryInputAutocomplete(outletNameInput, getOutletNameCallback(data), { allowMultiple: true }), 1);
         // Scan depth
         const scanDepthInput = editTemplate.find('input[name="scanDepth"]');
         scanDepthInput.data('uid', entry.uid);

     return headerTemplate;
+}
 /**
- * Get the inclusion groups for the autocomplete.
+ * Builds a jQuery UI autocomplete callback: (control, request, response) => void
- * @param {any} data WI data
+ * @param {object} [opt={}] - Optional arguments
- * @returns {(input: any, output: any) => any} Callback function for the autocomplete
+ * @param {{entries: Record<string, any>}} [opt.data]   - Your WI data
+ * @param {(entry:any)=>string|string[]|null|undefined} [opt.collectValues] - Extract values from one entry
+ * @param {() => Iterable<string>} [opt.includeExtras] - Optional global extras to include
+ * @param {(ctx:{result:string[], control:JQuery, input:any, haystack:string[]})=>string[]} [opt.postFilter] - Optional final filter step (for special rules like your "group" de-dupe logic)
  */
-function getInclusionGroupCallback(data) {
+function buildAutocompleteCallback({ data, collectValues, includeExtras = () => [], postFilter } = {}) {
     return function (control, input, output) {
         const uid = $(control).data('uid');
-        const thisGroups = String($(control).val()).split(/,\s*/).filter(x => x).map(x => x.toLowerCase());
-        const groups = new Set();
+        // Collect unique values from all *other* entries
-        for (const entry of Object.values(data.entries)) {
+        const values = new Set();
-            // Skip the groups of this entry, because auto-complete should only suggest the ones that are already available on other entries
+        for (const entry of Object.values(data.entries ?? {})) {
-            if (entry.uid == uid) continue;
+            if (entry?.uid == uid) continue;
-            if (entry.group) {
+            const raw = collectValues(entry);
-                entry.group.split(/,\s*/).filter(x => x).forEach(x => groups.add(x));
+            if (raw == null) continue;
+            const arr = Array.isArray(raw) ? raw : [raw];
+            for (const v of arr) {
+                const s = String(v).trim();
+                if (s) values.add(s);
+            }
+        }
-        const haystack = Array.from(groups);
+        // Add optional global extras
-        haystack.sort((a, b) => a.localeCompare(b));
+        for (const v of includeExtras()) {
-        const needle = input.term.toLowerCase();
+            const s = String(v).trim();
-        const hasExactMatch = haystack.findIndex(x => x.toLowerCase() == needle) !== -1;
+            if (s) values.add(s);
-        const result = haystack.filter(x => x.toLowerCase().includes(needle) && (!thisGroups.includes(x) || hasExactMatch && thisGroups.filter(g => g == x).length == 1));
+        }
+        // Sort stable & locale-aware
+        const haystack = Array.from(values).sort((a, b) => a.localeCompare(b));
+        // Case-insensitive contains
+        const needle = String(input.term ?? '').toLowerCase();
+        let result = haystack.filter(x => x.toLowerCase().includes(needle));
+        // Optional final-pass semantics
+        if (postFilter) {
+            result = postFilter({ result, control: $(control), input, haystack });
+        }
         output(result);
     };
+}
-function getAutomationIdCallback(data) {
+/**
-    return function (control, input, output) {
+ * Splits a string into an array of strings, separated by commas and trimmed
-        const uid = $(control).data('uid');
+ * @param {string} s - The string to split
-        const ids = new Set();
+ * @returns {string[]} An array of strings, separated by commas and trimmed
-        for (const entry of Object.values(data.entries)) {
+ */
-            // Skip automation id of this entry, because auto-complete should only suggest the ones that are already available on other entries
+const splitCsv = s => String(s ?? '').split(/,\s*/).filter(Boolean);
-            if (entry.uid == uid) continue;
-            if (entry.automationId) {
-                ids.add(String(entry.automationId));
-            }
-        }
-        if ('quickReplyApi' in globalThis) {
+/**
-            for (const automationId of globalThis.quickReplyApi.listAutomationIds()) {
+ * Get the inclusion groups for the autocomplete.
-                ids.add(String(automationId));
+ * @param {any} data WI data
-            }
+ * @returns {(input: any, output: any) => any} Callback function for the autocomplete
+ */
+function getInclusionGroupCallback(data) {
+    return buildAutocompleteCallback({
+        data,
+        collectValues: entry => entry.group ? splitCsv(entry.group) : [],
+        postFilter: ({ result, control, input, haystack }) => {
+            const thisGroups = splitCsv(String($(control).val()));
+            const needle = String(input.term ?? '').toLowerCase();
+            const hasExactMatch = haystack.some(x => x.toLowerCase() === needle);
+            // include suggestion if it contains the needle AND
+            // (not already present OR (exact match typed && appears only once))
+            return result.filter(x =>
+                !thisGroups.includes(x) ||
+                (hasExactMatch && thisGroups.filter(g => g === x).length === 1),
+            );
+        },
+    });
+}
-        const haystack = Array.from(ids);
+function getAutomationIdCallback(data) {
-        haystack.sort((a, b) => a.localeCompare(b));
+    return buildAutocompleteCallback({
-        const needle = input.term.toLowerCase();
+        data,
-        const result = haystack.filter(x => x.toLowerCase().includes(needle));
+        collectValues: entry => entry.automationId != null ? [String(entry.automationId)] : [],
+        includeExtras: () =>
+            ('quickReplyApi' in globalThis && globalThis.quickReplyApi?.listAutomationIds)
+                ? globalThis.quickReplyApi.listAutomationIds()
+                : [],
+    });
+}
-        output(result);
+function getOutletNameCallback(data) {
-    };
+    return buildAutocompleteCallback({
+        data,
+        collectValues: entry => entry.position === world_info_position.outlet && entry.outletName ? [entry.outletName] : [],
+    });
+}
 /**
- * Create an autocomplete for the inclusion group.
+ * Create an autocomplete for an input element.
  * @param {JQuery<HTMLElement>} input - Input element to attach the autocomplete to
  * @param {(control: JQuery<HTMLElement>, input: any, output: any) => any} callback - Source data callbacks
  * @param {object} [options={}] - Optional arguments

     probability: { default: 100, type: 'number' },
     useProbability: { default: true, type: 'boolean' },
     depth: { default: DEFAULT_DEPTH, type: 'number' },
+    outletName: { default: '', type: 'string' },
     group: { default: '', type: 'string' },
     groupOverride: { default: false, type: 'boolean' },
     groupWeight: { default: DEFAULT_WEIGHT, type: 'number' },

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

     const ANTopEntries = [];
     const ANBottomEntries = [];
     const WIDepthEntries = [];
+    /** @type {{[key: string]: string[]}} */
+    const WIOutletEntries = {};
     // 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

+                }
                 break;
+            }
+            case world_info_position.outlet: {
+                if (!entry.outletName) {
+                    console.warn(`[WI] Entry ${entry.uid} has position 'outlet' but no outlet name. Skipping.`);
+                    break;
+                }
+                if (Array.isArray(WIOutletEntries[entry.outletName])) {
+                    WIOutletEntries[entry.outletName].push(content);
+                } else {
+                    WIOutletEntries[entry.outletName] = [content];
+                }
+                break;
+            }
             default:
                 break;
+        }

     console.log(`[WI] ${isDryRun ? 'Hypothetically adding' : 'Adding'} ${allActivatedEntries.size} entries to prompt`, Array.from(allActivatedEntries.values()));
     console.debug(`[WI] --- DONE${isDryRun ? ' (DRY RUN)' : ''} ---`);
-    return { worldInfoBefore, worldInfoAfter, EMEntries, WIDepthEntries, ANBeforeEntries: ANTopEntries, ANAfterEntries: ANBottomEntries, allActivatedEntries: new Set(allActivatedEntries.values()) };
+    return { worldInfoBefore, worldInfoAfter, EMEntries, WIDepthEntries, ANBeforeEntries: ANTopEntries, ANAfterEntries: ANBottomEntries, outletEntries: WIOutletEntries, allActivatedEntries: new Set(allActivatedEntries.values()) };
+}
 /**

             displayIndex: index,
             probability: 100,
             useProbability: true,
+            outletName: '',
             group: '',
             groupOverride: false,
             groupWeight: DEFAULT_WEIGHT,

             displayIndex: index,
             probability: entry.activationPercent ?? 100,
             useProbability: entry.activationPercent ?? true,
+            outletName: '',
             group: '',
             groupOverride: false,
             groupWeight: DEFAULT_WEIGHT,

             displayIndex: index,
             probability: 100,
             useProbability: true,
+            outletName: '',
             group: '',
             groupOverride: false,
             groupWeight: DEFAULT_WEIGHT,

             useProbability: entry.extensions?.useProbability ?? true,
             depth: entry.extensions?.depth ?? DEFAULT_DEPTH,
             selectiveLogic: entry.extensions?.selectiveLogic ?? world_info_logic.AND_ANY,
+            outletName: entry.extensions?.outlet_name ?? '',
             group: entry.extensions?.group ?? '',
             groupOverride: entry.extensions?.group_override ?? false,
             groupWeight: entry.extensions?.group_weight ?? DEFAULT_WEIGHT,

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

                 useProbability: entry.useProbability ?? false,
                 depth: entry.depth ?? 4,
                 selectiveLogic: entry.selectiveLogic ?? 0,
+                outlet_name: entry.outletName ?? '',
                 group: entry.group ?? '',
                 group_override: entry.groupOverride ?? false,
                 group_weight: entry.groupWeight ?? null,