bf435777 · permissionBRICK/SillyTavern

.eslintrc.cjs+1 -0 Viewed

             },
             // These scripts are loaded in HTML; tell ESLint not to complain about them being undefined
             globals: {
+                globalThis: 'readonly',
                 ePub: 'readonly',
                 pdfjsLib: 'readonly',
                 toastr: 'readonly',

default/config.yaml+2 -0 Viewed

 # -- DATA CONFIGURATION --
 # Root directory for user data storage
 dataRoot: ./data
+# The maximum amount of memory that parsed character cards can use in MB
+cardsCacheCapacity: 100
 # -- SERVER CONFIGURATION --
 # Listen for incoming connections
 listen: false

package-lock.json+2 -2 Viewed

+{
     "name": "sillytavern",
-    "version": "1.12.8",
+    "version": "1.12.9",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "sillytavern",
-            "version": "1.12.8",
+            "version": "1.12.9",
             "hasInstallScript": true,
             "license": "AGPL-3.0",
             "dependencies": {

package.json+1 -1 Viewed

         "type": "git",
         "url": "https://github.com/SillyTavern/SillyTavern.git"
     },
-    "version": "1.12.8",
+    "version": "1.12.9",
     "scripts": {
         "start": "node server.js",
         "start:deno": "deno run --allow-run --allow-net --allow-read --allow-write --allow-sys --allow-env server.js",

public/global.d.ts+2 -1 Viewed

 import libs from './lib';
+import getContext from './scripts/st-context';
 // Global namespace modules
 declare var ai;

 declare var ePub;
 declare var SillyTavern: {
-    getContext(): any;
+    getContext(): typeof getContext;
     llm: any;
     libs: typeof libs;
 };

public/index.html+8 -7 Viewed

                                         </span>
                                     </div>
                                 </div>
-                                <div class="range-block" data-source="openai,claude,windowai,openrouter,ai21,scale,makersuite,mistralai,custom,cohere,perplexity,groq,01ai">
+                                <div class="range-block" data-source="openai,claude,windowai,openrouter,ai21,scale,makersuite,mistralai,custom,cohere,perplexity,groq,01ai,nanogpt">
                                     <div class="range-block-title" data-i18n="Temperature">
                                         Temperature
                                     </div>

                                         </div>
                                     </div>
                                 </div>
-                                <div class="range-block" data-source="openai,openrouter,custom,cohere,perplexity,groq,mistralai">
+                                <div class="range-block" data-source="openai,openrouter,custom,cohere,perplexity,groq,mistralai,nanogpt">
                                     <div class="range-block-title" data-i18n="Frequency Penalty">
                                         Frequency Penalty
                                     </div>

                                         </div>
                                     </div>
                                 </div>
-                                <div class="range-block" data-source="openai,openrouter,custom,cohere,perplexity,groq,mistralai">
+                                <div class="range-block" data-source="openai,openrouter,custom,cohere,perplexity,groq,mistralai,nanogpt">
                                     <div class="range-block-title" data-i18n="Presence Penalty">
                                         Presence Penalty
                                     </div>

                                         </div>
                                     </div>
                                 </div>
-                                <div class="range-block" data-source="openai,claude,openrouter,ai21,scale,makersuite,mistralai,custom,cohere,perplexity,groq,01ai">
+                                <div class="range-block" data-source="openai,claude,openrouter,ai21,scale,makersuite,mistralai,custom,cohere,perplexity,groq,01ai,nanogpt">
                                     <div class="range-block-title" data-i18n="Top P">
                                         Top P
                                     </div>

                                         </div>
                                     </div>
                                 </div>
-                                <div class="range-block" data-source="openai,openrouter,mistralai,custom,cohere,groq">
+                                <div class="range-block" data-source="openai,openrouter,mistralai,custom,cohere,groq,nanogpt">
                                     <div class="range-block-title justifyLeft" data-i18n="Seed">
                                         Seed
                                     </div>

                                                 <input class="neo-range-slider" type="range" id="dry_allowed_length_textgenerationwebui" min="1" max="20" step="1" />
                                                 <input class="neo-range-input" type="number" min="1" max="20" step="1" data-for="dry_allowed_length_textgenerationwebui" id="dry_allowed_length_counter_textgenerationwebui">
                                             </div>
-                                            <div class="alignItemsCenter flex-container flexFlowColumn flexBasis48p flexGrow flexShrink gap0" data-tg-type="llamacpp, koboldcpp, tabby">
+                                            <div class="alignItemsCenter flex-container flexFlowColumn flexBasis48p flexGrow flexShrink gap0" data-tg-type="llamacpp, koboldcpp, tabby, aphrodite">
                                                 <small data-i18n="Penalty Range">Penalty Range</small>
                                                 <input class="neo-range-slider" type="range" id="dry_penalty_last_n_textgenerationwebui" min="0" max="8192" step="1" />
                                                 <input class="neo-range-input" type="number" min="0" max="8192" step="1" data-for="dry_penalty_last_n_textgenerationwebui" id="dry_penalty_last_n_counter_textgenerationwebui">

                                     <optgroup label="Subversions">
                                         <option value="gemini-exp-1121">Gemini Experimental 2024-11-21</option>
                                         <option value="gemini-exp-1114">Gemini Experimental 2024-11-14</option>
+                                        <option value="gemini-exp-1206">Gemini Experimental 2024-12-06</option>
                                         <option value="gemini-1.5-pro-exp-0801">Gemini 1.5 Pro Experiment 2024-08-01</option>
                                         <option value="gemini-1.5-pro-exp-0827">Gemini 1.5 Pro Experiment 2024-08-27</option>
                                         <option value="gemini-1.5-pro-latest">Gemini 1.5 Pro [latest]</option>

                                 </label>
                                 <label for="show_swipe_num_all_messages" class="checkbox_label" title="Display swipe numbers for all messages, not just the last." data-i18n="[title]Display swipe numbers for all messages, not just the last.">
                                     <input id="show_swipe_num_all_messages" type="checkbox" />
-                                    <small data-i18n="Swipe # for All Messages">Swipe # for All Messages</small><i class="fa-solid fa-mobile-screen-button"></i>
+                                    <small data-i18n="Swipe # for All Messages">Swipe # for All Messages</small>
                                 </label>
                                 <label for="hotswapEnabled" class="checkbox_label" title="In the Character Management panel, show quick selection buttons for favorited characters." data-i18n="[title]In the Character Management panel, show quick selection buttons for favorited characters">
                                     <input id="hotswapEnabled" type="checkbox" />

public/jsconfig.json+2 -1 Viewed

         "module": "ESNext",
         "moduleResolution": "node",
         "allowUmdGlobalAccess": true,
-        "allowSyntheticDefaultImports": true
+        "allowSyntheticDefaultImports": true,
+        "strictBindCallApply": true
     },
     "exclude": [
         "**/node_modules/**",

public/script.js+76 -163 Viewed

     default as libs,
 } from './lib.js';
-import { humanizedDateTime, favsToHotswap, getMessageTimeStamp, dragElement, isMobile, initRossMods, shouldSendOnEnter } from './scripts/RossAscends-mods.js';
+import { humanizedDateTime, favsToHotswap, getMessageTimeStamp, dragElement, isMobile, initRossMods } from './scripts/RossAscends-mods.js';
 import { userStatsHandler, statMesProcess, initStats } from './scripts/stats.js';
 import {
     generateKoboldWithStreaming,

     parseTabbyLogprobs,
 } from './scripts/textgen-settings.js';
-const { MANCER, TOGETHERAI, OOBA, VLLM, APHRODITE, TABBY, OLLAMA, INFERMATICAI, DREAMGEN, OPENROUTER, FEATHERLESS } = textgen_types;
 import {
     world_info,
     getWorldInfoPrompt,

     getGroupChat,
     renameGroupMember,
     createNewGroupChat,
-    getGroupPastChats,
     getGroupAvatar,
-    openGroupChat,
     editGroup,
     deleteGroupChat,
     renameGroupChat,

     resetMovableStyles,
     forceCharacterEditorTokenize,
     applyPowerUserSettings,
-    switchSwipeNumAllMessages,
 } from './scripts/power-user.js';
 import {

 } from './scripts/utils.js';
 import { debounce_timeout } from './scripts/constants.js';
-import { ModuleWorkerWrapper, doDailyExtensionUpdatesCheck, extension_settings, getContext, initExtensions, loadExtensionSettings, renderExtensionTemplate, renderExtensionTemplateAsync, runGenerationInterceptors, saveMetadataDebounced, writeExtensionField } from './scripts/extensions.js';
+import { doDailyExtensionUpdatesCheck, extension_settings, initExtensions, loadExtensionSettings, runGenerationInterceptors, saveMetadataDebounced } from './scripts/extensions.js';
-import { COMMENT_NAME_DEFAULT, executeSlashCommands, executeSlashCommandsOnChatInput, executeSlashCommandsWithOptions, getSlashCommandsHelp, initDefaultSlashCommands, isExecutingCommandsFromChatInput, pauseScriptExecution, processChatSlashCommands, registerSlashCommand, stopScriptExecution } from './scripts/slash-commands.js';
+import { COMMENT_NAME_DEFAULT, executeSlashCommandsOnChatInput, getSlashCommandsHelp, initDefaultSlashCommands, isExecutingCommandsFromChatInput, pauseScriptExecution, processChatSlashCommands, stopScriptExecution } from './scripts/slash-commands.js';
 import {
     tag_map,
     tags,

     instruct_presets,
     selectContextPreset,
 } from './scripts/instruct-mode.js';
-import { initLocales, t, translate } from './scripts/i18n.js';
+import { initLocales, t } from './scripts/i18n.js';
-import { getFriendlyTokenizerName, getTokenCount, getTokenCountAsync, getTokenizerModel, initTokenizers, saveTokenCache, TOKENIZER_SUPPORTED_KEY } from './scripts/tokenizers.js';
+import { getFriendlyTokenizerName, getTokenCount, getTokenCountAsync, initTokenizers, saveTokenCache, TOKENIZER_SUPPORTED_KEY } from './scripts/tokenizers.js';
 import {
     user_avatar,
     getUserAvatars,

 import { BulkEditOverlay, CharacterContextMenu } from './scripts/BulkEditOverlay.js';
 import { loadFeatherlessModels, loadMancerModels, loadOllamaModels, loadTogetherAIModels, loadInfermaticAIModels, loadOpenRouterModels, loadVllmModels, loadAphroditeModels, loadDreamGenModels, initTextGenModels, loadTabbyModels } from './scripts/textgen-models.js';
 import { appendFileContent, hasPendingFileAttachment, populateFileAttachment, decodeStyleTags, encodeStyleTags, isExternalMediaAllowed, getCurrentEntityId, preserveNeutralChat, restoreNeutralChat } from './scripts/chats.js';
-import { initPresetManager } from './scripts/preset-manager.js';
+import { getPresetManager, initPresetManager } from './scripts/preset-manager.js';
-import { MacrosParser, evaluateMacros, getLastMessageId } from './scripts/macros.js';
+import { evaluateMacros, getLastMessageId, initMacros } from './scripts/macros.js';
 import { currentUser, setUserControls } from './scripts/user.js';
 import { POPUP_RESULT, POPUP_TYPE, Popup, callGenericPopup, fixToastrForDialogs } from './scripts/popup.js';
 import { renderTemplate, renderTemplateAsync } from './scripts/templates.js';
-import { initScrapers, ScraperManager } from './scripts/scrapers.js';
+import { initScrapers } from './scripts/scrapers.js';
 import { SlashCommandParser } from './scripts/slash-commands/SlashCommandParser.js';
 import { SlashCommand } from './scripts/slash-commands/SlashCommand.js';
 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './scripts/slash-commands/SlashCommandArgument.js';

 import { initSettingsSearch } from './scripts/setting-search.js';
 import { initBulkEdit } from './scripts/bulk-edit.js';
 import { deriveTemplatesFromChatTemplate } from './scripts/chat-templates.js';
+import { getContext } from './scripts/st-context.js';
+// API OBJECT FOR EXTERNAL WIRING
+globalThis.SillyTavern = {
+    libs,
+    getContext,
+};
 //exporting functions and vars for mods
 export {

+    }
 });
-// API OBJECT FOR EXTERNAL WIRING
-window['SillyTavern'] = {};
-window['SillyTavern'].libs = libs;
 // Event source init
 export const event_types = {
     APP_READY: 'app_ready',

 let generatedPromptCache = '';
 let generation_started = new Date();
-/** @type {import('scripts/char-data.js').v1CharData[]} */
+/** @type {import('./scripts/char-data.js').v1CharData[]} */
 export let characters = [];
 export let this_chid;
 let saveCharactersPage = 0;

 export let selected_button = ''; //which button pressed
 //create pole save
-let create_save = {
+export let create_save = {
     name: '',
     description: '',
     creator_notes: '',

 export let max_context = 2048;
 var swipes = true;
-let extension_prompts = {};
+export let extension_prompts = {};
 export let main_api;// = "kobold";
 //novel settings

     initDynamicStyles();
     initTags();
     initBookmarks();
+    initMacros();
     await getUserAvatars(true, user_avatar);
     await getCharacters();
     await getBackgrounds();

@@ -1174,7 +1173,7 @@ async function getStatusTextgen() {
1174	return resultCheckStatus();	1173	return resultCheckStatus();
1175	}	1174	}
1176		1175
1177	if (textgen_settings.type == OOBA && textgen_settings.bypass_status_check) {	1176	if (textgen_settings.type == textgen_types.OOBA && textgen_settings.bypass_status_check) {
1178	setOnlineStatus('Status check bypassed');	1177	setOnlineStatus('Status check bypassed');
1179	return resultCheckStatus();	1178	return resultCheckStatus();
1180	}	1179	}

         const data = await response.json();
-        if (textgen_settings.type === MANCER) {
+        if (textgen_settings.type === textgen_types.MANCER) {
             loadMancerModels(data?.data);
             setOnlineStatus(textgen_settings.mancer_model);
-        } else if (textgen_settings.type === TOGETHERAI) {
+        } else if (textgen_settings.type === textgen_types.TOGETHERAI) {
             loadTogetherAIModels(data?.data);
             setOnlineStatus(textgen_settings.togetherai_model);
-        } else if (textgen_settings.type === OLLAMA) {
+        } else if (textgen_settings.type === textgen_types.OLLAMA) {
             loadOllamaModels(data?.data);
             setOnlineStatus(textgen_settings.ollama_model || 'Connected');
-        } else if (textgen_settings.type === INFERMATICAI) {
+        } else if (textgen_settings.type === textgen_types.INFERMATICAI) {
             loadInfermaticAIModels(data?.data);
             setOnlineStatus(textgen_settings.infermaticai_model);
-        } else if (textgen_settings.type === DREAMGEN) {
+        } else if (textgen_settings.type === textgen_types.DREAMGEN) {
             loadDreamGenModels(data?.data);
             setOnlineStatus(textgen_settings.dreamgen_model);
-        } else if (textgen_settings.type === OPENROUTER) {
+        } else if (textgen_settings.type === textgen_types.OPENROUTER) {
             loadOpenRouterModels(data?.data);
             setOnlineStatus(textgen_settings.openrouter_model);
-        } else if (textgen_settings.type === VLLM) {
+        } else if (textgen_settings.type === textgen_types.VLLM) {
             loadVllmModels(data?.data);
             setOnlineStatus(textgen_settings.vllm_model);
-        } else if (textgen_settings.type === APHRODITE) {
+        } else if (textgen_settings.type === textgen_types.APHRODITE) {
             loadAphroditeModels(data?.data);
             setOnlineStatus(textgen_settings.aphrodite_model);
-        } else if (textgen_settings.type === FEATHERLESS) {
+        } else if (textgen_settings.type === textgen_types.FEATHERLESS) {
             loadFeatherlessModels(data?.data);
             setOnlineStatus(textgen_settings.featherless_model);
-        } else if (textgen_settings.type === TABBY) {
+        } else if (textgen_settings.type === textgen_types.TABBY) {
             loadTabbyModels(data?.data);
             setOnlineStatus(textgen_settings.tabby_model || data?.result);
         } else {

@@ -1636,7 +1635,7 @@ export function getEntitiesList({ doFilter = false, doSort = true } = {}) {
1636	subEntities = entitiesFilter.applyFilters(subEntities, { clearScoreCache: false, tempOverrides: { [FILTER_TYPES.FOLDER]: FILTER_STATES.UNDEFINED }, clearFuzzySearchCaches: false });	1635	subEntities = entitiesFilter.applyFilters(subEntities, { clearScoreCache: false, tempOverrides: { [FILTER_TYPES.FOLDER]: FILTER_STATES.UNDEFINED }, clearFuzzySearchCaches: false });
1637	}	1636	}
1638	if (doSort) {	1637	if (doSort) {
1639	sortEntitiesList(subEntities);	1638	sortEntitiesList(subEntities, false);
1640	}	1639	}
1641	entity.entities = subEntities;	1640	entity.entities = subEntities;
1642	entity.hidden = subCount - subEntities.length;	1641	entity.hidden = subCount - subEntities.length;

     // Sort before returning if requested
     if (doSort) {
-        sortEntitiesList(entities);
+        sortEntitiesList(entities, false);
+    }
     entitiesFilter.clearFuzzySearchCaches();
     return entities;

         };
+    }
-    const getGroupValue = () => {
+    const getGroupValue = (includeMuted) => {
         if (typeof _group === 'string') {
             return _group;
+        }
         if (selected_group) {
             const members = groups.find(x => x.id === selected_group)?.members;
+            /** @type {string[]} */
+            const disabledMembers = groups.find(x => x.id === selected_group)?.disabled_members ?? [];
+            const isMuted = x => includeMuted ? true : !disabledMembers.includes(x);
             const names = Array.isArray(members)
-                ? members.map(m => characters.find(c => c.avatar === m)?.name).filter(Boolean).join(', ')
+                ? members.filter(isMuted).map(m => characters.find(c => c.avatar === m)?.name).filter(Boolean).join(', ')
                 : '';
             return names;
         } else {

     // Must be substituted last so that they're replaced inside {{description}}
     environment.user = _name1 ?? name1;
     environment.char = _name2 ?? name2;
-    environment.group = environment.charIfNotGroup = getGroupValue();
+    environment.group = environment.charIfNotGroup = getGroupValue(true);
+    environment.groupNotMuted = getGroupValue(false);
     environment.model = getGeneratingModel();
     if (additionalMacro && typeof additionalMacro === 'object') {

             instruction: main_api !== 'openai' && power_user.sysprompt.enabled ? substituteParams(power_user.prefer_character_prompt && system ? system : power_user.sysprompt.content) : '',
             userPersona: (power_user.persona_description_position == persona_description_positions.IN_PROMPT ? (persona || '') : ''),
             tokenizer: getFriendlyTokenizerName(main_api).tokenizerName || '',
+            presetName: getPresetManager()?.getSelectedPresetName() || '',
         };
         //console.log(additionalPromptStuff);

         dataBankVectorsStringTokens: await getTokenCountAsync(itemizedPrompts[thisPromptSet].dataBankVectorsString),
         modelUsed: chat[incomingMesId]?.extra?.model,
         apiUsed: chat[incomingMesId]?.extra?.api,
+        presetName: itemizedPrompts[thisPromptSet].presetName || t`(Unknown)`,
     };
     const getFriendlyName = (value) => $(`#rm_api_block select option[value="${value}"]`).first().text() || value;

@@ -5535,7 +5540,7 @@ function extractMultiSwipes(data, type) {
5535	return swipes;	5540	return swipes;
5536	}	5541	}
5537		5542
5538	if (main_api === 'openai' \|\| (main_api === 'textgenerationwebui' && [MANCER, VLLM, APHRODITE, TABBY, INFERMATICAI].includes(textgen_settings.type))) {	5543	if (main_api === 'openai' \|\| (main_api === 'textgenerationwebui' && [textgen_types.MANCER, textgen_types.VLLM, textgen_types.APHRODITE, textgen_types.TABBY, textgen_types.INFERMATICAI].includes(textgen_settings.type))) {
5539	if (!Array.isArray(data.choices)) {	5544	if (!Array.isArray(data.choices)) {
5540	return swipes;	5545	return swipes;
5541	}	5546	}

     return getMessage;
+}
-async function saveReply(type, getMessage, fromStreaming, title, swipes) {
+export async function saveReply(type, getMessage, fromStreaming, title, swipes) {
     if (type != 'append' && type != 'continue' && type != 'appendFinal' && chat.length && (chat[chat.length - 1]['swipe_id'] === undefined ||
         chat[chat.length - 1]['is_user'])) {
         type = 'normal';

     //allows for writing individual swipe counters for past messages
     const lastSwipeCounter = $('.last_mes .swipes-counter');
     lastSwipeCounter.text(swipeCounterText).show();
-    switchSwipeNumAllMessages();
+}
 export function hideSwipeButtons() {
-    $('#chat').find('.swipe_right').hide();
+    chatElement.find('.swipe_right').hide();
-    $('#chat').find('.last_mes .swipes-counter').hide();
+    chatElement.find('.last_mes .swipes-counter').hide();
-    $('#chat').find('.swipe_left').hide();
+    chatElement.find('.swipe_left').hide();
+}
 /**

+    }
+}
-async function importCharacterChat(formData) {
+/**
-    await jQuery.ajax({
+ * Saves the chat to the server.
-        type: 'POST',
+ * @param {FormData} formData Form data to send to the server.
-        url: '/api/chats/import',
+ * @param {EventTarget} eventTarget Event target to trigger the event on.
-        data: formData,
+ */
-        beforeSend: function () {
+async function importCharacterChat(formData, eventTarget) {
-        },
+    const headers = getRequestHeaders();
-        cache: false,
+    delete headers['Content-Type'];
-        contentType: false,
+    const fetchResult = await fetch('/api/chats/import', {
-        processData: false,
+        method: 'POST',
-        success: async function (data) {
+        body: formData,
-            if (data.res) {
+        headers: headers,
-                await displayPastChats();
+        cache: 'no-cache',
-            }
-        },
-        error: function () {
-            $('#create_button').removeAttr('disabled');
-        },
     });
+    if (fetchResult.ok) {
+        const data = await fetchResult.json();
+        if (data.res) {
+            await displayPastChats();
+        }
+    }
+    if (eventTarget instanceof HTMLInputElement) {
+        eventTarget.value = '';
+    }
+}
 function updateViewMessageIds(startFromZero = false) {

+    }
+}
-window['SillyTavern'].getContext = function () {
-    return {
-        chat: chat,
-        characters: characters,
-        groups: groups,
-        name1: name1,
-        name2: name2,
-        characterId: this_chid,
-        groupId: selected_group,
-        chatId: selected_group
-            ? groups.find(x => x.id == selected_group)?.chat_id
-            : (this_chid && characters[this_chid] && characters[this_chid].chat),
-        getCurrentChatId: getCurrentChatId,
-        getRequestHeaders: getRequestHeaders,
-        reloadCurrentChat: reloadCurrentChat,
-        renameChat: renameChat,
-        saveSettingsDebounced: saveSettingsDebounced,
-        onlineStatus: online_status,
-        maxContext: Number(max_context),
-        chatMetadata: chat_metadata,
-        streamingProcessor,
-        eventSource: eventSource,
-        eventTypes: event_types,
-        addOneMessage: addOneMessage,
-        generate: Generate,
-        sendStreamingRequest: sendStreamingRequest,
-        sendGenerationRequest: sendGenerationRequest,
-        stopGeneration: stopGeneration,
-        getTokenCount: getTokenCount,
-        extensionPrompts: extension_prompts,
-        setExtensionPrompt: setExtensionPrompt,
-        updateChatMetadata: updateChatMetadata,
-        saveChat: saveChatConditional,
-        openCharacterChat: openCharacterChat,
-        openGroupChat: openGroupChat,
-        saveMetadata: saveMetadata,
-        sendSystemMessage: sendSystemMessage,
-        activateSendButtons,
-        deactivateSendButtons,
-        saveReply,
-        substituteParams,
-        substituteParamsExtended,
-        SlashCommandParser,
-        SlashCommand,
-        SlashCommandArgument,
-        SlashCommandNamedArgument,
-        ARGUMENT_TYPE,
-        executeSlashCommandsWithOptions,
-        /** @deprecated Use SlashCommandParser.addCommandObject() instead */
-        registerSlashCommand: registerSlashCommand,
-        /** @deprecated Use executeSlashCommandWithOptions instead */
-        executeSlashCommands: executeSlashCommands,
-        timestampToMoment: timestampToMoment,
-        /** @deprecated Handlebars for extensions are no longer supported. */
-        registerHelper: () => { },
-        registerMacro: MacrosParser.registerMacro.bind(MacrosParser),
-        unregisterMacro: MacrosParser.unregisterMacro.bind(MacrosParser),
-        registerFunctionTool: ToolManager.registerFunctionTool.bind(ToolManager),
-        unregisterFunctionTool: ToolManager.unregisterFunctionTool.bind(ToolManager),
-        isToolCallingSupported: ToolManager.isToolCallingSupported.bind(ToolManager),
-        canPerformToolCalls: ToolManager.canPerformToolCalls.bind(ToolManager),
-        registerDebugFunction: registerDebugFunction,
-        /** @deprecated Use renderExtensionTemplateAsync instead. */
-        renderExtensionTemplate: renderExtensionTemplate,
-        renderExtensionTemplateAsync: renderExtensionTemplateAsync,
-        registerDataBankScraper: ScraperManager.registerDataBankScraper,
-        /** @deprecated Use callGenericPopup or Popup instead. */
-        callPopup: callPopup,
-        callGenericPopup: callGenericPopup,
-        showLoader: showLoader,
-        hideLoader: hideLoader,
-        mainApi: main_api,
-        extensionSettings: extension_settings,
-        ModuleWorkerWrapper: ModuleWorkerWrapper,
-        getTokenizerModel: getTokenizerModel,
-        generateQuietPrompt: generateQuietPrompt,
-        writeExtensionField: writeExtensionField,
-        getThumbnailUrl: getThumbnailUrl,
-        selectCharacterById: selectCharacterById,
-        messageFormatting: messageFormatting,
-        shouldSendOnEnter: shouldSendOnEnter,
-        isMobile: isMobile,
-        t: t,
-        translate: translate,
-        tags: tags,
-        tagMap: tag_map,
-        menuType: menu_type,
-        createCharacterData: create_save,
-        /** @deprecated Legacy snake-case naming, compatibility with old extensions */
-        event_types: event_types,
-        Popup: Popup,
-        POPUP_TYPE: POPUP_TYPE,
-        POPUP_RESULT: POPUP_RESULT,
-    };
-};
 /**
  * Formats a counter for a swipe view.
  * @param {number} current The current number of items.

     });
     $('#chat_import_file').on('change', async function (e) {
-        var file = e.target.files[0];
+        const file = e.target.files[0];
         if (!file) {
             return;
+        }
-        var ext = file.name.match(/\.(\w+)$/);
+        const ext = file.name.match(/\.(\w+)$/);
         if (
             !ext ||
             (ext[1].toLowerCase() != 'json' && ext[1].toLowerCase() != 'jsonl')

             return;
+        }
-        var format = ext[1].toLowerCase();
+        const format = ext[1].toLowerCase();
         $('#chat_import_file_type').val(format);
-        var formData = new FormData($('#form_import_chat').get(0));
+        const formData = new FormData($('#form_import_chat').get(0));
         formData.append('user_name', name1);
         $('#select_chat_div').html('');
         if (selected_group) {
-            await importGroupChat(formData);
+            await importGroupChat(formData, e.originalEvent.target);
         } else {
-            await importCharacterChat(formData);
+            await importCharacterChat(formData, e.originalEvent.target);
+        }
     });

public/scripts/char-data.js+1 -0 Viewed

  * @property {string} [source_url] - The source URL associated with the character.
  * @property {{full_path: string}} [chub] - The Chub-specific data associated with the character.
  * @property {{source: string[]}} [risuai] - The RisuAI-specific data associated with the character.
+ * @property {{positive: string, negative: string}} [sd_character_prompt] - SD-specific data associated with the character.
  */
 /**

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

 import { POPUP_RESULT, POPUP_TYPE, Popup, callGenericPopup } from './popup.js';
 import { renderTemplate, renderTemplateAsync } from './templates.js';
 import { isSubsetOf, setValueByPath } from './utils.js';
+import { getContext } from './st-context.js';
 export {
     getContext,
     getApiUrl,

 let modules = [];
 let activeExtensions = new Set();
-const getContext = () => window['SillyTavern'].getContext();
 const getApiUrl = () => extension_settings.apiUrl;
 let connectedToApi = false;

public/scripts/extensions/caption/settings.html+1 -0 Viewed

                         <option data-type="google" value="gemini-1.5-flash-8b-exp-0924">gemini-1.5-flash-8b-exp-0924</option>
                         <option data-type="google" value="gemini-exp-1114">gemini-exp-1114</option>
                         <option data-type="google" value="gemini-exp-1121">gemini-exp-1121</option>
+                        <option data-type="google" value="gemini-exp-1206">gemini-exp-1206</option>
                         <option data-type="google" value="gemini-1.5-pro">gemini-1.5-pro</option>
                         <option data-type="google" value="gemini-1.5-pro-latest">gemini-1.5-pro-latest</option>
                         <option data-type="google" value="gemini-1.5-pro-001">gemini-1.5-pro-001</option>

public/scripts/extensions/stable-diffusion/index.js+0 -15 Viewed

 export { MODULE_NAME };
 const MODULE_NAME = 'sd';
-const UPDATE_INTERVAL = 1000;
 // This is a 1x1 transparent PNG
 const PNG_PIXEL = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';
 const CUSTOM_STOP_EVENT = 'sd_stop_generation';

     const button = $('#sd_gen');
     const dropdown = $('#sd_dropdown');
     dropdown.hide();
-    button.hide();
-    messageButton.hide();
     let popper = Popper.createPopper(button.get(0), dropdown.get(0), {
         placement: 'top',

+    }
+}
-async function moduleWorker() {
-    if (isValidState()) {
-        $('#sd_gen').show();
-        $('.sd_message_gen').show();
-    }
-    else {
-        $('#sd_gen').hide();
-        $('.sd_message_gen').hide();
-    }
-}
-setInterval(moduleWorker, UPDATE_INTERVAL);
 let buttonAbortController = null;
 async function sdMessageButton(e) {

public/scripts/extensions/stable-diffusion/style.css+1 -1 Viewed

 #sd_dropdown {
     z-index: 30000;
-    backdrop-filter: blur(--SmartThemeBlurStrength);
+    backdrop-filter: blur(var(--SmartThemeBlurStrength));
+}
 #sd_comfy_open_workflow_editor {

public/scripts/extensions/tts/style.css+1 -1 Viewed

 .at-settings-separator {
     margin-top: 10px;
     margin-bottom: 10px;
-    padding: 18x;
+    padding: 18px;
     font-weight: bold;
     border-top: 1px solid #e1e1e1; /* Grey line */
     border-bottom: 1px solid #e1e1e1; /* Grey line */

public/scripts/group-chats.js+39 -31 Viewed

     const thisGroup = openGroupId && groups.find((x) => x.id == openGroupId);
     let candidates = characters
         .filter((x) => isGroupMember(thisGroup, x.avatar) == onlyMembers)
-        .map((x, index) => ({ item: x, id: index, type: 'character' }));
+        .map((x) => ({ item: x, id: characters.indexOf(x), type: 'character' }));
+    if (doFilter) {
+        candidates = groupCandidatesFilter.applyFilters(candidates);
+    }
     if (onlyMembers) {
         candidates.sort(sortMembersFn);
     } else {
-        sortEntitiesList(candidates);
+        const useFilterOrder = doFilter && !!$('#rm_group_filter').val();
-    }
+        sortEntitiesList(candidates, useFilterOrder, groupCandidatesFilter);
-    if (doFilter) {
-        candidates = groupCandidatesFilter.applyFilters(candidates);
+    }
+    groupCandidatesFilter.clearFuzzySearchCaches();
     return candidates;
+}

+    }
+}
-export async function importGroupChat(formData) {
+/**
-    await jQuery.ajax({
+ * Imports a group chat from a file and adds it to the group.
-        type: 'POST',
+ * @param {FormData} formData Form data to send to the server
-        url: '/api/chats/group/import',
+ * @param {EventTarget} eventTarget Element that triggered the import
-        data: formData,
+ */
-        beforeSend: function () {
+export async function importGroupChat(formData, eventTarget) {
-        },
+    const headers = getRequestHeaders();
-        cache: false,
+    delete headers['Content-Type'];
-        contentType: false,
+    const fetchResult = await fetch('/api/chats/group/import', {
-        processData: false,
+        method: 'POST',
-        success: async function (data) {
+        headers: headers,
-            if (data.res) {
+        body: formData,
-                const chatId = data.res;
+        cache: 'no-cache',
-                const group = groups.find(x => x.id == selected_group);
-                if (group) {
-                    group.chats.push(chatId);
-                    await editGroup(selected_group, true, true);
-                    await displayPastChats();
-                }
-            }
-        },
-        error: function () {
-            $('#create_button').removeAttr('disabled');
-        },
     });
+    if (fetchResult.ok) {
+        const data = await fetchResult.json();
+        if (data.res) {
+            const chatId = data.res;
+            const group = groups.find(x => x.id == selected_group);
+            if (group) {
+                group.chats.push(chatId);
+                await editGroup(selected_group, true, true);
+                await displayPastChats();
+            }
+        }
+    }
+    if (eventTarget instanceof HTMLInputElement) {
+        eventTarget.value = '';
+    }
+}
 export async function saveGroupBookmarkChat(groupId, name, metadata, mesId) {

public/scripts/macros.js+20 -1 Viewed

 import { Handlebars, moment, seedrandom, droll } from '../lib.js';
-import { chat, chat_metadata, main_api, getMaxContextSize, getCurrentChatId, substituteParams } from '../script.js';
+import { chat, chat_metadata, main_api, getMaxContextSize, getCurrentChatId, substituteParams, eventSource, event_types } from '../script.js';
 import { timestampToMoment, isDigitsOnly, getStringHash, escapeRegex, uuidv4 } from './utils.js';
 import { textgenerationwebui_banned_in_macros } from './textgen-settings.js';
 import { getInstructMacros } from './instruct-mode.js';

     return content;
+}
+export function initMacros() {
+    function initLastGenerationType() {
+        let lastGenerationType = '';
+        MacrosParser.registerMacro('lastGenerationType', () => lastGenerationType);
+        eventSource.on(event_types.GENERATION_STARTED, (type, _params, isDryRun) => {
+            if (isDryRun) return;
+            lastGenerationType = type || 'normal';
+        });
+        eventSource.on(event_types.CHAT_CHANGED, () => {
+            lastGenerationType = '';
+        });
+    }
+    initLastGenerationType();
+}

public/scripts/openai.js+6 -4 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) {

     const isPerplexity = oai_settings.chat_completion_source == chat_completion_sources.PERPLEXITY;
     const isGroq = oai_settings.chat_completion_source == chat_completion_sources.GROQ;
     const is01AI = oai_settings.chat_completion_source == chat_completion_sources.ZEROONEAI;
+    const isNano = oai_settings.chat_completion_source == chat_completion_sources.NANOGPT;
     const isTextCompletion = isOAI && textCompletionModels.includes(oai_settings.openai_model);
     const isQuiet = type === 'quiet';
     const isImpersonate = type === 'impersonate';

@@ -1971,7 +1972,7 @@ async function sendOpenAIRequest(type, messages, signal) {
1971	delete generate_data.stop;	1972	delete generate_data.stop;
1972	}	1973	}
1973		1974
1974	if ((isOAI \|\| isOpenRouter \|\| isMistral \|\| isCustom \|\| isCohere) && oai_settings.seed >= 0) {	1975	if ((isOAI \|\| isOpenRouter \|\| isMistral \|\| isCustom \|\| isCohere \|\| isNano) && oai_settings.seed >= 0) {
1975	generate_data['seed'] = oai_settings.seed;	1976	generate_data['seed'] = oai_settings.seed;
1976	}	1977	}
1977		1978

             $('#openai_max_context').attr('max', max_2mil);
         } else if (value.includes('gemini-exp-1114') || value.includes('gemini-exp-1121')) {
             $('#openai_max_context').attr('max', max_32k);
-        } else if (value.includes('gemini-1.5-pro')) {
+        } else if (value.includes('gemini-1.5-pro') || value.includes('gemini-exp-1206')) {
             $('#openai_max_context').attr('max', max_2mil);
         } else if (value.includes('gemini-1.5-flash')) {
             $('#openai_max_context').attr('max', max_1mil);

         'gemini-1.5-flash-8b-exp-0924',
         'gemini-exp-1114',
         'gemini-exp-1121',
+        'gemini-exp-1206',
         'gemini-1.0-pro-vision-latest',
         'gemini-1.5-pro',
         'gemini-1.5-pro-latest',

public/scripts/power-user.js+13 -12 Viewed

     loadMovingUIState,
     collapseNewlines,
     playMessageSound,
-    sortEntitiesList,
     fixMarkdown,
     power_user,
     send_on_enter_options,

@@ -473,9 +472,9 @@ function switchCompactInputArea() {
473	$('#compact_input_area').prop('checked', power_user.compact_input_area);	472	$('#compact_input_area').prop('checked', power_user.compact_input_area);
474	}	473	}
475		474
476	export function switchSwipeNumAllMessages() {	475	function switchSwipeNumAllMessages() {
477	$('#show_swipe_num_all_messages').prop('checked', power_user.show_swipe_num_all_messages);	476	$('#show_swipe_num_all_messages').prop('checked', power_user.show_swipe_num_all_messages);
478	$('.mes:not(.last_mes) .swipes-counter').css('opacity', '').toggle(power_user.show_swipe_num_all_messages);	477	$('body').toggleClass('swipeAllMessages', !!power_user.show_swipe_num_all_messages);
479	}	478	}
480		479
481	var originalSliderValues = [];	480	var originalSliderValues = [];

  * Common function to perform fuzzy search with optional caching
  * @param {string} type - Type of search from fuzzySearchCategories
  * @param {any[]} data - Data array to search in
- * @param {Array<{name: string, weight: number, getFn?: Function}>} keys - Fuse.js keys configuration
+ * @param {Array<{name: string, weight: number, getFn?: (obj: any) => string}>} keys - Fuse.js keys configuration
  * @param {string} searchValue - The search term
  * @param {Object.<string, { resultMap: Map<string, any> }>} [fuzzySearchCaches=null] - Optional fuzzy search caches
  * @returns {import('fuse.js').FuseResult<any>[]} Results as items with their score

@@ -1851,7 +1850,6 @@ function performFuzzySearch(type, data, keys, searchValue, fuzzySearchCaches = n
1851	}	1850	}
1852	}	1851	}
1853		1852
1854	// @ts-ignore
1855	const fuse = new Fuse(data, {	1853	const fuse = new Fuse(data, {
1856	keys: keys,	1854	keys: keys,
1857	includeScore: true,	1855	includeScore: true,

     const mappedData = data.map(x => ({
         key: x,
         name: power_user.personas[x] ?? '',
-        description: power_user.persona_descriptions[x]?.description ?? ''
+        description: power_user.persona_descriptions[x]?.description ?? '',
     }));
     const keys = [

 /**
  * Sorts an array of entities based on the current sort settings
  * @param {any[]} entities An array of objects with an `item` property
+ * @param {boolean} forceSearch Whether to force search sorting
+ * @param {import('./filters.js').FilterHelper} [filterHelper=null] Filter helper to use
  */
-function sortEntitiesList(entities) {
+export function sortEntitiesList(entities, forceSearch, filterHelper = null) {
+    filterHelper = filterHelper ?? entitiesFilter;
     if (power_user.sort_field == undefined || entities.length === 0) {
         return;
+    }
-    if (power_user.sort_order === 'random') {
+    const isSearch = forceSearch || $('#character_sort_order option[data-field="search"]').is(':selected');
+    if (!isSearch && power_user.sort_order === 'random') {
         shuffle(entities);
         return;
+    }
-    const isSearch = $('#character_sort_order option[data-field="search"]').is(':selected');
     entities.sort((a, b) => {
         // Sort tags/folders will always be at the top
         if (a.type === 'tag' && b.type !== 'tag') {

         // If we have search sorting, we take scores and use those
         if (isSearch) {
-            const aScore = entitiesFilter.getScore(FILTER_TYPES.SEARCH, `${a.type}.${a.id}`);
+            const aScore = filterHelper.getScore(FILTER_TYPES.SEARCH, `${a.type}.${a.id}`);
-            const bScore = entitiesFilter.getScore(FILTER_TYPES.SEARCH, `${b.type}.${b.id}`);
+            const bScore = filterHelper.getScore(FILTER_TYPES.SEARCH, `${b.type}.${b.id}`);
             return (aScore - bScore);
+        }

public/scripts/slash-commands.js+121 -12 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';

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'at',
-                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
+                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values (including -0) are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),

             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'at',
-                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
+                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values (including -0) are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),

             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'at',
-                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
+                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values (including -0) are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),

             ),
             SlashCommandNamedArgument.fromProps({
                 name: 'at',
-                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
+                description: 'position to insert the message (index-based, corresponding to message id). If not set, the message will be inserted at the end of the chat.\nNegative values (including -0) are accepted and will work similarly to how \'depth\' usually works. For example, -1 will insert the message right before the last message in chat.',
                 typeList: [ARGUMENT_TYPE.NUMBER],
                 enumProvider: commonEnumProviders.messages({ allowIdAfter: true }),
             }),

         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));
                 },

     let insertAt = Number(args?.at);
     // Convert possible depth parameter to index
-    if (!isNaN(insertAt) && (insertAt < 0 || insertAt === Number(-0))) {
+    if (!isNaN(insertAt) && (insertAt < 0 || Object.is(insertAt, -0))) {
         // Negative value means going back from current chat length. (E.g.: 8 messages, Depth 1 means insert at index 7)
         insertAt = chat.length + insertAt;
+    }

     let insertAt = Number(args.at);
     // Convert possible depth parameter to index
-    if (!isNaN(insertAt) && (insertAt < 0 || insertAt === Number(-0))) {
+    if (!isNaN(insertAt) && (insertAt < 0 || Object.is(insertAt, -0))) {
         // Negative value means going back from current chat length. (E.g.: 8 messages, Depth 1 means insert at index 7)
         insertAt = chat.length + insertAt;
+    }

     let insertAt = Number(args.at);
     // Convert possible depth parameter to index
-    if (!isNaN(insertAt) && (insertAt < 0 || insertAt === Number(-0))) {
+    if (!isNaN(insertAt) && (insertAt < 0 || Object.is(insertAt, -0))) {
         // Negative value means going back from current chat length. (E.g.: 8 messages, Depth 1 means insert at index 7)
         insertAt = chat.length + insertAt;
+    }

     let insertAt = Number(args.at);
     // Convert possible depth parameter to index
-    if (!isNaN(insertAt) && (insertAt < 0 || insertAt === Number(-0))) {
+    if (!isNaN(insertAt) && (insertAt < 0 || Object.is(insertAt, -0))) {
         // Negative value means going back from current chat length. (E.g.: 8 messages, Depth 1 means insert at index 7)
         insertAt = chat.length + insertAt;
+    }

+}
 /**
+ * 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) {

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

+import {
+    activateSendButtons,
+    addOneMessage,
+    callPopup,
+    characters,
+    chat,
+    chat_metadata,
+    create_save,
+    deactivateSendButtons,
+    event_types,
+    eventSource,
+    extension_prompts,
+    Generate,
+    generateQuietPrompt,
+    getCurrentChatId,
+    getRequestHeaders,
+    getThumbnailUrl,
+    main_api,
+    max_context,
+    menu_type,
+    messageFormatting,
+    name1,
+    name2,
+    online_status,
+    openCharacterChat,
+    reloadCurrentChat,
+    renameChat,
+    saveChatConditional,
+    saveMetadata,
+    saveReply,
+    saveSettingsDebounced,
+    selectCharacterById,
+    sendGenerationRequest,
+    sendStreamingRequest,
+    sendSystemMessage,
+    setExtensionPrompt,
+    stopGeneration,
+    streamingProcessor,
+    substituteParams,
+    substituteParamsExtended,
+    this_chid,
+    updateChatMetadata,
+} from '../script.js';
+import {
+    extension_settings,
+    ModuleWorkerWrapper,
+    renderExtensionTemplate,
+    renderExtensionTemplateAsync,
+    writeExtensionField,
+} from './extensions.js';
+import { groups, openGroupChat, selected_group } from './group-chats.js';
+import { t, translate } from './i18n.js';
+import { hideLoader, showLoader } from './loader.js';
+import { MacrosParser } from './macros.js';
+import { oai_settings } from './openai.js';
+import { callGenericPopup, Popup, POPUP_RESULT, POPUP_TYPE } from './popup.js';
+import { power_user, registerDebugFunction } from './power-user.js';
+import { isMobile, shouldSendOnEnter } from './RossAscends-mods.js';
+import { ScraperManager } from './scrapers.js';
+import { executeSlashCommands, executeSlashCommandsWithOptions, registerSlashCommand } from './slash-commands.js';
+import { SlashCommand } from './slash-commands/SlashCommand.js';
+import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './slash-commands/SlashCommandArgument.js';
+import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
+import { tag_map, tags } from './tags.js';
+import { textgenerationwebui_settings } from './textgen-settings.js';
+import { getTokenCount, getTokenCountAsync, getTokenizerModel } from './tokenizers.js';
+import { ToolManager } from './tool-calling.js';
+import { timestampToMoment } from './utils.js';
+export function getContext() {
+    return {
+        chat,
+        characters,
+        groups,
+        name1,
+        name2,
+        characterId: this_chid,
+        groupId: selected_group,
+        chatId: selected_group
+            ? groups.find(x => x.id == selected_group)?.chat_id
+            : (characters[this_chid]?.chat),
+        getCurrentChatId,
+        getRequestHeaders,
+        reloadCurrentChat,
+        renameChat,
+        saveSettingsDebounced,
+        onlineStatus: online_status,
+        maxContext: Number(max_context),
+        chatMetadata: chat_metadata,
+        streamingProcessor,
+        eventSource,
+        eventTypes: event_types,
+        addOneMessage,
+        generate: Generate,
+        sendStreamingRequest,
+        sendGenerationRequest,
+        stopGeneration,
+        /** @deprecated Use getTokenCountAsync instead */
+        getTokenCount,
+        getTokenCountAsync,
+        extensionPrompts: extension_prompts,
+        setExtensionPrompt,
+        updateChatMetadata,
+        saveChat: saveChatConditional,
+        openCharacterChat,
+        openGroupChat,
+        saveMetadata,
+        sendSystemMessage,
+        activateSendButtons,
+        deactivateSendButtons,
+        saveReply,
+        substituteParams,
+        substituteParamsExtended,
+        SlashCommandParser,
+        SlashCommand,
+        SlashCommandArgument,
+        SlashCommandNamedArgument,
+        ARGUMENT_TYPE,
+        executeSlashCommandsWithOptions,
+        /** @deprecated Use SlashCommandParser.addCommandObject() instead */
+        registerSlashCommand,
+        /** @deprecated Use executeSlashCommandWithOptions instead */
+        executeSlashCommands,
+        timestampToMoment,
+        /** @deprecated Handlebars for extensions are no longer supported. */
+        registerHelper: () => { },
+        registerMacro: MacrosParser.registerMacro.bind(MacrosParser),
+        unregisterMacro: MacrosParser.unregisterMacro.bind(MacrosParser),
+        registerFunctionTool: ToolManager.registerFunctionTool.bind(ToolManager),
+        unregisterFunctionTool: ToolManager.unregisterFunctionTool.bind(ToolManager),
+        isToolCallingSupported: ToolManager.isToolCallingSupported.bind(ToolManager),
+        canPerformToolCalls: ToolManager.canPerformToolCalls.bind(ToolManager),
+        registerDebugFunction,
+        /** @deprecated Use renderExtensionTemplateAsync instead. */
+        renderExtensionTemplate,
+        renderExtensionTemplateAsync,
+        registerDataBankScraper: ScraperManager.registerDataBankScraper.bind(ScraperManager),
+        /** @deprecated Use callGenericPopup or Popup instead. */
+        callPopup,
+        callGenericPopup,
+        showLoader,
+        hideLoader,
+        mainApi: main_api,
+        extensionSettings: extension_settings,
+        ModuleWorkerWrapper,
+        getTokenizerModel,
+        generateQuietPrompt,
+        writeExtensionField,
+        getThumbnailUrl,
+        selectCharacterById,
+        messageFormatting,
+        shouldSendOnEnter,
+        isMobile,
+        t,
+        translate,
+        tags,
+        tagMap: tag_map,
+        menuType: menu_type,
+        createCharacterData: create_save,
+        /** @deprecated Legacy snake-case naming, compatibility with old extensions */
+        event_types: event_types,
+        Popup,
+        POPUP_TYPE,
+        POPUP_RESULT,
+        chatCompletionSettings: oai_settings,
+        textCompletionSettings: textgenerationwebui_settings,
+        powerUserSettings: power_user,
+    };
+}
+export default getContext;

public/scripts/templates/itemizationChat.html+11 -2 Viewed

     <div id="copyPromptToClipboard" class="fa-solid fa-copy menu_button" title="Copy Prompt" data-i18n="[title]Copy Prompt"></div>
     <div id="diffPrevPrompt" class="fa-solid fa-code-compare menu_button" title="Show Prompt Differences" data-i18n="[title]Show Prompt Differences"></div>
 </h3>
-API/Model Used: {{mainApiFriendlyName}} {{#if apiUsed}}({{apiUsed}}){{/if}} {{#if modelUsed}}&ndash; {{modelUsed}}{{/if}}<br>
+<div>
-Tokenizer: {{selectedTokenizer}}<br>
+    <div>
+        API/Model: {{mainApiFriendlyName}} {{#if apiUsed}}({{apiUsed}}){{/if}} {{#if modelUsed}}&ndash; {{modelUsed}}{{/if}}
+    </div>
+    <div>
+        <small>Preset: {{presetName}}</small>
+        <span>|</span>
+        <small>Tokenizer: {{selectedTokenizer}}</small>
+    </div>
+</div>
 <span class="tokenItemizingSubclass">
     Only the white numbers really matter. All numbers are estimates.
     Grey color items may not have been included in the context due to certain prompt format settings.

public/scripts/templates/itemizationText.html+11 -2 Viewed

     <div id="copyPromptToClipboard" class="fa-solid fa-copy menu_button" title="Copy Prompt" data-i18n="[title]Copy Prompt"></div>
     <div id="diffPrevPrompt" class="fa-solid fa-code-compare menu_button" title="Show Prompt Differences" data-i18n="[title]Show Prompt Differences"></div>
 </h3>
-API/Model Used: {{mainApiFriendlyName}} {{#if apiUsed}}({{apiUsed}}){{/if}} {{#if modelUsed}}&ndash; {{modelUsed}}{{/if}}<br>
+<div>
-Tokenizer: {{selectedTokenizer}}<br>
+    <div>
+        API/Model: {{mainApiFriendlyName}} {{#if apiUsed}}({{apiUsed}}){{/if}} {{#if modelUsed}}&ndash; {{modelUsed}}{{/if}}
+    </div>
+    <div>
+        <small>Preset: {{presetName}}</small>
+        <span>|</span>
+        <small>Tokenizer: {{selectedTokenizer}}</small>
+    </div>
+</div>
 <span class="tokenItemizingSubclass">
     Only the white numbers really matter. All numbers are estimates.
     Grey color items may not have been included in the context due to certain prompt format settings.

public/scripts/templates/macros.html+3 -1 Viewed

     <li><tt>&lcub;&lcub;noop&rcub;&rcub;</tt> – <span data-i18n="help_macros_4">no operation, just an empty string.</span></li>
     <li><tt>&lcub;&lcub;original&rcub;&rcub;</tt> – <span data-i18n="help_macros_5">global prompts defined in API settings. Only valid in Advanced Definitions prompt overrides.</span></li>
     <li><tt>&lcub;&lcub;input&rcub;&rcub;</tt> – <span data-i18n="help_macros_6">the user input</span></li>
+    <li><tt>&lcub;&lcub;lastGenerationType&rcub;&rcub;</tt> - <span>the type of the last queued generation request. Empty if no generations were performed yet or the active chat was switched. Possible values: "normal", "impersonate", "regenerate", "quiet", "swipe", "continue".</span></li>
     <li><tt>&lcub;&lcub;charPrompt&rcub;&rcub;</tt> – <span data-i18n="help_macros_7">the Character's Main Prompt override</span></li>
     <li><tt>&lcub;&lcub;charInstruction&rcub;&rcub;</tt> – <span data-i18n="help_macros_8">the Character's Post-History Instructions override</span></li>
     <li><tt>&lcub;&lcub;description&rcub;&rcub;</tt> – <span data-i18n="help_macros_9">the Character's Description</span></li>

     <li><tt>&lcub;&lcub;user&rcub;&rcub;</tt> – <span data-i18n="help_macros_15">your current Persona username</span></li>
     <li><tt>&lcub;&lcub;char&rcub;&rcub;</tt> – <span data-i18n="help_macros_16">the Character's name</span></li>
     <li><tt>&lcub;&lcub;char_version&rcub;&rcub;</tt> – <span data-i18n="help_macros_17">the Character's version number</span></li>
-    <li><tt>&lcub;&lcub;group&rcub;&rcub;</tt> – <span data-i18n="help_macros_18">a comma-separated list of group member names or the character name in solo chats. Alias: &lcub;&lcub;charIfNotGroup&rcub;&rcub;</span></li>
+    <li><tt>&lcub;&lcub;group&rcub;&rcub;</tt> – <span data-i18n="help_macros_18">a comma-separated list of group member names (including muted) or the character name in solo chats. Alias: &lcub;&lcub;charIfNotGroup&rcub;&rcub;</span></li>
+    <li><tt>&lcub;&lcub;groupNotMuted&rcub;&rcub;</tt> – <span data-i18n="help_groupNotMuted">the same as &lcub;&lcub;group&rcub;&rcub;, but excludes muted members</span></li>
     <li><tt>&lcub;&lcub;model&rcub;&rcub;</tt> – <span data-i18n="help_macros_19">a text generation model name for the currently selected API. </span><b data-i18n="Can be inaccurate!">Can be inaccurate!</b></li>
     <li><tt>&lcub;&lcub;lastMessage&rcub;&rcub;</tt> – <span data-i18n="help_macros_20">the text of the latest chat message.</span></li>
     <li><tt>&lcub;&lcub;lastUserMessage&rcub;&rcub;</tt> – <span data-i18n="help_macros_lastUser">the text of the latest user chat message.</span></li>

public/scripts/textgen-settings.js+8 -10 Viewed

 import { ENCODE_TOKENIZERS, TEXTGEN_TOKENIZERS, getTextTokens, tokenizers } from './tokenizers.js';
 import { getSortableDelay, onlyUnique } from './utils.js';
-export {
-    settings as textgenerationwebui_settings,
-    loadTextGenSettings,
-    generateTextGenWithStreaming,
-    formatTextGenURL,
-};
 export const textgen_types = {
     OOBA: 'ooba',
     MANCER: 'mancer',

     featherless_model: '',
 };
+export {
+    settings as textgenerationwebui_settings,
+};
 export let textgenerationwebui_banned_in_macros = [];
 export let textgenerationwebui_presets = [];

     saveSettingsDebounced();
+}
-function formatTextGenURL(value) {
+export function formatTextGenURL(value) {
     try {
         const noFormatTypes = [MANCER, TOGETHERAI, INFERMATICAI, DREAMGEN, OPENROUTER];
         if (noFormatTypes.includes(settings.type)) {

     return result;
+}
-function loadTextGenSettings(data, loadedSettings) {
+export function loadTextGenSettings(data, loadedSettings) {
     textgenerationwebui_presets = convertPresets(data.textgenerationwebui_presets);
     textgenerationwebui_preset_names = data.textgenerationwebui_preset_names ?? [];
     Object.assign(settings, loadedSettings.textgenerationwebui_settings ?? {});

  * @returns {Promise<(function(): AsyncGenerator<{swipes: [], text: string, toolCalls: [], logprobs: {token: string, topLogprobs: Candidate[]}|null}, void, *>)|*>}
  * @throws {Error} - If the response status is not OK, or from within the generator
  */
-async function generateTextGenWithStreaming(generate_data, signal) {
+export async function generateTextGenWithStreaming(generate_data, signal) {
     generate_data.stream = true;
     const response = await fetch('/api/backends/text-completions/generate', {

     if (settings.type === KOBOLDCPP) {
         params.grammar = settings.grammar_string;
+        params.trim_stop = true;
+    }
     if (settings.type === HUGGINGFACE) {

public/scripts/tokenizers.js+20 -10 Viewed

 import { textgen_types, textgenerationwebui_settings as textgen_settings, getTextGenServer, getTextGenModel } from './textgen-settings.js';
 import { getCurrentDreamGenModelTokenizer, getCurrentOpenRouterModelTokenizer, openRouterModels } from './textgen-models.js';
-const { OOBA, TABBY, KOBOLDCPP, VLLM, APHRODITE, LLAMACPP, OPENROUTER, DREAMGEN } = textgen_types;
 export const CHARACTERS_PER_TOKEN_RATIO = 3.35;
 export const TOKENIZER_WARNING_KEY = 'tokenizationWarningShown';
 export const TOKENIZER_SUPPORTED_KEY = 'tokenizationSupported';

     //tokenizers.NERD2,
 ];
-// A list of Text Completion sources that support remote tokenization.
+/**
-export const TEXTGEN_TOKENIZERS = [OOBA, TABBY, KOBOLDCPP, LLAMACPP, VLLM, APHRODITE];
+ * A list of Text Completion sources that support remote tokenization.
+ * Populated in initTokenziers due to circular dependencies.
+ * @type {string[]}
+ */
+export const TEXTGEN_TOKENIZERS = [];
 const TOKENIZER_URLS = {
     [tokenizers.GPT2]: {

         const hasTokenizerError = sessionStorage.getItem(TOKENIZER_WARNING_KEY);
         const hasValidEndpoint = sessionStorage.getItem(TOKENIZER_SUPPORTED_KEY);
         const isConnected = online_status !== 'no_connection';
-        const isTokenizerSupported = TEXTGEN_TOKENIZERS.includes(textgen_settings.type) && (textgen_settings.type !== OOBA || hasValidEndpoint);
+        const isTokenizerSupported = TEXTGEN_TOKENIZERS.includes(textgen_settings.type) && (textgen_settings.type !== textgen_types.OOBA || hasValidEndpoint);
         if (!hasTokenizerError && isConnected) {
             if (forApi === 'kobold' && kai_flags.can_use_tokenization) {

@@ -297,10 +299,10 @@ export function getTokenizerBestMatch(forApi) {
297	if (forApi === 'textgenerationwebui' && isTokenizerSupported) {	299	if (forApi === 'textgenerationwebui' && isTokenizerSupported) {
298	return tokenizers.API_TEXTGENERATIONWEBUI;	300	return tokenizers.API_TEXTGENERATIONWEBUI;
299	}	301	}
300	if (forApi === 'textgenerationwebui' && textgen_settings.type === OPENROUTER) {	302	if (forApi === 'textgenerationwebui' && textgen_settings.type === textgen_types.OPENROUTER) {
301	return getCurrentOpenRouterModelTokenizer();	303	return getCurrentOpenRouterModelTokenizer();
302	}	304	}
303	if (forApi === 'textgenerationwebui' && textgen_settings.type === DREAMGEN) {	305	if (forApi === 'textgenerationwebui' && textgen_settings.type === textgen_types.DREAMGEN) {
304	return getCurrentDreamGenModelTokenizer();	306	return getCurrentDreamGenModelTokenizer();
305	}	307	}
306	}	308	}

     // And for OpenRouter (if not a site model, then it's impossible to determine the tokenizer)
     if (main_api == 'openai' && oai_settings.chat_completion_source == chat_completion_sources.OPENROUTER && oai_settings.openrouter_model ||
-        main_api == 'textgenerationwebui' && textgen_settings.type === OPENROUTER && textgen_settings.openrouter_model) {
+        main_api == 'textgenerationwebui' && textgen_settings.type === textgen_types.OPENROUTER && textgen_settings.openrouter_model) {
         const model = main_api == 'openai'
             ? model_list.find(x => x.id === oai_settings.openrouter_model)
             : openRouterModels.find(x => x.id === textgen_settings.openrouter_model);

@@ -652,7 +654,7 @@ export function getTokenizerModel() {
652	return oai_settings.custom_model;	654	return oai_settings.custom_model;
653	}	655	}
654		656
655	if (oai_settings.chat_completion_source === chat_completion_sources.PERPLEXITY) {	657	if (oai_settings.chat_completion_source === chat_completion_sources.PERPLEXITY) {
656	if (oai_settings.perplexity_model.includes('llama-3') \|\| oai_settings.perplexity_model.includes('llama3')) {	658	if (oai_settings.perplexity_model.includes('llama-3') \|\| oai_settings.perplexity_model.includes('llama3')) {
657	return llama3Tokenizer;	659	return llama3Tokenizer;
658	}	660	}

@@ -680,7 +682,7 @@ export function getTokenizerModel() {
680	return yiTokenizer;	682	return yiTokenizer;
681	}	683	}
682		684
683	if (oai_settings.chat_completion_source === chat_completion_sources.BLOCKENTROPY) {	685	if (oai_settings.chat_completion_source === chat_completion_sources.BLOCKENTROPY) {
684	if (oai_settings.blockentropy_model.includes('llama3')) {	686	if (oai_settings.blockentropy_model.includes('llama3')) {
685	return llama3Tokenizer;	687	return llama3Tokenizer;
686	}	688	}

+}
 export async function initTokenizers() {
+    TEXTGEN_TOKENIZERS.push(
+        textgen_types.OOBA,
+        textgen_types.TABBY,
+        textgen_types.KOBOLDCPP,
+        textgen_types.LLAMACPP,
+        textgen_types.VLLM,
+        textgen_types.APHRODITE,
+    );
     await loadTokenCache();
     registerDebugFunction('resetTokenCache', 'Reset token cache', 'Purges the calculated token counts. Use this if you want to force a full re-tokenization of all chats or suspect the token counts are wrong.', resetTokenCache);
+}

public/scripts/tool-calling.js+1 -1 Viewed

                     enumProvider: toolsEnumProvider,
                 }),
             ],
-            callback: async (name) => {
+            callback: async (_, name) => {
                 if (typeof name !== 'string' || !name) {
                     throw new Error('The unnamed argument must be a non-empty string.');
+                }

public/style.css+8 -2 Viewed

     height: var(--swipeCounterHeight);
+}
-.mes:not(.last_mes) .swipes-counter {
+body:not(.swipeAllMessages) .mes:not(.last_mes) .swipes-counter {
-    opacity: 0.3;
+    visibility: hidden;
+}
+body.swipeAllMessages .mes:not(.last_mes) .swipes-counter {
+    /* Avoid expensive DOM queries */
+    opacity: 0.3 !important;
+    display: flex !important;
+}
 .swipe_left {

src/endpoints/backends/chat-completions.js+1 -1 Viewed

             delete generationConfig.stopSequences;
+        }
-        const should_use_system_prompt = (model.includes('gemini-1.5-flash') || model.includes('gemini-1.5-pro') || model.includes('gemini-exp-1114') || model.includes('gemini-exp-1121')) && request.body.use_makersuite_sysprompt;
+        const should_use_system_prompt = (model.includes('gemini-1.5-flash') || model.includes('gemini-1.5-pro') || model.startsWith('gemini-exp')) && request.body.use_makersuite_sysprompt;
         const prompt = convertGooglePrompt(request.body.messages, model, should_use_system_prompt, request.body.char_name, request.body.user_name);
         let body = {
             contents: prompt.contents,

src/endpoints/characters.js+4 -3 Viewed

 import { AVATAR_WIDTH, AVATAR_HEIGHT } from '../constants.js';
 import { jsonParser, urlencodedParser } from '../express-common.js';
-import { deepMerge, humanizedISO8601DateTime, tryParse, extractFileFromZipBuffer, MemoryLimitedMap } from '../util.js';
+import { deepMerge, humanizedISO8601DateTime, tryParse, extractFileFromZipBuffer, MemoryLimitedMap, getConfigValue } from '../util.js';
 import { TavernCardValidator } from '../validator/TavernCardValidator.js';
 import { parse, write } from '../character-card-parser.js';
 import { readWorldInfoFile } from './worldinfo.js';

 const defaultAvatarPath = './public/img/ai4.png';
 // KV-store for parsed character data
-// 100 MB limit. Would take roughly 3000 characters to reach this limit
+const cacheCapacity = Number(getConfigValue('cardsCacheCapacity', 100)); // MB
-const characterDataCache = new MemoryLimitedMap(1024 * 1024 * 100);
+// With 100 MB limit it would take roughly 3000 characters to reach this limit
+const characterDataCache = new MemoryLimitedMap(1024 * 1024 * cacheCapacity);
 // Some Android devices require tighter memory management
 const isAndroid = process.platform === 'android';

src/endpoints/chats.js+66 -23 Viewed

+}
 /**
+ * Imports a chat from Kobold Lite format.
+ * @param {string} _userName User name
+ * @param {string} _characterName Character name
+ * @param {object} data JSON data
+ * @returns {string} Chat data
+ */
+function importKoboldLiteChat(_userName, _characterName, data) {
+    const inputToken = '{{[INPUT]}}';
+    const outputToken = '{{[OUTPUT]}}';
+    /** @type {function(string): object} */
+    function processKoboldMessage(msg) {
+        const isUser = msg.includes(inputToken);
+        return {
+            name: isUser ? header.user_name : header.character_name,
+            is_user: isUser,
+            mes: msg.replaceAll(inputToken, '').replaceAll(outputToken, '').trim(),
+            send_date: Date.now(),
+        };
+    }
+    // Create the header
+    const header = {
+        user_name: String(data.savedsettings.chatname),
+        character_name: String(data.savedsettings.chatopponent).split('||$||')[0],
+    };
+    // Format messages
+    const formattedMessages = data.actions.map(processKoboldMessage);
+    // Add prompt if available
+    if (data.prompt) {
+        formattedMessages.unshift(processKoboldMessage(data.prompt));
+    }
+    // Combine header and messages
+    const chatData = [header, ...formattedMessages];
+    return chatData.map(obj => JSON.stringify(obj)).join('\n');
+}
+/**
  * Flattens `msg` and `swipes` data from Chub Chat format.
  * Only changes enough to make it compatible with the standard chat serialization format.
  * @param {string} userName User name

     const format = request.body.file_type;
     const avatarUrl = (request.body.avatar_url).replace('.png', '');
     const characterName = request.body.character_name;
-    const userName = request.body.user_name || 'You';
+    const userName = request.body.user_name || 'User';
     if (!request.file) {
         return response.sendStatus(400);

         if (format === 'json') {
             fs.unlinkSync(pathToUpload);
             const jsonData = JSON.parse(data);
-            if (jsonData.histories !== undefined) {
-                // CAI Tools format
+            /** @type {function(string, string, object): string|string[]} */
-                const chats = importCAIChat(userName, characterName, jsonData);
+            let importFunc;
-                for (const chat of chats) {
-                    const fileName = `${characterName} - ${humanizedISO8601DateTime()} imported.jsonl`;
+            if (jsonData.savedsettings !== undefined) { // Kobold Lite format
-                    const filePath = path.join(request.user.directories.chats, avatarUrl, fileName);
+                importFunc = importKoboldLiteChat;
-                    writeFileAtomicSync(filePath, chat, 'utf8');
+            } else if (jsonData.histories !== undefined) { // CAI Tools format
-                }
+                importFunc = importCAIChat;
-                return response.send({ res: true });
+            } else if (Array.isArray(jsonData.data_visible)) { // oobabooga's format
-            } else if (Array.isArray(jsonData.data_visible)) {
+                importFunc = importOobaChat;
-                // oobabooga's format
+            } else if (Array.isArray(jsonData.messages)) { // Agnai's format
-                const chat = importOobaChat(userName, characterName, jsonData);
+                importFunc = importAgnaiChat;
-                const fileName = `${characterName} - ${humanizedISO8601DateTime()} imported.jsonl`;
+            } else { // Unknown format
-                const filePath = path.join(request.user.directories.chats, avatarUrl, fileName);
+                console.log('Incorrect chat format .json');
-                writeFileAtomicSync(filePath, chat, 'utf8');
+                return response.send({ error: true });
-                return response.send({ res: true });
+            }
-            } else if (Array.isArray(jsonData.messages)) {
-                // Agnai format
+            const handleChat = (chat) => {
-                const chat = importAgnaiChat(userName, characterName, jsonData);
                 const fileName = `${characterName} - ${humanizedISO8601DateTime()} imported.jsonl`;
                 const filePath = path.join(request.user.directories.chats, avatarUrl, fileName);
                 writeFileAtomicSync(filePath, chat, 'utf8');
-                return response.send({ res: true });
+            };
+            const chat = importFunc(userName, characterName, jsonData);
+            if (Array.isArray(chat)) {
+                chat.forEach(handleChat);
             } else {
-                console.log('Incorrect chat format .json');
+                handleChat(chat);
-                return response.send({ error: true });
+            }
+            return response.send({ res: true });
+        }
         if (format === 'jsonl') {

src/endpoints/users-public.js+8 -8 Viewed

@@ -67,17 +67,17 @@ router.post('/login', jsonParser, async (request, response) => {
67	const user = await storage.getItem(toKey(request.body.handle));	67	const user = await storage.getItem(toKey(request.body.handle));
68		68
69	if (!user) {	69	if (!user) {
70	console.log('Login failed: User not found');	70	console.log('Login failed: User', request.body.handle, 'not found');
71	return response.status(403).json({ error: 'Incorrect credentials' });	71	return response.status(403).json({ error: 'Incorrect credentials' });
72	}	72	}
73		73
74	if (!user.enabled) {	74	if (!user.enabled) {
75	console.log('Login failed: User is disabled');	75	console.log('Login failed: User', user.handle, 'is disabled');
76	return response.status(403).json({ error: 'User is disabled' });	76	return response.status(403).json({ error: 'User is disabled' });
77	}	77	}
78		78
79	if (user.password && user.password !== getPasswordHash(request.body.password, user.salt)) {	79	if (user.password && user.password !== getPasswordHash(request.body.password, user.salt)) {
80	console.log('Login failed: Incorrect password');	80	console.log('Login failed: Incorrect password for', user.handle);
81	return response.status(403).json({ error: 'Incorrect credentials' });	81	return response.status(403).json({ error: 'Incorrect credentials' });
82	}	82	}
83		83

         await loginLimiter.delete(ip);
         request.session.handle = user.handle;
-        console.log('Login successful:', user.handle, request.session);
+        console.log('Login successful:', user.handle, 'from', ip, 'at', new Date().toLocaleString());
         return response.json({ handle: user.handle });
     } catch (error) {
         if (error instanceof RateLimiterRes) {

@@ -115,12 +115,12 @@ router.post('/recover-step1', jsonParser, async (request, response) => {
115	const user = await storage.getItem(toKey(request.body.handle));	115	const user = await storage.getItem(toKey(request.body.handle));
116		116
117	if (!user) {	117	if (!user) {
118	console.log('Recover step 1 failed: User not found');	118	console.log('Recover step 1 failed: User', request.body.handle, 'not found');
119	return response.status(404).json({ error: 'User not found' });	119	return response.status(404).json({ error: 'User not found' });
120	}	120	}
121		121
122	if (!user.enabled) {	122	if (!user.enabled) {
123	console.log('Recover step 1 failed: User is disabled');	123	console.log('Recover step 1 failed: User', user.handle, 'is disabled');
124	return response.status(403).json({ error: 'User is disabled' });	124	return response.status(403).json({ error: 'User is disabled' });
125	}	125	}
126		126

@@ -153,12 +153,12 @@ router.post('/recover-step2', jsonParser, async (request, response) => {
153	const ip = getIpFromRequest(request);	153	const ip = getIpFromRequest(request);
154		154
155	if (!user) {	155	if (!user) {
156	console.log('Recover step 2 failed: User not found');	156	console.log('Recover step 2 failed: User', request.body.handle, 'not found');
157	return response.status(404).json({ error: 'User not found' });	157	return response.status(404).json({ error: 'User not found' });
158	}	158	}
159		159
160	if (!user.enabled) {	160	if (!user.enabled) {
161	console.log('Recover step 2 failed: User is disabled');	161	console.log('Recover step 2 failed: User', user.handle, 'is disabled');
162	return response.status(403).json({ error: 'User is disabled' });	162	return response.status(403).json({ error: 'User is disabled' });
163	}	163	}
164		164

src/prompt-converters.js+1 -0 Viewed

         'gemini-1.5-flash-8b-exp-0924',
         'gemini-exp-1114',
         'gemini-exp-1121',
+        'gemini-exp-1206',
         'gemini-1.5-pro',
         'gemini-1.5-pro-latest',
         'gemini-1.5-pro-001',

src/util.js+3 -2 Viewed

      * @param {number} maxMemoryInBytes - The maximum allowed memory in bytes for string values.
      */
     constructor(maxMemoryInBytes) {
-        if (typeof maxMemoryInBytes !== 'number' || maxMemoryInBytes <= 0) {
+        if (typeof maxMemoryInBytes !== 'number' || maxMemoryInBytes <= 0 || isNaN(maxMemoryInBytes)) {
-            throw new Error('maxMemoryInBytes must be a positive number');
+            console.warn('Invalid maxMemoryInBytes, using a fallback value of 1 GB.');
+            maxMemoryInBytes = 1024 * 1024 * 1024; // 1 GB
+        }
         this.maxMemory = maxMemoryInBytes;
         this.currentMemory = 0;

Merge pull request #3156 from SillyTavern/staging Staging