Merge pull request #2797 from SillyTavern/connection-manager Implement Connection Manager

d9ea3d48dd00ab1ac9aba3e72cefe6f3a548f9f6

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

Signed

Parents: 6f9846a29041bf6f9c14b412982a277ea3cc0681 c7650576845dca33ee3e4ef2beb44e0ad635f6c0

public/script.js+13 -6 Viewed

 import { initDynamicStyles } from './scripts/dynamic-styles.js';
 import { SlashCommandEnumValue, enumTypes } from './scripts/slash-commands/SlashCommandEnumValue.js';
 import { commonEnumProviders, enumIcons } from './scripts/slash-commands/SlashCommandCommonEnumsProvider.js';
+import { AbortReason } from './scripts/util/AbortReason.js';
 //exporting functions and vars for mods
 export {

     LLM_FUNCTION_TOOL_CALL: 'llm_function_tool_call',
     ONLINE_STATUS_CHANGED: 'online_status_changed',
     IMAGE_SWIPED: 'image_swiped',
+    CONNECTION_PROFILE_LOADED: 'connection_profile_loaded',
 };
 export const eventSource = new EventEmitter();

@@ -977,8 +979,8 @@ async function fixViewport() {
977	document.body.style.position = '';	979	document.body.style.position = '';
978	}	980	}
979		981
980	function cancelStatusCheck() {	982	function cancelStatusCheck(reason = 'Manually cancelled status check') {
981	abortStatusCheck?.abort();	983	abortStatusCheck?.abort(new AbortReason(reason));
982	abortStatusCheck = new AbortController();	984	abortStatusCheck = new AbortController();
983	setOnlineStatus('no_connection');	985	setOnlineStatus('no_connection');
984	}	986	}

             toastr.error(data.response, 'API Error', { timeOut: 5000, preventDuplicates: true });
+        }
     } catch (err) {
+        if (err instanceof AbortReason) {
+            console.info('Status check aborted.', err.reason);
+        } else {
             console.error('Error getting status', err);
+        }
         setOnlineStatus('no_connection');
+    }

@@ -8519,7 +8526,7 @@ async function selectContextCallback(args, name) {
8519	}	8526	}
8520		8527
8521	const foundName = result[0].item;	8528	const foundName = result[0].item;
8522	selectContextPreset(foundName, quiet);	8529	selectContextPreset(foundName, { quiet: quiet });
8523	return foundName;	8530	return foundName;
8524	}	8531	}
8525		8532

@@ -8539,7 +8546,7 @@ async function selectInstructCallback(args, name) {
8539	}	8546	}
8540		8547
8541	const foundName = result[0].item;	8548	const foundName = result[0].item;
8542	selectInstructPreset(foundName, quiet);	8549	selectInstructPreset(foundName, { quiet: quiet });
8543	return foundName;	8550	return foundName;
8544	}	8551	}
8545		8552

         $('#groupCurrentMemberListToggle .inline-drawer-icon').trigger('click');
     }, 200);
-    $(document).on('click', '.api_loading', cancelStatusCheck);
+    $(document).on('click', '.api_loading', () => cancelStatusCheck('Canceled because connecting was manually canceled'));
     //////////INPUT BAR FOCUS-KEEPING LOGIC/////////////
     let S_TAPreviouslyFocused = false;

     });
     $('#main_api').change(function () {
-        cancelStatusCheck();
+        cancelStatusCheck('Canceled because main api changed');
         changeMainAPI();
         saveSettingsDebounced();
     });

public/scripts/extensions.js+5 -0 Viewed

         /** @type {string[]} */
         custom: [],
     },
+    connectionManager: {
+        selectedProfile: '',
+        /** @type {import('./extensions/connection-manager/index.js').ConnectionProfile[]} */
+        profiles: [],
+    },
     dice: {},
     /** @type {import('./char-data.js').RegexScriptData[]} */
     regex: [],

public/scripts/extensions/connection-manager/index.js+594 -0 Viewed

