Merge pull request #3185 from SillyTavern/inject-filter Inject filter

f9eb720f2a823db170137f229b0fa031dd265a5e

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

Signed

Parents: e7b53dcb46a9edd1773b76511b4c1e5178d3ccde 6f4350b3a7f074e57e1da5c150ec71415e43c712

public/script.js+75 -33 Viewed

+    }
+}
-function getAllExtensionPrompts() {
+/**
-    const value = Object
+ * Returns all extension prompts combined.
-        .values(extension_prompts)
+ * @returns {Promise<string>} Combined extension prompts
-        .filter(x => x.value)
+ */
-        .map(x => x.value.trim())
+async function getAllExtensionPrompts() {
-        .join('\n');
+    const values = [];
+    for (const prompt of Object.values(extension_prompts)) {
+        const value = prompt?.value?.trim();
+        if (!value) {
+            continue;
+        }
-    return value.length ? substituteParams(value) : '';
+        const hasFilter = typeof prompt.filter === 'function';
+        if (hasFilter && !await prompt.filter()) {
+            continue;
+        }
+        values.push(value);
+    }
+    return substituteParams(values.join('\n'));
+}
-// Wrapper to fetch extension prompts by module name
+/**
-export function getExtensionPromptByName(moduleName) {
+ * Wrapper to fetch extension prompts by module name
-    if (moduleName) {
+ * @param {string} moduleName Module name
-        return substituteParams(extension_prompts[moduleName]?.value);
+ * @returns {Promise<string>} Extension prompt
-    } else {
+ */
-        return;
+export async function getExtensionPromptByName(moduleName) {
+    if (!moduleName) {
+        return '';
+    }
+    const prompt = extension_prompts[moduleName];
+    if (!prompt) {
+        return '';
+    }
+    const hasFilter = typeof prompt.filter === 'function';
+    if (hasFilter && !await prompt.filter()) {
+        return '';
+    }
+    return substituteParams(prompt.value);
+}
 /**

  * @param {string} [separator] Separator for joining multiple prompts
  * @param {number} [role] Role of the prompt
  * @param {boolean} [wrap] Wrap start and end with a separator
- * @returns {string} Extension prompt
+ * @returns {Promise<string>} Extension prompt
  */
-export function getExtensionPrompt(position = extension_prompt_types.IN_PROMPT, depth = undefined, separator = '\n', role = undefined, wrap = true) {
+export async function getExtensionPrompt(position = extension_prompt_types.IN_PROMPT, depth = undefined, separator = '\n', role = undefined, wrap = true) {
-    let extension_prompt = Object.keys(extension_prompts)
+    const filterByFunction = async (prompt) => {
+        const hasFilter = typeof prompt.filter === 'function';
+        if (hasFilter && !await prompt.filter()) {
+            return false;
+        }
+        return true;
+    };
+    const promptPromises = Object.keys(extension_prompts)
         .sort()
         .map((x) => extension_prompts[x])
         .filter(x => x.position == position && x.value)
         .filter(x => depth === undefined || x.depth === undefined || x.depth === depth)
         .filter(x => role === undefined || x.role === undefined || x.role === role)
-        .map(x => x.value.trim())
+        .filter(filterByFunction);
-        .join(separator);
+    const prompts = await Promise.all(promptPromises);
-    if (wrap && extension_prompt.length && !extension_prompt.startsWith(separator)) {
-        extension_prompt = separator + extension_prompt;
+    let values = prompts.map(x => x.value.trim()).join(separator);
+    if (wrap && values.length && !values.startsWith(separator)) {
+        values = separator + values;
+    }
-    if (wrap && extension_prompt.length && !extension_prompt.endsWith(separator)) {
+    if (wrap && values.length && !values.endsWith(separator)) {
-        extension_prompt = extension_prompt + separator;
+        values = values + separator;
+    }
-    if (extension_prompt.length) {
+    if (values.length) {
-        extension_prompt = substituteParams(extension_prompt);
+        values = substituteParams(values);
+    }
-    return extension_prompt;
+    return values;
+}
 export function baseChatReplace(value, name1, name2) {

     // Inject all Depth prompts. Chat Completion does it separately
     let injectedIndices = [];
     if (main_api !== 'openai') {
-        injectedIndices = doChatInject(coreChat, isContinue);
+        injectedIndices = await doChatInject(coreChat, isContinue);
+    }
     // Insert character jailbreak as the last user message (if exists, allowed, preferred, and not using Chat Completion)

+    }
     // Call combined AN into Generate
-    const beforeScenarioAnchor = getExtensionPrompt(extension_prompt_types.BEFORE_PROMPT).trimStart();
+    const beforeScenarioAnchor = (await getExtensionPrompt(extension_prompt_types.BEFORE_PROMPT)).trimStart();
-    const afterScenarioAnchor = getExtensionPrompt(extension_prompt_types.IN_PROMPT);
+    const afterScenarioAnchor = await getExtensionPrompt(extension_prompt_types.IN_PROMPT);
     const storyStringParams = {
         description: description,

             ...thisPromptBits[currentArrayEntry],
             rawPrompt: generate_data.prompt || generate_data.input,
             mesId: getNextMessageId(type),
-            allAnchors: getAllExtensionPrompts(),
+            allAnchors: await getAllExtensionPrompts(),
             chatInjects: injectedIndices?.map(index => arrMes[arrMes.length - index - 1])?.join('') || '',
             summarizeString: (extension_prompts['1_memory']?.value || ''),
             authorsNoteString: (extension_prompts['2_floating_prompt']?.value || ''),

  * Injects extension prompts into chat messages.
  * @param {object[]} messages Array of chat messages
  * @param {boolean} isContinue Whether the generation is a continuation. If true, the extension prompts of depth 0 are injected at position 1.
- * @returns {number[]} Array of indices where the extension prompts were injected
+ * @returns {Promise<number[]>} Array of indices where the extension prompts were injected
  */
-function doChatInject(messages, isContinue) {
+async function doChatInject(messages, isContinue) {
     const injectedIndices = [];
     let totalInsertedMessages = 0;
     messages.reverse();

         const wrap = false;
         for (const role of roles) {
-            const extensionPrompt = String(getExtensionPrompt(extension_prompt_types.IN_CHAT, i, separator, role, wrap)).trimStart();
+            const extensionPrompt = String(await getExtensionPrompt(extension_prompt_types.IN_CHAT, i, separator, role, wrap)).trimStart();
             const isNarrator = role === extension_prompt_roles.SYSTEM;
             const isUser = role === extension_prompt_roles.USER;
             const name = names[role];

  * @param {number} depth Insertion depth. 0 represets the last message in context. Expected values up to MAX_INJECTION_DEPTH.
  * @param {number} role Extension prompt role. Defaults to SYSTEM.
  * @param {boolean} scan Should the prompt be included in the world info scan.
+ * @param {(function(): Promise<boolean>|boolean)} filter Filter function to determine if the prompt should be injected.
  */
-export function setExtensionPrompt(key, value, position, depth, scan = false, role = extension_prompt_roles.SYSTEM) {
+export function setExtensionPrompt(key, value, position, depth, scan = false, role = extension_prompt_roles.SYSTEM, filter = null) {
     extension_prompts[key] = {
         value: String(value),
         position: Number(position),
         depth: Number(depth),
         scan: !!scan,
         role: Number(role ?? extension_prompt_roles.SYSTEM),
+        filter: filter,
     };
+}

public/scripts/openai.js+10 -6 Viewed

+ *
  * @param {Prompt[]} prompts - Array containing injection prompts.
  * @param {Object[]} messages - Array containing all messages.
+ * @returns {Promise<Object[]>} - Array containing all messages with injections.
  */
-function populationInjectionPrompts(prompts, messages) {
+async function populationInjectionPrompts(prompts, messages) {
     let totalInsertedMessages = 0;
     const roleTypes = {

             // Get prompts for current role
             const rolePrompts = depthPrompts.filter(prompt => prompt.role === role).map(x => x.content).join(separator);
             // Get extension prompt
-            const extensionPrompt = getExtensionPrompt(extension_prompt_types.IN_CHAT, i, separator, roleTypes[role], wrap);
+            const extensionPrompt = await getExtensionPrompt(extension_prompt_types.IN_CHAT, i, separator, roleTypes[role], wrap);
             const jointPrompt = [rolePrompts, extensionPrompt].filter(x => x).map(x => x.trim()).join(separator);

+    }
     // Add in-chat injections
-    messages = populationInjectionPrompts(absolutePrompts, messages);
+    messages = await populationInjectionPrompts(absolutePrompts, messages);
     // Decide whether dialogue examples should always be added
     if (power_user.pin_examples) {

  * @param {string} options.systemPromptOverride
  * @param {string} options.jailbreakPromptOverride
  * @param {string} options.personaDescription
- * @returns {Object} prompts - The prepared and merged system and user-defined prompts.
+ * @returns {Promise<Object>} prompts - The prepared and merged system and user-defined prompts.
  */
-function preparePromptsForChatCompletion({ Scenario, charPersonality, name2, worldInfoBefore, worldInfoAfter, charDescription, quietPrompt, bias, extensionPrompts, systemPromptOverride, jailbreakPromptOverride, personaDescription }) {
+async function preparePromptsForChatCompletion({ Scenario, charPersonality, name2, worldInfoBefore, worldInfoAfter, charDescription, quietPrompt, bias, extensionPrompts, systemPromptOverride, jailbreakPromptOverride, personaDescription }) {
     const scenarioText = Scenario && oai_settings.scenario_format ? substituteParams(oai_settings.scenario_format) : '';
     const charPersonalityText = charPersonality && oai_settings.personality_format ? substituteParams(oai_settings.personality_format) : '';
     const groupNudge = substituteParams(oai_settings.group_nudge_prompt);

             if (!extensionPrompts[key].value) continue;
             if (![extension_prompt_types.BEFORE_PROMPT, extension_prompt_types.IN_PROMPT].includes(prompt.position)) continue;
+            const hasFilter = typeof prompt.filter === 'function';
+            if (hasFilter && !await prompt.filter()) continue;
             systemPrompts.push({
                 identifier: key.replace(/\W/g, '_'),
                 position: getPromptPosition(prompt.position),

     try {
         // Merge markers and ordered user prompts with system prompts
-        const prompts = preparePromptsForChatCompletion({
+        const prompts = await preparePromptsForChatCompletion({
             Scenario,
             charPersonality,
             name2,

public/scripts/slash-commands.js+63 -7 Viewed

 const registerSlashCommand = SlashCommandParser.addCommand.bind(SlashCommandParser);
 const getSlashCommandsHelp = parser.getHelpString.bind(parser);
+/**
+ * Converts a SlashCommandClosure to a filter function that returns a boolean.
+ * @param {SlashCommandClosure} closure
+ * @returns {() => Promise<boolean>}
+ */
+function closureToFilter(closure) {
+    return async () => {
+        try {
+            const localClosure = closure.getCopy();
+            localClosure.onProgress = () => { };
+            const result = await localClosure.execute();
+            return isTrueBoolean(result.pipe);
+        } catch (e) {
+            console.error('Error executing filter closure', e);
+            return false;
+        }
+    };
+}
 export function initDefaultSlashCommands() {
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: '?',

             new SlashCommandNamedArgument(
                 'ephemeral', 'remove injection after generation', [ARGUMENT_TYPE.BOOLEAN], false, false, 'false',
             ),
+            SlashCommandNamedArgument.fromProps({
+                name: 'filter',
+                description: 'if a filter is defined, an injection will only be performed if the closure returns true',
+                typeList: [ARGUMENT_TYPE.CLOSURE],
+                isRequired: false,
+                acceptsMultiple: false,
+            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

 export const COMMENT_NAME_DEFAULT = 'Note';
 const SCRIPT_PROMPT_KEY = 'script_inject_';
+/**
+ * Adds a new script injection to the chat.
+ * @param {import('./slash-commands/SlashCommand.js').NamedArguments} args Named arguments
+ * @param {import('./slash-commands/SlashCommand.js').UnnamedArguments} value Unnamed argument
+ */
 function injectCallback(args, value) {
     const positions = {
         'before': extension_prompt_types.BEFORE_PROMPT,

         'assistant': extension_prompt_roles.ASSISTANT,
     };
-    const id = args?.id;
+    const id = String(args?.id);
-    const ephemeral = isTrueBoolean(args?.ephemeral);
+    const ephemeral = isTrueBoolean(String(args?.ephemeral));
     if (!id) {
         console.warn('WARN: No ID provided for /inject command');

     const depth = isNaN(depthValue) ? defaultDepth : depthValue;
     const roleValue = typeof args?.role === 'string' ? args.role.toLowerCase().trim() : Number(args?.role ?? extension_prompt_roles.SYSTEM);
     const role = roles[roleValue] ?? roles[extension_prompt_roles.SYSTEM];
-    const scan = isTrueBoolean(args?.scan);
+    const scan = isTrueBoolean(String(args?.scan));
+    const filter = args?.filter instanceof SlashCommandClosure ? args.filter.rawText : null;
+    const filterFunction = args?.filter instanceof SlashCommandClosure ? closureToFilter(args.filter) : null;
     value = value || '';
+    if (args?.filter && !String(filter ?? '').trim()) {
+        throw new Error('Failed to parse the filter argument. Make sure it is a valid non-empty closure.');
+    }
     const prefixedId = `${SCRIPT_PROMPT_KEY}${id}`;
     if (!chat_metadata.script_injects) {

+    }
     if (value) {
-        const inject = { value, position, depth, scan, role };
+        const inject = { value, position, depth, scan, role, filter };
         chat_metadata.script_injects[id] = inject;
     } else {
         delete chat_metadata.script_injects[id];
+    }
-    setExtensionPrompt(prefixedId, value, position, depth, scan, role);
+    setExtensionPrompt(prefixedId, String(value), position, depth, scan, role, filterFunction);
     saveMetadataDebounced();
     if (ephemeral) {

+            }
             console.log('Removing ephemeral script injection', id);
             delete chat_metadata.script_injects[id];
-            setExtensionPrompt(prefixedId, '', position, depth, scan, role);
+            setExtensionPrompt(prefixedId, '', position, depth, scan, role, filterFunction);
             saveMetadataDebounced();
             deleted = true;
         };

+    }
     for (const [id, inject] of Object.entries(context.chatMetadata.script_injects)) {
+        /**
+         * Rehydrates a filter closure from a string.
+         * @returns {SlashCommandClosure | null}
+         */
+        function reviveFilterClosure() {
+            if (!inject.filter) {
+                return null;
+            }
+            try {
+                return new SlashCommandParser().parse(inject.filter, true);
+            } catch (error) {
+                console.warn('Failed to revive filter closure for script injection', id, error);
+                return null;
+            }
+        }
         const prefixedId = `${SCRIPT_PROMPT_KEY}${id}`;
+        const filterClosure = reviveFilterClosure();
+        const filter = filterClosure ? closureToFilter(filterClosure) : null;
         console.log('Adding script injection', id);
-        setExtensionPrompt(prefixedId, inject.value, inject.position, inject.depth, inject.scan, inject.role);
+        setExtensionPrompt(prefixedId, inject.value, inject.position, inject.depth, inject.scan, inject.role, filter);
+    }
+}

public/scripts/world-info.js+1 -1 Viewed

     // Put this code here since otherwise, the chat reference is modified
     for (const key of Object.keys(context.extensionPrompts)) {
         if (context.extensionPrompts[key]?.scan) {
-            const prompt = getExtensionPromptByName(key);
+            const prompt = await getExtensionPromptByName(key);
             if (prompt) {
                 buffer.addInject(prompt);
+            }