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} */
-let promptManager = null;
+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, setupChatCompletionPromptManager } from './openai.js';
+import { chat_completion_sources, oai_settings, promptManager } 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) {