+import { event_types, eventSource, main_api, saveSettingsDebounced } from '../../../script.js';
+import { extension_settings, renderExtensionTemplateAsync } from '../../extensions.js';
+import { callGenericPopup, Popup, POPUP_TYPE } from '../../popup.js';
+import { executeSlashCommandsWithOptions } from '../../slash-commands.js';
+import { SlashCommand } from '../../slash-commands/SlashCommand.js';
+import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from '../../slash-commands/SlashCommandArgument.js';
+import { commonEnumProviders, enumIcons } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
+import { enumTypes, SlashCommandEnumValue } from '../../slash-commands/SlashCommandEnumValue.js';
+import { SlashCommandParser } from '../../slash-commands/SlashCommandParser.js';
+import { collapseSpaces, getUniqueName, isFalseBoolean, uuidv4 } from '../../utils.js';
+const MODULE_NAME = 'connection-manager';
+const NONE = '<None>';
+const DEFAULT_SETTINGS = {
+    profiles: [],
+    selectedProfile: null,
+};
+const COMMON_COMMANDS = [
+    'api',
+    'preset',
+    'api-url',
+    'model',
+];
+const CC_COMMANDS = [
+    ...COMMON_COMMANDS,
+    'proxy',
+];
+const TC_COMMANDS = [
+    ...COMMON_COMMANDS,
+    'instruct',
+    'context',
+    'instruct-state',
+    'tokenizer',
+];
+const FANCY_NAMES = {
+    'api': 'API',
+    'api-url': 'Server URL',
+    'preset': 'Settings Preset',
+    'model': 'Model',
+    'proxy': 'Proxy Preset',
+    'instruct-state': 'Instruct Mode',
+    'instruct': 'Instruct Template',
+    'context': 'Context Template',
+    'tokenizer': 'Tokenizer',
+};
+/**
+ * A wrapper for the connection manager spinner.
+ */
+class ConnectionManagerSpinner {
+    /**
+     * @type {AbortController[]}
+     */
+    static abortControllers = [];
+    /** @type {HTMLElement} */
+    spinnerElement;
+    /** @type {AbortController} */
+    abortController = new AbortController();
+    constructor() {
+        // @ts-ignore
+        this.spinnerElement = document.getElementById('connection_profile_spinner');
+        this.abortController = new AbortController();
+    }
+    start() {
+        ConnectionManagerSpinner.abortControllers.push(this.abortController);
+        this.spinnerElement.classList.remove('hidden');
+    }
+    stop() {
+        this.spinnerElement.classList.add('hidden');
+    }
+    isAborted() {
+        return this.abortController.signal.aborted;
+    }
+    static abort() {
+        for (const controller of ConnectionManagerSpinner.abortControllers) {
+            controller.abort();
+        }
+        ConnectionManagerSpinner.abortControllers = [];
+    }
+}
+/** @type {() => SlashCommandEnumValue[]} */
+const profilesProvider = () => [
+    new SlashCommandEnumValue(NONE),
+    ...extension_settings.connectionManager.profiles.map(p => new SlashCommandEnumValue(p.name, null, enumTypes.name, enumIcons.server)),
+];
+/**
+ * @typedef {Object} ConnectionProfile
+ * @property {string} id Unique identifier
+ * @property {string} mode Mode of the connection profile
+ * @property {string} [name] Name of the connection profile
+ * @property {string} [api] API
+ * @property {string} [preset] Settings Preset
+ * @property {string} [model] Model
+ * @property {string} [proxy] Proxy Preset
+ * @property {string} [instruct] Instruct Template
+ * @property {string} [context] Context Template
+ * @property {string} [instruct-state] Instruct Mode
+ * @property {string} [tokenizer] Tokenizer
+ */
+const escapeArgument = (a) => a.replace(/"/g, '\\"').replace(/\|/g, '\\|');
+/**
+ * Finds the best match for the search value.
+ * @param {string} value Search value
+ * @returns {ConnectionProfile|null} Best match or null
+ */
+function findProfileByName(value) {
+    // Try to find exact match
+    const profile = extension_settings.connectionManager.profiles.find(p => p.name === value);
+    if (profile) {
+        return profile;
+    }
+    // Try to find fuzzy match
+    const fuse = new Fuse(extension_settings.connectionManager.profiles, { keys: ['name'] });
+    const results = fuse.search(value);
+    if (results.length === 0) {
+        return null;
+    }
+    const bestMatch = results[0];
+    return bestMatch.item;
+}
+/**
+ * Reads the connection profile from the commands.
+ * @param {string} mode Mode of the connection profile
+ * @param {ConnectionProfile} profile Connection profile
+ * @param {boolean} [cleanUp] Whether to clean up the profile
+ */
+async function readProfileFromCommands(mode, profile, cleanUp = false) {
+    const commands = mode === 'cc' ? CC_COMMANDS : TC_COMMANDS;
+    const opposingCommands = mode === 'cc' ? TC_COMMANDS : CC_COMMANDS;
+    for (const command of commands) {
+        const commandText = `/${command} quiet=true`;
+        try {
+            const result = await executeSlashCommandsWithOptions(commandText, { handleParserErrors: false, handleExecutionErrors: false });
+            if (result.pipe) {
+                profile[command] = result.pipe;
+                continue;
+            }
+        } catch (error) {
+            console.warn(`Failed to execute command: ${commandText}`, error);
+        }
+    }
+    if (cleanUp) {
+        for (const command of opposingCommands) {
+            if (commands.includes(command)) {
+                continue;
+            }
+            delete profile[command];
+        }
+    }
+}
+/**
+ * Creates a new connection profile.
+ * @param {string} [forceName] Name of the connection profile
+ * @returns {Promise<ConnectionProfile>} Created connection profile
+ */
+async function createConnectionProfile(forceName = null) {
+    const mode = main_api === 'openai' ? 'cc' : 'tc';
+    const id = uuidv4();
+    const profile = {
+        id,
+        mode,
+    };
+    await readProfileFromCommands(mode, profile);
+    const profileForDisplay = makeFancyProfile(profile);
+    const template = await renderExtensionTemplateAsync(MODULE_NAME, 'profile', { profile: profileForDisplay });
+    const isNameTaken = (n) => extension_settings.connectionManager.profiles.some(p => p.name === n);
+    const suggestedName = getUniqueName(collapseSpaces(`${profile.api ?? ''} ${profile.model ?? ''} - ${profile.preset ?? ''}`), isNameTaken);
+    const name = forceName ?? await callGenericPopup(template, POPUP_TYPE.INPUT, suggestedName, { rows: 2 });
+    if (!name) {
+        return null;
+    }
+    if (isNameTaken(name) || name === NONE) {
+        toastr.error('A profile with the same name already exists.');
+        return null;
+    }
+    profile.name = name;
+    return profile;
+}
+/**
+ * Deletes the selected connection profile.
+ * @returns {Promise<void>}
+ */
+async function deleteConnectionProfile() {
+    const selectedProfile = extension_settings.connectionManager.selectedProfile;
+    if (!selectedProfile) {
+        return;
+    }
+    const index = extension_settings.connectionManager.profiles.findIndex(p => p.id === selectedProfile);
+    if (index === -1) {
+        return;
+    }
+    const name = extension_settings.connectionManager.profiles[index].name;
+    const confirm = await Popup.show.confirm('Are you sure you want to delete the selected profile?', name);
+    if (!confirm) {
+        return;
+    }
+    extension_settings.connectionManager.profiles.splice(index, 1);
+    extension_settings.connectionManager.selectedProfile = null;
+    saveSettingsDebounced();
+}
+/**
+ * Formats the connection profile for display.
+ * @param {ConnectionProfile} profile Connection profile
+ * @returns {Object} Fancy profile
+ */
+function makeFancyProfile(profile) {
+    return Object.entries(FANCY_NAMES).reduce((acc, [key, value]) => {
+        if (!profile[key]) return acc;
+        acc[value] = profile[key];
+        return acc;
+    }, {});
+}
+/**
+ * Applies the connection profile.
+ * @param {ConnectionProfile} profile Connection profile
+ * @returns {Promise<void>}
+ */
+async function applyConnectionProfile(profile) {
+    if (!profile) {
+        return;
+    }
+    // Abort any ongoing profile application
+    ConnectionManagerSpinner.abort();
+    const mode = profile.mode;
+    const commands = mode === 'cc' ? CC_COMMANDS : TC_COMMANDS;
+    const spinner = new ConnectionManagerSpinner();
+    spinner.start();
+    for (const command of commands) {
+        if (spinner.isAborted()) {
+            throw new Error('Profile application aborted');
+        }
+        const argument = profile[command];
+        if (!argument) {
+            continue;
+        }
+        const commandText = `/${command} quiet=true ${escapeArgument(argument)}`;
+        try {
+            await executeSlashCommandsWithOptions(commandText, { handleParserErrors: false, handleExecutionErrors: false });
+        } catch (error) {
+            console.error(`Failed to execute command: ${commandText}`, error);
+        }
+    }
+    spinner.stop();
+}
+/**
+ * Updates the selected connection profile.
+ * @param {ConnectionProfile} profile Connection profile
+ * @returns {Promise<void>}
+ */
+async function updateConnectionProfile(profile) {
+    profile.mode = main_api === 'openai' ? 'cc' : 'tc';
+    await readProfileFromCommands(profile.mode, profile, true);
+}
+/**
+ * Renders the connection profile details.
+ * @param {HTMLSelectElement} profiles Select element containing connection profiles
+ */
+function renderConnectionProfiles(profiles) {
+    profiles.innerHTML = '';
+    const noneOption = document.createElement('option');
+    noneOption.value = '';
+    noneOption.textContent = NONE;
+    noneOption.selected = !extension_settings.connectionManager.selectedProfile;
+    profiles.appendChild(noneOption);
+    for (const profile of extension_settings.connectionManager.profiles) {
+        const option = document.createElement('option');
+        option.value = profile.id;
+        option.textContent = profile.name;
+        option.selected = profile.id === extension_settings.connectionManager.selectedProfile;
+        profiles.appendChild(option);
+    }
+}
+/**
+ * Renders the content of the details element.
+ * @param {HTMLElement} detailsContent Content element of the details
+ */
+async function renderDetailsContent(detailsContent) {
+    detailsContent.innerHTML = '';
+    if (detailsContent.classList.contains('hidden')) {
+        return;
+    }
+    const selectedProfile = extension_settings.connectionManager.selectedProfile;
+    const profile = extension_settings.connectionManager.profiles.find(p => p.id === selectedProfile);
+    if (profile) {
+        const profileForDisplay = makeFancyProfile(profile);
+        const template = await renderExtensionTemplateAsync(MODULE_NAME, 'view', { profile: profileForDisplay });
+        detailsContent.innerHTML = template;
+    } else {
+        detailsContent.textContent = 'No profile selected';
+    }
+}
+(async function () {
+    extension_settings.connectionManager = extension_settings.connectionManager || structuredClone(DEFAULT_SETTINGS);
+    for (const key of Object.keys(DEFAULT_SETTINGS)) {
+        if (extension_settings.connectionManager[key] === undefined) {
+            extension_settings.connectionManager[key] = DEFAULT_SETTINGS[key];
+        }
+    }
+    const container = document.getElementById('rm_api_block');
+    const settings = await renderExtensionTemplateAsync(MODULE_NAME, 'settings');
+    container.insertAdjacentHTML('afterbegin', settings);
+    /** @type {HTMLSelectElement} */
+    // @ts-ignore
+    const profiles = document.getElementById('connection_profiles');
+    renderConnectionProfiles(profiles);
+    function toggleProfileSpecificButtons() {
+        const profileId = extension_settings.connectionManager.selectedProfile;
+        const profileSpecificButtons = ['update_connection_profile', 'reload_connection_profile', 'delete_connection_profile'];
+        profileSpecificButtons.forEach(id => document.getElementById(id).classList.toggle('disabled', !profileId));
+    }
+    toggleProfileSpecificButtons();
+    profiles.addEventListener('change', async function () {
+        const selectedProfile = profiles.selectedOptions[0];
+        if (!selectedProfile) {
+            // Safety net for preventing the command getting stuck
+            await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, NONE);
+            return;
+        }
+        const profileId = selectedProfile.value;
+        extension_settings.connectionManager.selectedProfile = profileId;
+        saveSettingsDebounced();
+        await renderDetailsContent(detailsContent);
+        toggleProfileSpecificButtons();
+        // None option selected
+        if (!profileId) {
+            await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, NONE);
+            return;
+        }
+        const profile = extension_settings.connectionManager.profiles.find(p => p.id === profileId);
+        if (!profile) {
+            console.log(`Profile not found: ${profileId}`);
+            return;
+        }
+        await applyConnectionProfile(profile);
+        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
+    });
+    const reloadButton = document.getElementById('reload_connection_profile');
+    reloadButton.addEventListener('click', async () => {
+        const selectedProfile = extension_settings.connectionManager.selectedProfile;
+        const profile = extension_settings.connectionManager.profiles.find(p => p.id === selectedProfile);
+        if (!profile) {
+            console.log('No profile selected');
+            return;
+        }
+        await applyConnectionProfile(profile);
+        await renderDetailsContent(detailsContent);
+        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
+        toastr.success('Connection profile reloaded', '', { timeOut: 1500 });
+    });
+    const createButton = document.getElementById('create_connection_profile');
+    createButton.addEventListener('click', async () => {
+        const profile = await createConnectionProfile();
+        if (!profile) {
+            return;
+        }
+        extension_settings.connectionManager.profiles.push(profile);
+        extension_settings.connectionManager.selectedProfile = profile.id;
+        saveSettingsDebounced();
+        renderConnectionProfiles(profiles);
+        await renderDetailsContent(detailsContent);
+        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
+    });
+    const updateButton = document.getElementById('update_connection_profile');
+    updateButton.addEventListener('click', async () => {
+        const selectedProfile = extension_settings.connectionManager.selectedProfile;
+        const profile = extension_settings.connectionManager.profiles.find(p => p.id === selectedProfile);
+        if (!profile) {
+            console.log('No profile selected');
+            return;
+        }
+        await updateConnectionProfile(profile);
+        await renderDetailsContent(detailsContent);
+        saveSettingsDebounced();
+        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
+        toastr.success('Connection profile updated', '', { timeOut: 1500 });
+    });
+    const deleteButton = document.getElementById('delete_connection_profile');
+    deleteButton.addEventListener('click', async () => {
+        await deleteConnectionProfile();
+        renderConnectionProfiles(profiles);
+        await renderDetailsContent(detailsContent);
+        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, NONE);
+    });
+    /** @type {HTMLElement} */
+    const viewDetails = document.getElementById('view_connection_profile');
+    const detailsContent = document.getElementById('connection_profile_details_content');
+    viewDetails.addEventListener('click', async () => {
+        viewDetails.classList.toggle('active');
+        detailsContent.classList.toggle('hidden');
+        await renderDetailsContent(detailsContent);
+    });
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'profile',
+        helpString: 'Switch to a connection profile or return the name of the current profile in no argument is provided. Use <code>&lt;None&gt;</code> to switch to no profile.',
+        returns: 'name of the profile',
+        unnamedArgumentList: [
+            SlashCommandArgument.fromProps({
+                description: 'Name of the connection profile',
+                enumProvider: profilesProvider,
+                isRequired: false,
+            }),
+        ],
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'await',
+                description: 'Wait for the connection profile to be applied before returning.',
+                isRequired: false,
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'true',
+                enumList: commonEnumProviders.boolean('trueFalse')(),
+            }),
+        ],
+        callback: async (args, value) => {
+            if (!value || typeof value !== 'string') {
+                const selectedProfile = extension_settings.connectionManager.selectedProfile;
+                const profile = extension_settings.connectionManager.profiles.find(p => p.id === selectedProfile);
+                if (!profile) {
+                    return NONE;
+                }
+                return profile.name;
+            }
+            if (value === NONE) {
+                profiles.selectedIndex = 0;
+                profiles.dispatchEvent(new Event('change'));
+                return NONE;
+            }
+            const profile = findProfileByName(value);
+            if (!profile) {
+                return '';
+            }
+            const shouldAwait = !isFalseBoolean(String(args?.await));
+            const awaitPromise = new Promise((resolve) => eventSource.once(event_types.CONNECTION_PROFILE_LOADED, resolve));
+            profiles.selectedIndex = Array.from(profiles.options).findIndex(o => o.value === profile.id);
+            profiles.dispatchEvent(new Event('change'));
+            if (shouldAwait) {
+                await awaitPromise;
+            }
+            return profile.name;
+        },
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'profile-list',
+        helpString: 'List all connection profile names.',
+        returns: 'list of profile names',
+        callback: () => JSON.stringify(extension_settings.connectionManager.profiles.map(p => p.name)),
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'profile-create',
+        returns: 'name of the new profile',
+        helpString: 'Create a new connection profile using the current settings.',
+        unnamedArgumentList: [
+            SlashCommandArgument.fromProps({
+                description: 'name of the new connection profile',
+                isRequired: true,
+                typeList: [ARGUMENT_TYPE.STRING],
+            }),
+        ],
+        callback: async (_args, name) => {
+            if (!name || typeof name !== 'string') {
+                toastr.warning('Please provide a name for the new connection profile.');
+                return '';
+            }
+            const profile = await createConnectionProfile(name);
+            if (!profile) {
+                return '';
+            }
+            extension_settings.connectionManager.profiles.push(profile);
+            extension_settings.connectionManager.selectedProfile = profile.id;
+            saveSettingsDebounced();
+            renderConnectionProfiles(profiles);
+            await renderDetailsContent(detailsContent);
+            return profile.name;
+        },
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'profile-update',
+        helpString: 'Update the selected connection profile.',
+        callback: async () => {
+            const selectedProfile = extension_settings.connectionManager.selectedProfile;
+            const profile = extension_settings.connectionManager.profiles.find(p => p.id === selectedProfile);
+            if (!profile) {
+                toastr.warning('No profile selected.');
+                return '';
+            }
+            await updateConnectionProfile(profile);
+            await renderDetailsContent(detailsContent);
+            saveSettingsDebounced();
+            return profile.name;
+        },
+    }));
+    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
+        name: 'profile-get',
+        helpString: 'Get the details of the connection profile. Returns the selected profile if no argument is provided.',
+        returns: 'object of the selected profile',
+        unnamedArgumentList: [
+            SlashCommandArgument.fromProps({
+                description: 'Name of the connection profile',
+                enumProvider: profilesProvider,
+                isRequired: false,
+            }),
+        ],
+        callback: async (_args, value) => {
+            if (!value || typeof value !== 'string') {
+                const selectedProfile = extension_settings.connectionManager.selectedProfile;
+                const profile = extension_settings.connectionManager.profiles.find(p => p.id === selectedProfile);
+                if (!profile) {
+                    return '';
+                }
+                return JSON.stringify(profile);
+            }
+            const profile = findProfileByName(value);
+            if (!profile) {
+                return '';
+            }
+            return JSON.stringify(profile);
+        },
+    }));
+})();

