Merge branch 'staging' into reasoning-template

cf2671c6d77b53a165bf8a5862d85e18625b7394

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

Parents: d31475254730c49bcda47a37c7ed715ac436052a a8716d7c690255649d42c2ca49f6914673cf88f1

.github/workflows/pr-auto-manager.yml+14 -4 Viewed

   label-by-branches:
     name: 🏷️ Label PR by Branches
 +    needs: [label-by-size]
     runs-on: ubuntu-latest
 +    # Run, even if the previous jobs were skipped/failed
     # Only label once when PR is created or branches are changed, to allow manual label removal
 -    if: github.event.action == 'opened' || (github.event.action == 'synchronize' && (github.event.changes.base || github.event.changes.head))
 +    if: |
 +      always()
 +      && github.event.action == 'opened' || (github.event.action == 'synchronize' && (github.event.changes.base || github.event.changes.head))
     steps:
       - name: Checkout Repository

   label-by-files:
     name: 🏷️ Label PR by Files
 +    needs: [label-by-branches]
     runs-on: ubuntu-latest
 +    # Run, even if the previous jobs were skipped/failed
 +    if: always()
     steps:
       - name: Checkout Repository

   remove-stale-label:
     name: 🗑️ Remove Stale Label on Comment
 +    needs: [label-by-files]
     runs-on: ubuntu-latest
     # Only runs when this is not done by the github actions bot
 -    if: github.event_name == 'pull_request_review_comment' && github.actor != 'github-actions[bot]'
 +    if: |
 +      always()
 +      && github.event_name == 'pull_request_review_comment' && github.actor != 'github-actions[bot]'
     steps:
       - name: Remove Stale Label

   check-merge-blocking-labels:
     name: 🚫 Check Merge Blocking Labels
     needs: [label-by-size, label-by-branches, label-by-files, remove-stale-label]
     runs-on: ubuntu-latest
     # Run, even if the previous jobs were skipped/failed
     if: always()

   write-auto-comments:
     name: 💬 Post PR Comments Based on Labels
     needs: [label-by-size, label-by-branches, label-by-files, remove-stale-label]
     runs-on: ubuntu-latest
     # Run, even if the previous jobs were skipped/failed
     if: always()

