Merge branch 'staging' into tc-split-generic

756f88b5aa612f49a81a6d473cb39fe8de9d3758

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

Parents: cd0b83429187a94715419180befe9c8d5446d045 5c1a9a300313f662f4a24a0a33e2078a5c4204dc

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 = [];
 -    return value.length ? substituteParams(value) : '';
 +    for (const prompt of Object.values(extension_prompts)) {
 +        const value = prompt?.value?.trim();
++
 +        if (!value) {
 +            continue;
+        }
 -// Wrapper to fetch extension prompts by module name
 +        const hasFilter = typeof prompt.filter === 'function';
 -export function getExtensionPromptByName(moduleName) {
 +        if (hasFilter && !await prompt.filter()) {
 -    if (moduleName) {
 +            continue;
 -        return substituteParams(extension_prompts[moduleName]?.value);
 -    } else {
 -        return;
+        }
++
 +        values.push(value);
 +    }
++
 +    return substituteParams(values.join('\n'));
 +}
++
 +/**
 + * Wrapper to fetch extension prompts by module name
 + * @param {string} moduleName Module name
 + * @returns {Promise<string>} Extension prompt
 + */
 +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 {Promise<string>} Extension prompt
  */
 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_promptvalues.length && !extension_promptvalues.endsWith(separator)) {
         extension_promptvalues = extension_promptvalues + separator;
+    }
     if (extension_promptvalues.length) {
         extension_promptvalues = substituteParams(extension_promptvalues);
+    }
     return extension_promptvalues;
+}
 export function baseChatReplace(value, name1, name2) {

     // Inject all Depth prompts. Chat Completion does it separately
     let injectedIndices = [];
     if (main_api !== 'openai') {
         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 = (await getExtensionPrompt(extension_prompt_types.BEFORE_PROMPT)).trimStart();
     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: 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 {Promise<number[]>} Array of indices where the extension prompts were injected
  */
 async function doChatInject(messages, isContinue) {
     const injectedIndices = [];
     let totalInsertedMessages = 0;
     messages.reverse();

         const wrap = false;
         for (const role of roles) {
             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, 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/instruct-mode.js+5 -4 Viewed

         return mesExamplesArray.map(x => x.replace(/<START>\n/i, blockHeading));
+    }
     const includeNames = power_user.instruct.names_behavior === names_behavior_types.ALWAYS || (!!selected_group && power_user.instruct.names_behavior === names_behavior_types.FORCE);
 +    const includeGroupNames = selected_group && [names_behavior_types.ALWAYS, names_behavior_types.FORCE].includes(power_user.instruct.names_behavior);
     let inputPrefix = power_user.instruct.input_sequence || '';
     let outputPrefix = power_user.instruct.output_sequence || '';

     for (const item of mesExamplesArray) {
         const cleanedItem = item.replace(/<START>/i, '{Example Dialogue:}').replace(/\r/gm, '');
         const blockExamples = parseExampleIntoIndividual(cleanedItem, includeGroupNames);
         if (blockExamples.length === 0) {
             continue;

+        }
         for (const example of blockExamples) {
 +            // If group names were already included, we don't want to add an additional prefix
             // If force group/persona names is set, we should override the include names for the user placeholder
             const includeThisName = (includeNames && !includeGroupNames) || (power_user.instruct.names_behavior === names_behavior_types.FORCE && example.name == 'example_user');
             const prefix = example.name == 'example_user' ? inputPrefix : outputPrefix;
             const suffix = example.name == 'example_user' ? inputSuffix : outputSuffix;

@@ -489,7 +491,6 @@ export function formatInstructModeExamples(mesExamplesArray, name1, name2) {
489	491	if (formattedExamples.length === 0) {
490	492	return mesExamplesArray.map(x => x.replace(/<START>\n/i, blockHeading));
491	493	}
492		-
493	494	return formattedExamples;
494	495	}
495	496

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.
  */
 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 = 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 = 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 {Promise<Object>} prompts - The prepared and merged system and user-defined prompts.
  */
 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 = 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 = String(args?.id);
     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(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, filter };
         chat_metadata.script_injects[id] = inject;
     } else {
         delete chat_metadata.script_injects[id];
+    }
     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, 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, filter);
+    }
+}

public/scripts/st-context.js+3 -1 Viewed

 import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { tag_map, tags } from './tags.js';
 import { textgenerationwebui_settings } from './textgen-settings.js';
 import { tokenizers, getTextTokens, getTokenCount, getTokenCountAsync, getTokenizerModel } from './tokenizers.js';
 import { ToolManager } from './tool-calling.js';
 import { timestampToMoment } from './utils.js';

         sendStreamingRequest,
         sendGenerationRequest,
         stopGeneration,
 +        tokenizers,
 +        getTextTokens,
         /** @deprecated Use getTokenCountAsync instead */
         getTokenCount,
         getTokenCountAsync,

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 = await getExtensionPromptByName(key);
             if (prompt) {
                 buffer.addInject(prompt);
+            }