public/scripts/extensions/connection-manager/manifest.json+11 -0 Viewed

+{
+    "display_name": "Connection Profiles",
+    "loading_order": 1,
+    "requires": [],
+    "optional": [],
+    "js": "index.js",
+    "css": "style.css",
+    "author": "Cohee1207",
+    "version": "1.0.0",
+    "homePage": "https://github.com/SillyTavern/SillyTavern"
+}

public/scripts/extensions/connection-manager/profile.html+13 -0 Viewed

+<div>
+    <h2 data-i18n="Creating a Connection Profile">
+        Creating a Connection Profile
+    </h2>
+    <ul class="justifyLeft">
+        {{#each profile}}
+        <li><strong data-i18n="{{@key}}">{{@key}}:</strong>&nbsp;{{this}}</li>
+        {{/each}}
+    </ul>
+    <h3 data-i18n="Enter a name:">
+        Enter a name:
+    </h3>
+</div>

public/scripts/extensions/connection-manager/settings.html+18 -0 Viewed

+<div class="wide100p">
+    <div class="flex-container alignItemsBaseline">
+        <h3 data-i18n="Connection Profile" class="margin0">
+            Connection Profile
+        </h3>
+        <div class="fa-solid fa-circle-info opacity50p" data-i18n="[title]Save connection profiles to quickly switch between different APIs, models and formatting templates." title="Save connection profiles to quickly switch between different APIs, models and formatting templates."></div>
+        <i id="connection_profile_spinner" class="fa-solid fa-spinner fa-spin hidden"></i>
+    </div>
+    <div class="flex-container">
+        <select class="text_pole flex1" id="connection_profiles"></select>
+        <i id="view_connection_profile" class="menu_button fa-solid fa-info-circle" title="View connection profile details" data-i18n="[title]View connection profile details"></i>
+        <i id="create_connection_profile" class="menu_button fa-solid fa-file-circle-plus" title="Create a new connection profile" data-i18n="[title]Create a new connection profile"></i>
+        <i id="update_connection_profile" class="menu_button fa-solid fa-save" title="Update a connection profile" data-i18n="[title]Update a connection profile"></i>
+        <i id="reload_connection_profile" class="menu_button fa-solid fa-recycle" title="Reload a connection profile" data-i18n="[title]Reload a connection profile"></i>
+        <i id="delete_connection_profile" class="menu_button fa-solid fa-trash-can" title="Delete a connection profile" data-i18n="[title]Delete a connection profile"></i>
+    </div>
+    <div id="connection_profile_details_content" class="hidden"></div>
+</div>

public/scripts/extensions/connection-manager/style.css+11 -0 Viewed

+#connection_profile_details_content {
+    margin: 5px 0;
+}
+#connection_profile_details_content ul {
+    margin: 0;
+}
+#connection_profile_spinner {
+    margin-left: 5px;
+}