public/global.d.ts+4 -0 Viewed

 import libs from './lib';
 import getContext from './scripts/st-context';
 +import { power_user } from './scripts/power-user';
 declare global {
 +    // Custom types
 +    declare type InstructSettings = typeof power_user.instruct;
++
     // Global namespace modules
     interface Window {
         ai: any;

public/script.js+57 -22 Viewed

     ONLINE_STATUS_CHANGED: 'online_status_changed',
     IMAGE_SWIPED: 'image_swiped',
     CONNECTION_PROFILE_LOADED: 'connection_profile_loaded',
 +    CONNECTION_PROFILE_CREATED: 'connection_profile_created',
 +    CONNECTION_PROFILE_DELETED: 'connection_profile_deleted',
 +    CONNECTION_PROFILE_UPDATED: 'connection_profile_updated',
     TOOL_CALLS_PERFORMED: 'tool_calls_performed',
     TOOL_CALLS_RENDERED: 'tool_calls_rendered',
 };

  * If the character ID doesn't exist, if the chat is being saved, or if a group is being generated, this function does nothing.
  * If the character is different from the currently selected one, it will clear the chat and reset any selected character or group.
  * @param {number} id The ID of the character to switch to.
 + * @param {object} [options] Options for the switch.
 + * @param {boolean} [options.switchMenu=true] Whether to switch the right menu to the character edit menu if the character is already selected.
 + * @returns {Promise<void>} A promise that resolves when the character is switched.
  */
 export async function selectCharacterById(id, { switchMenu = true } = {}) {
     if (characters[id] === undefined) {
         return;
+    }

@@ -1400,9 +1406,9 @@ export async function selectCharacterById(id) {
1400	1406	}
1401	1407	} else {
1402	1408	//if clicked on character that was already selected
1403	1409	switchMenu && (selected_button = 'character_edit');
1404	1410	await unshallowCharacter(this_chid);
1405	1411	select_selected_character(this_chid, { switchMenu });
1406	1412	}
1407	1413	}
1408	1414

         body: JSON.stringify({}),
     });
     if (response.ok === true) {
 +        const previousAvatar = this_chid !== undefined ? characters[this_chid]?.avatar : null;
         characters.splice(0, characters.length);
         const getData = await response.json();
         for (let i = 0; i < getData.length; i++) {

             characters[i]['chat'] = String(characters[i]['chat']);
+        }
 -        if (this_chid !== undefined) {
++
 -            $('#avatar_url_pole').val(characters[this_chid].avatar);
 +        if (previousAvatar) {
 +            const newCharacterId = characters.findIndex(x => x.avatar === previousAvatar);
 +            if (newCharacterId >= 0) {
 +                setCharacterId(newCharacterId);
 +                await selectCharacterById(newCharacterId, { switchMenu: false });
 +            } else {
 +                await Popup.show.text(t`ERROR: The active character is no longer available.`, t`The page will be refreshed to prevent data loss. Press "OK" to continue.`);
 +                return location.reload();
 +            }
+        }
         await getGroups();

             await eventSource.emit(event_types.CHARACTER_RENAMED, oldAvatar, newAvatar);
 +            // Unload current character
 +            setCharacterId(undefined);
             // Reload characters list
             await getCharacters();

             if (newChId !== -1) {
                 // Select the character after the renaming
 -                setCharacterId(undefined);
                 await selectCharacterById(newChId);
                 // Async delay to update UI

+    }
+}
 -export function select_selected_character(chid) {
 +/**
 + * Selects the right menu for displaying the character editor.
 + * @param {number|string} chid Character array index
 + * @param {object} [param1] Options for the switch
 + * @param {boolean} [param1.switchMenu=true] Whether to switch the menu
 + */
 +export function select_selected_character(chid, { switchMenu = true } = {}) {
     //character select
     //console.log('select_selected_character() -- starting with input of -- ' + chid + ' (name:' + characters[chid].name + ')');
     select_rm_create({ switchMenu });
     switchMenu && setMenuType('character_edit');
     $('#delete_button').css('display', 'flex');
     $('#export_button').css('display', 'flex');
 -    var display_name = characters[chid].name;
     //create text poles
     $('#rm_button_back').css('display', 'none');

     // Don't update the navbar name if we're peeking the group member defs
     if (!selected_group) {
         $('#rm_button_selected_ch').children('h2').text(display_namecharacters[chid].name);
+    }
     $('#add_avatar_button').val('');

     $('#chat_import_avatar_url').val(characters[chid].avatar);
     $('#chat_import_character_name').val(characters[chid].name);
     $('#character_json_data').val(characters[chid].json_data);
 -    let this_avatar = default_avatar;
 -    if (characters[chid].avatar != 'none') {
 -        this_avatar = getThumbnailUrl('avatar', characters[chid].avatar);
 -    }
     updateFavButtonState(characters[chid].fav || characters[chid].fav == 'true');
 -    $('#avatar_load_preview').attr('src', this_avatar);
 +    const avatarUrl = characters[chid].avatar != 'none' ? getThumbnailUrl('avatar', characters[chid].avatar) : default_avatar;
     $('#name_divavatar_load_preview').removeClassattr('displayBlocksrc', avatarUrl);
 -    $('#name_div').addClass('displayNone');
 -    $('#renameCharButton').css('display', '');
     $('.open_alternate_greetings').data('chid', chid);
     $('#set_character_world').data('chid', chid);
     setWorldInfoButtonClass(chid);
     checkEmbeddedWorld(chid);
 +    $('#name_div').removeClass('displayBlock');
 +    $('#name_div').addClass('displayNone');
 +    $('#renameCharButton').css('display', '');
++
     $('#form_create').attr('actiontype', 'editcharacter');
     $('.form_create_bottom_buttons_block .chat_lorebook_button').show();

     saveSettingsDebounced();
+}
 -function select_rm_create() {
 +/**
 -    setMenuType('create');
 + * Selects the right menu for creating a new character.
 + * @param {object} [options] Options for the switch
 + * @param {boolean} [options.switchMenu=true] Whether to switch the menu
 + */
 +function select_rm_create({ switchMenu = true } = {}) {
 +    switchMenu && setMenuType('create');
     //console.log('select_rm_Create() -- selected button: '+selected_button);
     if (selected_button == 'create') {

@@ -7973,7 +7997,7 @@ function select_rm_create() {
7973	7997	}
7974	7998	}
7975	7999
7976	8000	switchMenu && selectRightMenuWithAnimation('rm_ch_create_block');
7977	8001
7978	8002	$('#set_chat_scenario').hide();
7979	8003	$('#delete_button_div').css('display', 'none');

+    }
+}
 +/**
 + * @typedef {object} ConnectAPIMap
 + * @property {string} selected - API name (e.g. "textgenerationwebui", "openai")
 + * @property {string?} [button] - CSS selector for the API button
 + * @property {string?} [type] - API type, mostly used by text completion. (e.g. "openrouter")
 + * @property {string?} [source] - API source, mostly used by chat completion. (e.g. "openai")
 + */
++
 +/**
 + * @type {Record<string, ConnectAPIMap>}
 + */
 export const CONNECT_API_MAP = {
     // Default APIs not contined inside text gen / chat gen
     'kobold': {

public/scripts/custom-request.js+233 -35 Viewed

 import { getPresetManager } from './preset-manager.js';
 import { extractMessageFromData, getGenerateUrl, getRequestHeaders } from '../script.js';
 import { getTextGenServer } from './textgen-settings.js';
 +import { extractReasoningFromData } from './reasoning.js';
 +import { formatInstructModeChat, formatInstructModePrompt, names_behavior_types } from './instruct-mode.js';
 // #region Type Definitions
 /**
  * @typedef {Object} TextCompletionRequestBase
 - * @property {string} prompt - The text prompt for completion
  * @property {number} max_tokens - Maximum number of tokens to generate
  * @property {string} [model] - Optional model name
  * @property {string} api_type - Type of API to use
  * @property {string} [api_server] - Optional API server URL
  * @property {number} [temperature] - Optional temperature parameter
 + * @property {number} [min_p] - Optional min_p parameter
  */
 -/** @typedef {Record<string, any> & TextCompletionRequestBase} TextCompletionRequest */
+-
 /**
  * @typedef {Object} TextCompletionPayloadBase
  * @property {string} prompt - The text prompt for completion

  */
 /** @typedef {Record<string, any> & ChatCompletionPayloadBase} ChatCompletionPayload */
++
 +/**
 + * @typedef {Object} ExtractedData
 + * @property {string} content - Extracted content.
 + * @property {string} reasoning - Extracted reasoning.
 + */
++
 // #endregion
 /**

     static TYPE = 'textgenerationwebui';
     /**
 -     * @param {TextCompletionRequest} custom
 +     * @param {Record<string, any> & TextCompletionRequestBase & {prompt: string}} custom
      * @returns {TextCompletionPayload}
      */
     static createRequestData({ prompt, max_tokens, model, api_type, api_server, temperature, min_p, ...props }) {
         returnconst payload = {
             ...props,
             prompt,
             max_tokens,

             api_type,
             api_server: api_server ?? getTextGenServer(api_type),
             temperature,
 +            min_p,
             stream: false,
         };
++
 +        // Remove undefined values to avoid API errors
 +        Object.keys(payload).forEach(key => {
 +            if (payload[key] === undefined) {
 +                delete payload[key];
 +            }
 +        });
++
 +        return payload;
+    }
     /**
      * Sends a text completion request to the specified server
      * @param {TextCompletionPayload} data Request data
      * @param {boolean?} extractData Extract message from the response. Default true
      * @returns {Promise<stringExtractedData | any>} Extracted data or the raw response
      * @throws {Error}
      */
     static async sendRequest(data, extractData = true) {

             throw json;
+        }
 -        return extractData ? extractMessageFromData(json, this.TYPE) : json;
 +        if (!extractData) {
 +            return json;
 +        }
++
 +        return {
 +            content: extractMessageFromData(json, this.TYPE),
 +            reasoning: extractReasoningFromData(json, {
 +                mainApi: this.TYPE,
 +                textGenType: data.api_type,
 +                ignoreShowThoughts: true,
 +            }),
 +        };
+    }
     /**
 -     * @param {string} presetName
 +     * Process and send a text completion request with optional preset & instruct
 -     * @param {TextCompletionRequest} custom
 +     * @param {Record<string, any> & TextCompletionRequestBase & {prompt: (ChatCompletionMessage & {ignoreInstruct?: boolean})[] |string}} custom
      * @param {boolean?Object} extractData Extract message from theoptions response.- DefaultConfiguration trueoptions
 -     * @returns {Promise<string | any>} Extracted data or the raw response
 +     * @param {string?} [options.presetName] - Name of the preset to use for generation settings
 +     * @param {string?} [options.instructName] - Name of instruct preset for message formatting
 +     * @param {boolean} extractData - Whether to extract structured data from response
 +     * @returns {Promise<ExtractedData | any>} Extracted data or the raw response
      * @throws {Error}
      */
 -    static async sendRequestWithPreset(presetName, custom, extractData = true) {
 +    static async processRequest(
 -        const presetManager = getPresetManager(this.TYPE);
 +        custom,
 -        if (!presetManager) {
 +        options = {},
 -            throw new Error('Preset manager not found');
 +        extractData = true,
 +    ) {
 +        const { presetName, instructName } = options;
 +        let requestData = { ...custom };
 +        const prompt = custom.prompt;
++
 +        // Apply generation preset if specified
 +        if (presetName) {
 +            const presetManager = getPresetManager(this.TYPE);
 +            if (presetManager) {
 +                const preset = presetManager.getCompletionPresetByName(presetName);
 +                if (preset) {
 +                    // Convert preset to payload and merge with custom parameters
 +                    const presetPayload = this.presetToGeneratePayload(preset, {});
 +                    requestData = { ...presetPayload, ...requestData };
 +                } else {
 +                    console.warn(`Preset "${presetName}" not found, continuing with default settings`);
 +                }
 +            } else {
 +                console.warn('Preset manager not found, continuing with default settings');
 +            }
+        }
 -        const preset = presetManager.getCompletionPresetByName(presetName);
 +        // Handle instruct formatting if requested
         if (!presetArray.isArray(prompt) && instructName) {
             throwconst newinstructPresetManager Error= getPresetManager('Preset not foundinstruct');
 +            let instructPreset = instructPresetManager?.getCompletionPresetByName(instructName);
 +            if (instructPreset) {
 +                // Clone the preset to avoid modifying the original
 +                instructPreset = structuredClone(instructPreset);
 +                instructPreset.macro = false;
 +                instructPreset.names_behavior = names_behavior_types.NONE;
++
 +                // Format messages using instruct formatting
 +                const formattedMessages = [];
 +                for (const message of prompt) {
 +                    let messageContent = message.content;
 +                    if (!message.ignoreInstruct) {
 +                        messageContent = formatInstructModeChat(
 +                            message.role,
 +                            message.content,
 +                            message.role === 'user',
 +                            false,
 +                            undefined,
 +                            undefined,
 +                            undefined,
 +                            undefined,
 +                            instructPreset,
 +                        );
++
 +                        // Add prompt formatting for the last message
 +                        if (message === prompt[prompt.length - 1]) {
 +                            messageContent += formatInstructModePrompt(
 +                                undefined,
 +                                false,
 +                                undefined,
 +                                undefined,
 +                                undefined,
 +                                false,
 +                                false,
 +                                instructPreset,
 +                            );
 +                        }
 +                    }
 +                    formattedMessages.push(messageContent);
 +                }
 +                requestData.prompt = formattedMessages.join('');
 +                if (instructPreset.output_suffix) {
 +                    requestData.stop = [instructPreset.output_suffix];
 +                    requestData.stopping_strings = [instructPreset.output_suffix];
 +                }
 +            } else {
 +                console.warn(`Instruct preset "${instructName}" not found, using basic formatting`);
 +                requestData.prompt = prompt.map(x => x.content).join('\n\n');
 +            }
 +        } else if (typeof prompt === 'string') {
 +            requestData.prompt = prompt;
 +        } else {
 +            requestData.prompt = prompt.map(x => x.content).join('\n\n');
+        }
 -        const data = this.createRequestData({ ...preset, ...custom });
 +        // @ts-ignore
 +        const data = this.createRequestData(requestData);
         return await this.sendRequest(data, extractData);
+    }
++
 +    /**
 +     * Converts a preset to a valid text completion payload.
 +     * Only supports temperature.
 +     * @param {Object} preset - The preset configuration
 +     * @param {Object} customPreset - Additional parameters to override preset values
 +     * @returns {Object} - Formatted payload for text completion API
 +     */
 +    static presetToGeneratePayload(preset, customPreset = {}) {
 +        if (!preset || typeof preset !== 'object') {
 +            throw new Error('Invalid preset: must be an object');
 +        }
++
 +        // Merge preset with custom parameters
 +        const settings = { ...preset, ...customPreset };
++
 +        // Initialize base payload with common parameters
 +        let payload = {
 +            'temperature': settings.temp ? Number(settings.temp) : undefined,
 +            'min_p': settings.min_p ? Number(settings.min_p) : undefined,
 +        };
++
 +        // Remove undefined values to avoid API errors
 +        Object.keys(payload).forEach(key => {
 +            if (payload[key] === undefined) {
 +                delete payload[key];
 +            }
 +        });
++
 +        return payload;
 +    }
+}
 /**

      * @returns {ChatCompletionPayload}
      */
     static createRequestData({ messages, model, chat_completion_source, max_tokens, temperature, ...props }) {
         returnconst payload = {
             ...props,
             messages,
             model,

             temperature,
             stream: false,
         };
++
 +        // Remove undefined values to avoid API errors
 +        Object.keys(payload).forEach(key => {
 +            if (payload[key] === undefined) {
 +                delete payload[key];
 +            }
 +        });
++
 +        return payload;
+    }
     /**
      * Sends a chat completion request
      * @param {ChatCompletionPayload} data Request data
      * @param {boolean?} extractData Extract message from the response. Default true
      * @returns {Promise<stringExtractedData | any>} Extracted data or the raw response
      * @throws {Error}
      */
     static async sendRequest(data, extractData = true) {

             throw json;
+        }
 -        return extractData ? extractMessageFromData(json, this.TYPE) : json;
 +        if (!extractData) {
 +            return json;
 +        }
++
 +        return {
 +            content: extractMessageFromData(json, this.TYPE),
 +            reasoning: extractReasoningFromData(json, {
 +                mainApi: this.TYPE,
 +                textGenType: data.chat_completion_source,
 +                ignoreShowThoughts: true,
 +            }),
 +        };
+    }
     /**
 -     * @param {string} presetName
 +     * Process and send a chat completion request with optional preset
      * @param {ChatCompletionPayload} custom
      * @param {booleanObject} extractData Extract message from theoptions response.- DefaultConfiguration trueoptions
 -     * @returns {Promise<string | any>} Extracted data or the raw response
 +     * @param {string?} [options.presetName] - Name of the preset to use for generation settings
 +     * @param {boolean} extractData - Whether to extract structured data from response
 +     * @returns {Promise<ExtractedData | any>} Extracted data or the raw response
      * @throws {Error}
      */
     static async sendRequestWithPresetprocessRequest(presetNamecustom, customoptions, extractData = true) {
         const presetManager{ presetName } = getPresetManager(this.TYPE)options;
 -        if (!presetManager) {
 +        let requestData = { ...custom };
 -            throw new Error('Preset manager not found');
 -        }
 -        const preset = presetManager.getCompletionPresetByName(presetName);
 +        // Apply generation preset if specified
         if (!presetpresetName) {
 -            throw new Error('Preset not found');
 +            const presetManager = getPresetManager(this.TYPE);
 +            if (presetManager) {
 +                const preset = presetManager.getCompletionPresetByName(presetName);
 +                if (preset) {
 +                    // Convert preset to payload and merge with custom parameters
 +                    const presetPayload = this.presetToGeneratePayload(preset, {});
 +                    requestData = { ...presetPayload, ...requestData };
 +                } else {
 +                    console.warn(`Preset "${presetName}" not found, continuing with default settings`);
 +                }
 +            } else {
 +                console.warn('Preset manager not found, continuing with default settings');
 +            }
+        }
         const data = this.createRequestData({ ...preset, ...custom }requestData);
         return await this.sendRequest(data, extractData);
+    }
++
 +    /**
 +     * Converts a preset to a valid chat completion payload
 +     * Only supports temperature.
 +     * @param {Object} preset - The preset configuration
 +     * @param {Object} customParams - Additional parameters to override preset values
 +     * @returns {Object} - Formatted payload for chat completion API
 +     */
 +    static presetToGeneratePayload(preset, customParams = {}) {
 +        if (!preset || typeof preset !== 'object') {
 +            throw new Error('Invalid preset: must be an object');
 +        }
++
 +        // Merge preset with custom parameters
 +        const settings = { ...preset, ...customParams };
++
 +        // Initialize base payload with common parameters
 +        const payload = {
 +            temperature: settings.temperature ? Number(settings.temperature) : undefined,
 +        };
++
 +        // Remove undefined values to avoid API errors
 +        Object.keys(payload).forEach(key => {
 +            if (payload[key] === undefined) {
 +                delete payload[key];
 +            }
 +        });
++
 +        return payload;
 +    }
+}

public/scripts/extensions/connection-manager/index.js+28 -6 Viewed

 import { DOMPurify, Fuse } from '../../../lib.js';
 import { event_types, eventSource, main_api, saveSettingsDebounced } from '../../../script.js';
 import { extension_settings, renderExtensionTemplateAsync } from '../../extensions.js';

     });
     const isNameTaken = (n) => extension_settings.connectionManager.profiles.some(p => p.name === n);
     const suggestedName = getUniqueName(collapseSpaces(`${profile.api ?? ''} ${profile.model ?? ''} - ${profile.preset ?? ''}`), isNameTaken);
     constlet name = forceName ?? await callGenericPopup(template, POPUP_TYPE.INPUT, suggestedName, { rows: 2 });
