Merge pull request #3150 from Succubyss/getpromptentry add /getpromptentry command

f5f60e269ec7c1aa030ad2a75524ba40c668db01

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

Signed

Parents: 7f9766c9186296fe72da0eee12e6dc9bdd12d4ff 7dfba69fc1804f3650d3285f85288fd06292b0a3

public/scripts/openai.js+2 -2 Viewed

 let openai_setting_names;
 let openai_settings;
+-
 +/** @type {import('./PromptManager.js').PromptManager} */
 export let promptManager = null;
 async function validateReverseProxy() {
     if (!oai_settings.reverse_proxy) {

public/scripts/slash-commands.js+113 -4 Viewed

 import { getContext, saveMetadataDebounced } from './extensions.js';
 import { getRegexedString, regex_placement } from './extensions/regex/engine.js';
 import { findGroupMemberId, groups, is_group_generating, openGroupById, resetSelectedGroup, saveGroupChat, selected_group } from './group-chats.js';
 import { chat_completion_sources, oai_settings, setupChatCompletionPromptManagerpromptManager } from './openai.js';
 import { autoSelectPersona, retriggerFirstMessageOnEmptyChat, setPersonaLockState, togglePersonaLock, user_avatar } from './personas.js';
 import { addEphemeralStoppingString, chat_styles, flushEphemeralStoppingStrings, power_user } from './power-user.js';
 import { SERVER_INPUTS, textgen_types, textgenerationwebui_settings } from './textgen-settings.js';

         helpString: 'Sets the model for the current API. Gets the current model name if no argument is provided.',
     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'getpromptentry',
 +        aliases: ['getpromptentries'],
 +        callback: getPromptEntryCallback,
 +        returns: 'true/false state of prompt(s)',
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'identifier',
 +                description: 'Prompt entry identifier(s) to retrieve',
 +                typeList: [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.LIST],
 +                acceptsMultiple: true,
 +                enumProvider: () =>
 +                    promptManager.serviceSettings.prompts
 +                        .map(prompt => prompt.identifier)
 +                        .map(identifier => new SlashCommandEnumValue(identifier)),
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'name',
 +                description: 'Prompt entry name(s) to retrieve',
 +                typeList: [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.LIST],
 +                acceptsMultiple: true,
 +                enumProvider: () =>
 +                    promptManager.serviceSettings.prompts
 +                        .map(prompt => prompt.name)
 +                        .map(name => new SlashCommandEnumValue(name)),
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'Whether the return will be simple, a list, or a dict.',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'simple',
 +                enumList: ['simple', 'list', 'dict'],
 +            }),
 +        ],
 +        helpString: `
 +            <div>
 +                Gets the state of the specified prompt entries.
 +            </div>
 +            <div>
 +                If <code>return</code> is <code>simple</code> (default) then the return will be a single value if only one value was retrieved; otherwise uses a dict (if the identifier parameter was used) or a list.
 +            </div>
 +        `,
 +    }));
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'setpromptentry',
         aliases: ['setpromptentries'],
         callback: setPromptEntryCallback,

                 typeList: [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.LIST],
                 acceptsMultiple: true,
                 enumProvider: () => {
 -                    const promptManager = setupChatCompletionPromptManager(oai_settings);
                     const prompts = promptManager.serviceSettings.prompts;
                     return prompts.map(prompt => new SlashCommandEnumValue(prompt.identifier, prompt.name, enumTypes.enum));
                 },

                 typeList: [ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.LIST],
                 acceptsMultiple: true,
                 enumProvider: () => {
 -                    const promptManager = setupChatCompletionPromptManager(oai_settings);
                     const prompts = promptManager.serviceSettings.prompts;
                     return prompts.map(prompt => new SlashCommandEnumValue(prompt.name, prompt.identifier, enumTypes.enum));
                 },

+}
 /**
 + * Gets the state of prompt entries (toggles) either via identifier/uuid or name.
 + * @param {object} args Object containing arguments
 + * @param {string} args.identifier Select prompt entry using an identifier (uuid)
 + * @param {string} args.name Select prompt entry using name
 + * @param {string} args.return The type of return value to use (simple, list, dict)
 + * @returns {Object} An object containing the states of the requested prompt entries
 + */
 +function getPromptEntryCallback(args) {
 +    const prompts = promptManager.serviceSettings.prompts;
 +    let returnType = args.return ?? 'simple';
++
 +    function parseArgs(arg) {
 +        // Arg is already an array
 +        if (Array.isArray(arg)) {
 +            return arg;
 +        }
 +        const list = [];
 +        try {
 +            // Arg is a JSON-stringified array
 +            const parsedArg = JSON.parse(arg);
 +            list.push(...Array.isArray(parsedArg) ? parsedArg : [arg]);
 +        } catch {
 +            // Arg is a string
 +            list.push(arg);
 +        }
 +        return list;
 +    }
++
 +    let identifiersList = parseArgs(args.identifier);
 +    let nameList = parseArgs(args.name);
++
 +    // Check if identifiers exists in prompt, else remove from list
 +    if (identifiersList.length !== 0) {
 +        identifiersList = identifiersList.filter(identifier => prompts.some(prompt => prompt.identifier === identifier));
 +    }
++
 +    if (nameList.length !== 0) {
 +        nameList.forEach(name => {
 +            let identifiers = prompts
 +                .filter(entry => entry.name === name)
 +                .map(entry => entry.identifier);
 +            identifiersList = identifiersList.concat(identifiers);
 +        });
 +    }
++
 +    // Get the state for each prompt entry
 +    let promptStates = new Map();
 +    identifiersList.forEach(identifier => {
 +        const promptOrderEntry = promptManager.getPromptOrderEntry(promptManager.activeCharacter, identifier);
 +        if (promptOrderEntry) {
 +            promptStates.set(identifier, promptOrderEntry.enabled);
 +        }
 +    });
++
 +    // If return is simple (default) but more than one prompt state was retrieved, then change return type
 +    if (returnType === 'simple' && promptStates.size > 1) {
 +        returnType = args.identifier ? 'dict' : 'list';
 +    }
++
 +    const result = (() => {
 +        if (returnType === 'list') return [...promptStates.values()];
 +        if (returnType === 'dict') return Object.fromEntries(promptStates);
 +        return [...promptStates.values()][0];
 +    })();
++
 +    return result;
 +}
++
 +/**
  * Sets state of prompt entries (toggles) either via identifier/uuid or name.
  * @param {object} args Object containing arguments
  * @param {string} args.identifier Select prompt entry using an identifier (uuid)

  */
 function setPromptEntryCallback(args, targetState) {
     // needs promptManager to manipulate prompt entries
 -    const promptManager = setupChatCompletionPromptManager(oai_settings);
     const prompts = promptManager.serviceSettings.prompts;
     function parseArgs(arg) {