public/scripts/extensions/connection-manager/view.html+5 -0 Viewed

+<ul>
+    {{#each profile}}
+    <li><strong data-i18n="{{@key}}">{{@key}}:</strong>&nbsp;{{this}}</li>
+    {{/each}}
+</ul>

public/scripts/instruct-mode.js+14 -10 Viewed

 /**
  * Select context template if not already selected.
  * @param {string} preset Preset name.
- * @param {boolean} quiet Suppress info message.
+ * @param {object} [options={}] Optional arguments.
+ * @param {boolean} [options.quiet=false] Suppress toast messages.
+ * @param {boolean} [options.isAuto=false] Is auto-select.
  */
-export function selectContextPreset(preset, quiet) {
+export function selectContextPreset(preset, { quiet = false, isAuto = false } = {}) {
     // If context template is not already selected, select it
     if (preset !== power_user.context.preset) {
         $('#context_presets').val(preset).trigger('change');
-        !quiet && toastr.info(`Context Template: preset "${preset}" auto-selected`);
+        !quiet && toastr.info(`Context Template: "${preset}" ${isAuto ? 'auto-' : ''}selected`);
+    }
     // If instruct mode is disabled, enable it, except for default context template

 /**
  * Select instruct preset if not already selected.
  * @param {string} preset Preset name.
- * @param {boolean} quiet Suppress info message.
+ * @param {object} [options={}] Optional arguments.
+ * @param {boolean} [options.quiet=false] Suppress toast messages.
+ * @param {boolean} [options.isAuto=false] Is auto-select.
  */
-export function selectInstructPreset(preset, quiet) {
+export function selectInstructPreset(preset, { quiet = false, isAuto = false } = {}) {
     // If instruct preset is not already selected, select it
     if (preset !== power_user.instruct.preset) {
         $('#instruct_presets').val(preset).trigger('change');
-        !quiet && toastr.info(`Instruct Mode: template "${preset}" auto-selected`);
+        !quiet && toastr.info(`Instruct Template: "${preset}" ${isAuto ? 'auto-' : ''}selected`);
+    }
     // If instruct mode is disabled, enable it

@@ -189,7 +193,7 @@ export function autoSelectInstructPreset(modelId) {
189	// If instruct preset matches the context template	193	// If instruct preset matches the context template
190	if (power_user.instruct.bind_to_context && instruct_preset.name === power_user.context.preset) {	194	if (power_user.instruct.bind_to_context && instruct_preset.name === power_user.context.preset) {
191	foundMatch = true;	195	foundMatch = true;
192	selectInstructPreset(instruct_preset.name);	196	selectInstructPreset(instruct_preset.name, { isAuto: true });
193	break;	197	break;
194	}	198	}
195	}	199	}

                     // Stop on first match so it won't cycle back and forth between presets if multiple regexes match
                     if (regex instanceof RegExp && regex.test(modelId)) {
-                        selectInstructPreset(preset.name);
+                        selectInstructPreset(preset.name, { isAuto: true });
                         return true;
+                    }

@@ -541,13 +545,13 @@ function selectMatchingContextTemplate(name) {
541	// If context template matches the instruct preset	545	// If context template matches the instruct preset
542	if (context_preset.name === name) {	546	if (context_preset.name === name) {
543	foundMatch = true;	547	foundMatch = true;
544	selectContextPreset(context_preset.name);	548	selectContextPreset(context_preset.name, { isAuto: true });
545	break;	549	break;
546	}	550	}
547	}	551	}
548	if (!foundMatch) {	552	if (!foundMatch) {
549	// If no match was found, select default context preset	553	// If no match was found, select default context preset
550	selectContextPreset(power_user.default_context);	554	selectContextPreset(power_user.default_context, { isAuto: true });
551	}	555	}
552	}	556	}
553		557

public/scripts/power-user.js+1 -1 Viewed

@@ -1798,7 +1798,7 @@ async function loadContextSettings() {
1798	for (const instruct_preset of instruct_presets) {	1798	for (const instruct_preset of instruct_presets) {
1799	// If instruct preset matches the context template	1799	// If instruct preset matches the context template
1800	if (instruct_preset.name === name) {	1800	if (instruct_preset.name === name) {
1801	selectInstructPreset(instruct_preset.name);	1801	selectInstructPreset(instruct_preset.name, { isAuto: true });
1802	break;	1802	break;
1803	}	1803	}
1804	}	1804	}

public/scripts/slash-commands/SlashCommandCommonEnumsProvider.js+1 -0 Viewed

     file: '📄',
     message: '💬',
     voice: '🎤',
+    server: '🖥️',
     true: '✔️',
     false: '❌',

public/scripts/util/AbortReason.js+9 -0 Viewed

+export class AbortReason {
+    constructor(reason) {
+        this.reason = reason;
+    }
+    toString() {
+        return this.reason;
+    }
+}

public/scripts/utils.js+9 -0 Viewed

     });
+}
+/**
+ * Collapses multiple spaces in a strings into one.
+ * @param {string} s String to process
+ * @returns {string} String with collapsed spaces
+ */
+export function collapseSpaces(s) {
+    return s.replace(/\s+/g, ' ').trim();
+}
 function postProcessText(text, collapse = true) {
     // Remove carriage returns
     text = text.replace(/\r/g, '');