+-
 +    // If it's cancelled, it will be false
 +    if (!name) {
 +        return null;
 +    }
 +    name = DOMPurify.sanitize(String(name));
     if (!name) {
 +        toastr.error('Name cannot be empty.');
         return null;
+    }

         return;
+    }
     const nameprofile = extension_settings.connectionManager.profiles[index].name;
 +    const name = profile.name;
     const confirm = await Popup.show.confirm(t`Are you sure you want to delete the selected profile?`, name);
     if (!confirm) {

     extension_settings.connectionManager.profiles.splice(index, 1);
     extension_settings.connectionManager.selectedProfile = null;
     saveSettingsDebounced();
++
 +    await eventSource.emit(event_types.CONNECTION_PROFILE_DELETED, profile);
+}
 /**

         saveSettingsDebounced();
         renderConnectionProfiles(profiles);
         await renderDetailsContent(detailsContent);
 +        await eventSource.emit(event_types.CONNECTION_PROFILE_CREATED, profile);
         await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
     });

             console.log('No profile selected');
             return;
+        }
 +        const oldProfile = structuredClone(profile);
         await updateConnectionProfile(profile);
         await renderDetailsContent(detailsContent);
         saveSettingsDebounced();
 +        await eventSource.emit(event_types.CONNECTION_PROFILE_UPDATED, oldProfile, profile);
         await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
         toastr.success('Connection profile updated', '', { timeOut: 1500 });
     });

             return acc;
         }, {});
         const template = $(await renderExtensionTemplateAsync(MODULE_NAME, 'edit', { name: profile.name, settings }));
         constlet newName = await callGenericPopup(template, POPUP_TYPE.INPUT, profile.name, {
             rows: 2,
             customButtons: [{
                 text: t`Save and Update`,

             }],
         });
 +        // If it's cancelled, it will be false
 +        if (!newName) {
 +            return;
 +        }
 +        newName = DOMPurify.sanitize(String(newName));
         if (!newName) {
 +            toastr.error('Name cannot be empty.');
             return;
+        }

             return Object.entries(FANCY_NAMES).find(x => x[1] === String($(this).val()))?.[0];
         }).get();
 +        const oldProfile = structuredClone(profile);
         if (newExcludeList.length !== profile.exclude.length || !newExcludeList.every(e => profile.exclude.includes(e))) {
             profile.exclude = newExcludeList;
             for (const command of newExcludeList) {

         if (profile.name !== newName) {
             toastr.success('Connection profile renamed.');
             profile.name = String(newName);
+        }
         saveSettingsDebounced();
 +        await eventSource.emit(event_types.CONNECTION_PROFILE_UPDATED, oldProfile, profile);
         renderConnectionProfiles(profiles);
         await renderDetailsContent(detailsContent);
     });

             saveSettingsDebounced();
             renderConnectionProfiles(profiles);
             await renderDetailsContent(detailsContent);
 +            await eventSource.emit(event_types.CONNECTION_PROFILE_CREATED, profile);
             return profile.name;
         },
     }));

                 toastr.warning('No profile selected.');
                 return '';
+            }
 +            const oldProfile = structuredClone(profile);
             await updateConnectionProfile(profile);
             await renderDetailsContent(detailsContent);
             saveSettingsDebounced();
 +            await eventSource.emit(event_types.CONNECTION_PROFILE_UPDATED, oldProfile, profile);
             return profile.name;
         },
     }));

public/scripts/extensions/shared.js+308 -1 Viewed

 import { CONNECT_API_MAP, getRequestHeaders } from '../../script.js';
 import { extension_settings, openThirdPartyExtensionMenu } from '../extensions.js';
 +import { t } from '../i18n.js';
 import { oai_settings } from '../openai.js';
 import { SECRET_KEYS, secret_state } from '../secrets.js';
 import { textgen_types, textgenerationwebui_settings } from '../textgen-settings.js';

     const model = await engine.getCurrentModelInfo();
     return model?.context_size;
+}
++
 +/**
 + * It uses the profiles to send a generate request to the API. Doesn't support streaming.
 + */
 +export class ConnectionManagerRequestService {
 +    static defaultSendRequestParams = {
 +        extractData: true,
 +        includePreset: true,
 +        includeInstruct: true,
 +    };
++
 +    static getAllowedTypes() {
 +        return {
 +            openai: t`Chat Completion`,
 +            textgenerationwebui: t`Text Completion`,
 +        };
 +    }
++
 +    /**
 +     * @param {string} profileId
 +     * @param {string | (import('../custom-request.js').ChatCompletionMessage & {ignoreInstruct?: boolean})[]} prompt
 +     * @param {number} maxTokens
 +     * @param {{extractData?: boolean, includePreset?: boolean, includeInstruct?: boolean}} custom - default values are true
 +     * @returns {Promise<import('../custom-request.js').ExtractedData | any>} Extracted data or the raw response
 +     */
 +    static async sendRequest(profileId, prompt, maxTokens, custom = this.defaultSendRequestParams) {
 +        const { extractData, includePreset, includeInstruct } = { ...this.defaultSendRequestParams, ...custom };
++
 +        const context = SillyTavern.getContext();
 +        if (context.extensionSettings.disabledExtensions.includes('connection-manager')) {
 +            throw new Error('Connection Manager is not available');
 +        }
++
 +        const profile = context.extensionSettings.connectionManager.profiles.find((p) => p.id === profileId);
 +        const selectedApiMap = this.validateProfile(profile);
++
 +        try {
 +            switch (selectedApiMap.selected) {
 +                case 'openai': {
 +                    if (!selectedApiMap.source) {
 +                        throw new Error(`API type ${selectedApiMap.selected} does not support chat completions`);
 +                    }
++
 +                    const messages = Array.isArray(prompt) ? prompt : [{ role: 'user', content: prompt }];
 +                    return await context.ChatCompletionService.processRequest({
 +                        messages,
 +                        max_tokens: maxTokens,
 +                        model: profile.model,
 +                        chat_completion_source: selectedApiMap.source,
 +                    }, {
 +                        presetName: includePreset ? profile.preset : undefined,
 +                    }, extractData);
 +                }
 +                case 'textgenerationwebui': {
 +                    if (!selectedApiMap.type) {
 +                        throw new Error(`API type ${selectedApiMap.selected} does not support text completions`);
 +                    }
++
 +                    return await context.TextCompletionService.processRequest({
 +                        prompt,
 +                        max_tokens: maxTokens,
 +                        model: profile.model,
 +                        api_type: selectedApiMap.type,
 +                        api_server: profile['api-url'],
 +                    }, {
 +                        instructName: includeInstruct ? profile.instruct : undefined,
 +                        presetName: includePreset ? profile.preset : undefined,
 +                    }, extractData);
 +                }
 +                default: {
 +                    throw new Error(`Unknown API type ${selectedApiMap.selected}`);
 +                }
 +            }
 +        } catch (error) {
 +            throw new Error('API request failed', { cause: error });
 +        }
 +    }
++
 +    /**
 +     * Respects allowed types.
 +     * @returns {import('./connection-manager/index.js').ConnectionProfile[]}
 +     */
 +    static getSupportedProfiles() {
 +        const context = SillyTavern.getContext();
 +        if (context.extensionSettings.disabledExtensions.includes('connection-manager')) {
 +            throw new Error('Connection Manager is not available');
 +        }
++
 +        const profiles = context.extensionSettings.connectionManager.profiles;
 +        return profiles.filter((p) => this.isProfileSupported(p));
 +    }
++
 +    /**
 +     * @param {import('./connection-manager/index.js').ConnectionProfile?} [profile]
 +     * @returns {boolean}
 +     */
 +    static isProfileSupported(profile) {
 +        if (!profile) {
 +            return false;
 +        }
++
 +        const apiMap = CONNECT_API_MAP[profile.api];
 +        if (!Object.hasOwn(this.getAllowedTypes(), apiMap.selected)) {
 +            return false;
 +        }
++
 +        // Some providers not need model, like koboldcpp. But I don't want to check by provider.
 +        switch (apiMap.selected) {
 +            case 'openai':
 +                return !!apiMap.source;
 +            case 'textgenerationwebui':
 +                return !!apiMap.type;
 +        }
++
 +        return false;
 +    }
++
 +    /**
 +     * @param {import('./connection-manager/index.js').ConnectionProfile?} [profile]
 +     * @return {import('../../script.js').ConnectAPIMap}
 +     * @throws {Error}
 +     */
 +    static validateProfile(profile) {
 +        if (!profile) {
 +            throw new Error('Could not find profile.');
 +        }
 +        if (!profile.api) {
 +            throw new Error('Select a connection profile that has an API');
 +        }
++
 +        const context = SillyTavern.getContext();
 +        const selectedApiMap = context.CONNECT_API_MAP[profile.api];
 +        if (!selectedApiMap) {
 +            throw new Error(`Unknown API type ${profile.api}`);
 +        }
 +        if (!Object.hasOwn(this.getAllowedTypes(), selectedApiMap.selected)) {
 +            throw new Error(`API type ${selectedApiMap.selected} is not supported. Supported types: ${Object.values(this.getAllowedTypes()).join(', ')}`);
 +        }
++
 +        return selectedApiMap;
 +    }
++
 +    /**
 +     * Create profiles dropdown and updates select element accordingly. Use onChange, onCreate, unUpdate, onDelete callbacks for custom behaviour. e.g updating extension settings.
 +     * @param {string} selector
 +     * @param {string} initialSelectedProfileId
 +     * @param {(profile?: import('./connection-manager/index.js').ConnectionProfile) => Promise<void> | void} onChange - 3 cases. 1- When user selects new profile. 2- When user deletes selected profile. 3- When user updates selected profile.
 +     * @param {(profile: import('./connection-manager/index.js').ConnectionProfile) => Promise<void> | void} onCreate
 +     * @param {(oldProfile: import('./connection-manager/index.js').ConnectionProfile, newProfile: import('./connection-manager/index.js').ConnectionProfile) => Promise<void> | void} unUpdate
 +     * @param {(profile: import('./connection-manager/index.js').ConnectionProfile) => Promise<void> | void} onDelete
 +     */
 +    static handleDropdown(
 +        selector,
 +        initialSelectedProfileId,
 +        onChange = () => { },
 +        onCreate = () => { },
 +        unUpdate = () => { },
 +        onDelete = () => { },
 +    ) {
 +        const context = SillyTavern.getContext();
 +        if (context.extensionSettings.disabledExtensions.includes('connection-manager')) {
 +            throw new Error('Connection Manager is not available');
 +        }
++
 +        /**
 +         * @type {JQuery<HTMLSelectElement>}
 +         */
 +        const dropdown = $(selector);
++
 +        if (!dropdown || !dropdown.length) {
 +            throw new Error(`Could not find dropdown with selector ${selector}`);
 +        }
++
 +        dropdown.empty();
++
 +        // Create default option using document.createElement
 +        const defaultOption = document.createElement('option');
 +        defaultOption.value = '';
 +        defaultOption.textContent = 'Select a Connection Profile';
 +        defaultOption.dataset.i18n = 'Select a Connection Profile';
 +        dropdown.append(defaultOption);
++
 +        const profiles = context.extensionSettings.connectionManager.profiles;
++
 +        // Create optgroups using document.createElement
 +        const groups = {};
 +        for (const [apiType, groupLabel] of Object.entries(this.getAllowedTypes())) {
 +            const optgroup = document.createElement('optgroup');
 +            optgroup.label = groupLabel;
 +            groups[apiType] = optgroup;
 +        }
++
 +        const sortedProfilesByGroup = {};
 +        for (const apiType of Object.keys(this.getAllowedTypes())) {
 +            sortedProfilesByGroup[apiType] = [];
 +        }
++
 +        for (const profile of profiles) {
 +            if (this.isProfileSupported(profile)) {
 +                const apiMap = CONNECT_API_MAP[profile.api];
 +                if (sortedProfilesByGroup[apiMap.selected]) {
 +                    sortedProfilesByGroup[apiMap.selected].push(profile);
 +                }
 +            }
 +        }
++
 +        // Sort each group alphabetically and add to dropdown
 +        for (const [apiType, groupProfiles] of Object.entries(sortedProfilesByGroup)) {
 +            if (groupProfiles.length === 0) continue;
++
 +            groupProfiles.sort((a, b) => a.name.localeCompare(b.name));
++
 +            const group = groups[apiType];
 +            for (const profile of groupProfiles) {
 +                const option = document.createElement('option');
 +                option.value = profile.id;
 +                option.textContent = profile.name;
 +                group.appendChild(option);
 +            }
 +        }
++
 +        for (const group of Object.values(groups)) {
 +            if (group.children.length > 0) {
 +                dropdown.append(group);
 +            }
 +        }
++
 +        const selectedProfile = profiles.find((p) => p.id === initialSelectedProfileId);
 +        if (selectedProfile) {
 +            dropdown.val(selectedProfile.id);
 +        }
++
 +        context.eventSource.on(context.eventTypes.CONNECTION_PROFILE_CREATED, async (profile) => {
 +            const isSupported = this.isProfileSupported(profile);
 +            if (!isSupported) {
 +                return;
 +            }
++
 +            const group = groups[CONNECT_API_MAP[profile.api].selected];
 +            const option = document.createElement('option');
 +            option.value = profile.id;
 +            option.textContent = profile.name;
 +            group.appendChild(option);
++
 +            await onCreate(profile);
 +        });
++
 +        context.eventSource.on(context.eventTypes.CONNECTION_PROFILE_UPDATED, async (oldProfile, newProfile) => {
 +            const currentSelected = dropdown.val();
 +            const isSelectedProfile = currentSelected === oldProfile.id;
 +            await unUpdate(oldProfile, newProfile);
++
 +            if (!this.isProfileSupported(newProfile)) {
 +                if (isSelectedProfile) {
 +                    dropdown.val('');
 +                    dropdown.trigger('change');
 +                }
 +                return;
 +            }
++
 +            const group = groups[CONNECT_API_MAP[newProfile.api].selected];
 +            const oldOption = group.querySelector(`option[value="${oldProfile.id}"]`);
 +            if (oldOption) {
 +                oldOption.remove();
 +            }
++
 +            const option = document.createElement('option');
 +            option.value = newProfile.id;
 +            option.textContent = newProfile.name;
 +            group.appendChild(option);
++
 +            if (isSelectedProfile) {
 +                // Ackchyually, we don't need to reselect but what if id changes? It is not possible for now I couldn't stop myself.
 +                dropdown.val(newProfile.id);
 +                dropdown.trigger('change');
 +            }
 +        });
++
 +        context.eventSource.on(context.eventTypes.CONNECTION_PROFILE_DELETED, async (profile) => {
 +            const currentSelected = dropdown.val();
 +            const isSelectedProfile = currentSelected === profile.id;
 +            if (!this.isProfileSupported(profile)) {
 +                return;
 +            }
++
 +            const group = groups[CONNECT_API_MAP[profile.api].selected];
 +            const optionToRemove = group.querySelector(`option[value="${profile.id}"]`);
 +            if (optionToRemove) {
 +                optionToRemove.remove();
 +            }
++
 +            if (isSelectedProfile) {
 +                dropdown.val('');
 +                dropdown.trigger('change');
 +            }
++
 +            await onDelete(profile);
 +        });
++
 +        dropdown.on('change', async () => {
 +            const profileId = dropdown.val();
 +            const profile = context.extensionSettings.connectionManager.profiles.find((p) => p.id === profileId);
 +            await onChange(profile);
 +        });
 +    }
 +}

public/scripts/instruct-mode.js+35 -31 Viewed

@@ -320,59 +320,61 @@ export const force_output_sequence = {
320	320	* @param {string} name1 User name.
321	321	* @param {string} name2 Character name.
322	322	* @param {boolean\|number} forceOutputSequence Force to use first/last output sequence (if configured).
	323	+ * @param {InstructSettings} customInstruct Custom instruct mode settings.
323	324	* @returns {string} Formatted instruct mode chat message.
324	325	*/
325	326	export function formatInstructModeChat(name, mes, isUser, isNarrator, forceAvatar, name1, name2, forceOutputSequence, customInstruct = null) {
326	327	letconst includeNamesinstruct = isNarratorstructuredClone(customInstruct ? false :? power_user.instruct.names_behavior === names_behavior_types.ALWAYS);
	328	+ let includeNames = isNarrator ? false : instruct.names_behavior === names_behavior_types.ALWAYS;
327	329
328	330	if (!isNarrator && power_user.instruct.names_behavior === names_behavior_types.FORCE && ((selected_group && name !== name1) \|\| (forceAvatar && name !== name1))) {
329	331	includeNames = true;
330	332	}
331	333
332	334	function getPrefix() {
333	335	if (isNarrator) {
334	336	return power_user.instruct.system_same_as_user ? power_user.instruct.input_sequence : power_user.instruct.system_sequence;
335	337	}
336	338
337	339	if (isUser) {
338	340	if (forceOutputSequence === force_output_sequence.FIRST) {
339	341	return power_user.instruct.first_input_sequence \|\| power_user.instruct.input_sequence;
340	342	}
341	343
342	344	if (forceOutputSequence === force_output_sequence.LAST) {
343	345	return power_user.instruct.last_input_sequence \|\| power_user.instruct.input_sequence;
344	346	}
345	347
346	348	return power_user.instruct.input_sequence;
347	349	}
348	350
349	351	if (forceOutputSequence === force_output_sequence.FIRST) {
350	352	return power_user.instruct.first_output_sequence \|\| power_user.instruct.output_sequence;
351	353	}
352	354
353	355	if (forceOutputSequence === force_output_sequence.LAST) {
354	356	return power_user.instruct.last_output_sequence \|\| power_user.instruct.output_sequence;
355	357	}
356	358
357	359	return power_user.instruct.output_sequence;
358	360	}
359	361
360	362	function getSuffix() {
361	363	if (isNarrator) {
362	364	return power_user.instruct.system_same_as_user ? power_user.instruct.input_suffix : power_user.instruct.system_suffix;
363	365	}
364	366
365	367	if (isUser) {
366	368	return power_user.instruct.input_suffix;
367	369	}
368	370
369	371	return power_user.instruct.output_suffix;
370	372	}
371	373
372	374	let prefix = getPrefix() \|\| '';
373	375	let suffix = getSuffix() \|\| '';
374	376
375	377	if (power_user.instruct.macro) {
376	378	prefix = substituteParams(prefix, name1, name2);
377	379	prefix = prefix.replace(/{{name}}/gi, name \|\| 'System');
378	380

@@ -380,11 +382,11 @@ export function formatInstructModeChat(name, mes, isUser, isNarrator, forceAvata
380	382	suffix = suffix.replace(/{{name}}/gi, name \|\| 'System');
381	383	}
382	384
383	385	if (!suffix && power_user.instruct.wrap) {
384	386	suffix = '\n';
385	387	}
386	388
387	389	const separator = power_user.instruct.wrap ? '\n' : '';
388	390
389	391	// Don't include the name if it's empty
390	392	const textArray = includeNames && name ? [prefix, `${name}: ${mes}` + suffix] : [prefix, mes + suffix];

  * @param {string} name2 Character name.
  * @param {boolean} isQuiet Is quiet mode generation.
  * @param {boolean} isQuietToLoud Is quiet to loud generation.
 + * @param {InstructSettings} customInstruct Custom instruct settings.
  * @returns {string} Formatted instruct mode last prompt line.
  */
 export function formatInstructModePrompt(name, isImpersonate, promptBias, name1, name2, isQuiet, isQuietToLoud, customInstruct = null) {
 -    const includeNames = name && (power_user.instruct.names_behavior === names_behavior_types.ALWAYS || (!!selected_group && power_user.instruct.names_behavior === names_behavior_types.FORCE)) && !(isQuiet && !isQuietToLoud);
 +    const instruct = structuredClone(customInstruct ?? power_user.instruct);
 +    const includeNames = name && (instruct.names_behavior === names_behavior_types.ALWAYS || (!!selected_group && instruct.names_behavior === names_behavior_types.FORCE)) && !(isQuiet && !isQuietToLoud);
     function getSequence() {
         // User impersonation prompt
         if (isImpersonate) {
             return power_user.instruct.input_sequence;
+        }
         // Neutral / system / quiet prompt
         // Use a special quiet instruct sequence if defined, or assistant's output sequence otherwise
         if (isQuiet && !isQuietToLoud) {
             return power_user.instruct.last_system_sequence || power_user.instruct.output_sequence;
+        }
         // Quiet in-character prompt
         if (isQuiet && isQuietToLoud) {
             return power_user.instruct.last_output_sequence || power_user.instruct.output_sequence;
+        }
         // Default AI response
         return power_user.instruct.last_output_sequence || power_user.instruct.output_sequence;
+    }
     let sequence = getSequence() || '';

     // A hack for Mistral's formatting that has a normal output sequence ending with a space
     if (
         includeNames &&
         power_user.instruct.last_output_sequence &&
         power_user.instruct.output_sequence &&
         sequence === power_user.instruct.last_output_sequence &&
         /\s$/.test(power_user.instruct.output_sequence) &&
         !/\s$/.test(power_user.instruct.last_output_sequence)
     ) {
         nameFiller = power_user.instruct.output_sequence.slice(-1);
+    }
     if (power_user.instruct.macro) {
         sequence = substituteParams(sequence, name1, name2);
         sequence = sequence.replace(/{{name}}/gi, name || 'System');
+    }
     const separator = power_user.instruct.wrap ? '\n' : '';
     let text = includeNames ? (separator + sequence + separator + nameFiller + `${name}:`) : (separator + sequence);
     // Quiet prompt already has a newline at the end

@@ -562,7 +566,7 @@ export function formatInstructModePrompt(name, isImpersonate, promptBias, name1,
562	566	text += (includeNames ? promptBias : (separator + promptBias.trimStart()));
563	567	}
564	568
565	569	return (power_user.instruct.wrap ? text.trimEnd() : text) + (includeNames ? '' : separator);
566	570	}
567	571
568	572	/**

public/scripts/power-user.js+2 -0 Viewed

         system_sequence: '',
         system_suffix: '',
         last_system_sequence: '',
 +        first_input_sequence: '',
         first_output_sequence: '',
 +        last_input_sequence: '',
         last_output_sequence: '',
         system_sequence_prefix: '',
         system_sequence_suffix: '',

public/scripts/reasoning.js+10 -5 Viewed

  * @param {object} data Response data
  * @returns {string} Extracted reasoning
  */
 export function extractReasoningFromData(data), {
 -    switch (main_api) {
 +    mainApi = null,
 +    ignoreShowThoughts = false,
 +    textGenType = null,
 +    chatCompletionSource = null
 +} = {}) {
 +    switch (mainApi ?? main_api) {
         case 'textgenerationwebui':
             switch (textGenType ?? textgenerationwebui_settings.type) {
                 case textgen_types.OPENROUTER:
                     return data?.choices?.[0]?.reasoning ?? '';
+            }
             break;
         case 'openai':
             if (!ignoreShowThoughts && !oai_settings.show_thoughts) break;
             switch (chatCompletionSource ?? oai_settings.chat_completion_source) {
                 case chat_completion_sources.DEEPSEEK:
                     return data?.choices?.[0]?.message?.reasoning_content ?? '';
                 case chat_completion_sources.OPENROUTER:

public/scripts/st-context.js+2 -0 Viewed

 import { getGlobalVariable, getLocalVariable, setGlobalVariable, setLocalVariable } from './variables.js';
 import { convertCharacterBook, loadWorldInfo, saveWorldInfo, updateWorldInfoList } from './world-info.js';
 import { ChatCompletionService, TextCompletionService } from './custom-request.js';
 +import { ConnectionManagerRequestService } from './extensions/shared.js';
 import { updateReasoningUI, parseReasoningFromString } from './reasoning.js';
 export function getContext() {

         clearChat,
         ChatCompletionService,
         TextCompletionService,
 +        ConnectionManagerRequestService,
         updateReasoningUI,
         parseReasoningFromString,
         unshallowCharacter,

public/scripts/textgen-settings.js+1 -1 Viewed

     'encoder_repetition_penalty',
     'no_repeat_ngram',
 ];
 export const APHRODITE_DEFAULT_ORDER = [
     'dry',
     'penalties',
     'no_repeat_ngram',