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.89",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "sillytavern",
             "version": "1.12.89",
             "hasInstallScript": true,
             "license": "AGPL-3.0",
             "dependencies": {

package.json+1 -1 Viewed

         "type": "git",
         "url": "https://github.com/SillyTavern/SillyTavern.git"
     },
     "version": "1.12.89",
     "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(): anytypeof 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,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,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,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,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,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, 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>
                                 </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,
 +        "strictBindCallApply": true
     },
     "exclude": [
         "**/node_modules/**",

public/script.js+74 -161 Viewed

     default as libs,
 } from './lib.js';
 import { humanizedDateTime, favsToHotswap, getMessageTimeStamp, dragElement, isMobile, initRossMods, shouldSendOnEnter } 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 { COMMENT_NAME_DEFAULT, executeSlashCommands, executeSlashCommandsOnChatInput, executeSlashCommandsWithOptions, getSlashCommandsHelp, initDefaultSlashCommands, isExecutingCommandsFromChatInput, pauseScriptExecution, processChatSlashCommands, registerSlashCommand, 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 { getFriendlyTokenizerName, getTokenCount, getTokenCountAsync, getTokenizerModel, 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 { getPresetManager, initPresetManager } from './scripts/preset-manager.js';
 import { MacrosParser, 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 { 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[]} */
 export let characters = [];
 export let this_chid;
 let saveCharactersPage = 0;

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

 export let max_context = 2048;
 var swipes = true;
 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	1173	return resultCheckStatus();
1175	1174	}
1176	1175
1177	1176	if (textgen_settings.type == textgen_types.OOBA && textgen_settings.bypass_status_check) {
1178	1177	setOnlineStatus('Status check bypassed');
1179	1178	return resultCheckStatus();
1180	1179	}

         const data = await response.json();
         if (textgen_settings.type === textgen_types.MANCER) {
             loadMancerModels(data?.data);
             setOnlineStatus(textgen_settings.mancer_model);
         } else if (textgen_settings.type === textgen_types.TOGETHERAI) {
             loadTogetherAIModels(data?.data);
             setOnlineStatus(textgen_settings.togetherai_model);
         } else if (textgen_settings.type === textgen_types.OLLAMA) {
             loadOllamaModels(data?.data);
             setOnlineStatus(textgen_settings.ollama_model || 'Connected');
         } else if (textgen_settings.type === textgen_types.INFERMATICAI) {
             loadInfermaticAIModels(data?.data);
             setOnlineStatus(textgen_settings.infermaticai_model);
         } else if (textgen_settings.type === textgen_types.DREAMGEN) {
             loadDreamGenModels(data?.data);
             setOnlineStatus(textgen_settings.dreamgen_model);
         } else if (textgen_settings.type === textgen_types.OPENROUTER) {
             loadOpenRouterModels(data?.data);
             setOnlineStatus(textgen_settings.openrouter_model);
         } else if (textgen_settings.type === textgen_types.VLLM) {
             loadVllmModels(data?.data);
             setOnlineStatus(textgen_settings.vllm_model);
         } else if (textgen_settings.type === textgen_types.APHRODITE) {
             loadAphroditeModels(data?.data);
             setOnlineStatus(textgen_settings.aphrodite_model);
         } else if (textgen_settings.type === textgen_types.FEATHERLESS) {
             loadFeatherlessModels(data?.data);
             setOnlineStatus(textgen_settings.featherless_model);
         } 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	1635	subEntities = entitiesFilter.applyFilters(subEntities, { clearScoreCache: false, tempOverrides: { [FILTER_TYPES.FOLDER]: FILTER_STATES.UNDEFINED }, clearFuzzySearchCaches: false });
1637	1636	}
1638	1637	if (doSort) {
1639	1638	sortEntitiesList(subEntities, false);
1640	1639	}
1641	1640	entity.entities = subEntities;
1642	1641	entity.hidden = subCount - subEntities.length;

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

         };
+    }
     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.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(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	5540	return swipes;
5536	5541	}
5537	5542
5538	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	5544	if (!Array.isArray(data.choices)) {
5540	5545	return swipes;
5541	5546	}

     return getMessage;
+}
 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')chatElement.find('.swipe_right').hide();
     $('#chat')chatElement.find('.last_mes .swipes-counter').hide();
     $('#chat')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:async function importCharacterChat(formData, eventTarget) {
 -        },
 +    const headers = getRequestHeaders();
 -        cache: false,
 +    delete headers['Content-Type'];
 -        contentType: false,
 +    const fetchResult = await fetch('/api/chats/import', {
         processDatamethod: false'POST',
 -        success: async function (data) {
 +        body: formData,
 +        headers: headers,
 +        cache: 'no-cache',
 +    });
++
 +    if (fetchResult.ok) {
 +        const data = await fetchResult.json();
         if (data.res) {
             await displayPastChats();
+        }
 -        },
 +    }
 -        error: function () {
++
 -            $('#create_button').removeAttr('disabled');
 +    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) {
         varconst file = e.target.files[0];
         if (!file) {
             return;
+        }
         varconst ext = file.name.match(/\.(\w+)$/);
         if (
             !ext ||
             (ext[1].toLowerCase() != 'json' && ext[1].toLowerCase() != 'jsonl')

             return;
+        }
         varconst format = ext[1].toLowerCase();
         $('#chat_import_file_type').val(format);
         varconst formData = new FormData($('#form_import_chat').get(0));
         formData.append('user_name', name1);
         $('#select_chat_div').html('');
         if (selected_group) {
             await importGroupChat(formData, e.originalEvent.target);
         } else {
             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(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: 18x18px;
     font-weight: bold;
     border-top: 1px solid #e1e1e1; /* Grey line */
     border-bottom: 1px solid #e1e1e1; /* Grey line */

public/scripts/group-chats.js+30 -22 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: indexcharacters.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: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', {
         processDatamethod: false'POST',
 -        success: async function (data) {
 +        headers: headers,
 +        body: formData,
 +        cache: 'no-cache',
 +    });
++
 +    if (fetchResult.ok) {
 +        const data = await fetchResult.json();
         if (data.res) {
             const chatId = data.res;
             const group = groups.find(x => x.id == selected_group);

@@ -1884,11 +1892,11 @@ export async function importGroupChat(formData) {
1884	1892	await displayPastChats();
1885	1893	}
1886	1894	}
1887		- },
	1895	+ }
1888		- error: function () {
	1896	+
1889		- $('#create_button').removeAttr('disabled');
	1897	+ if (eventTarget instanceof HTMLInputElement) {
1890		- },
	1898	+ eventTarget.value = '';
1891	1899	});
1892	1900	}
1893	1901
1894	1902	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, 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} */
 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	1972	delete generate_data.stop;
1972	1973	}
1973	1974
1974	1975	if ((isOAI \|\| isOpenRouter \|\| isMistral \|\| isCustom \|\| isCohere \|\| isNano) && oai_settings.seed >= 0) {
1975	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') || 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	472	$('#compact_input_area').prop('checked', power_user.compact_input_area);
474	473	}
475	474
476	475	export function switchSwipeNumAllMessages() {
477	476	$('#show_swipe_num_all_messages').prop('checked', power_user.show_swipe_num_all_messages);
478	477	$('.mes:not(.last_mes) .swipes-counterbody').csstoggleClass('opacityswipeAllMessages', '').toggle(!!power_user.show_swipe_num_all_messages);
479	478	}
480	479
481	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(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	1853	const fuse = new Fuse(data, {
1856	1854	keys: keys,
1857	1855	includeScore: true,

     const mappedData = data.map(x => ({
         key: x,
         name: power_user.personas[x] ?? '',
         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
  */
 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 = entitiesFilterfilterHelper.getScore(FILTER_TYPES.SEARCH, `${a.type}.${a.id}`);
             const bScore = entitiesFilterfilterHelper.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, setupChatCompletionPromptManagerpromptManager } from './openai.js';
 import { autoSelectPersona, retriggerFirstMessageOnEmptyChat, setPersonaLockState, togglePersonaLock, user_avatar } from './personas.js';
 import { addEphemeralStoppingString, chat_styles, flushEphemeralStoppingStrings, power_user } from './power-user.js';
 import { SERVER_INPUTS, textgen_types, textgenerationwebui_settings } from './textgen-settings.js';

             }),
             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 (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 (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 (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 (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 || Object.is(insertAt ===, Number(-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 || Object.is(insertAt ===, Number(-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 || Object.is(insertAt ===, Number(-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 || Object.is(insertAt ===, Number(-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 (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();
+}
 export function formatTextGenURL(value) {
     try {
         const noFormatTypes = [MANCER, TOGETHERAI, INFERMATICAI, DREAMGEN, OPENROUTER];
         if (noFormatTypes.includes(settings.type)) {

     return result;
+}
 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
  */
 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+18 -8 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 !== textgen_types.OOBA || hasValidEndpoint);
         if (!hasTokenizerError && isConnected) {
             if (forApi === 'kobold' && kai_flags.can_use_tokenization) {

@@ -297,10 +299,10 @@ export function getTokenizerBestMatch(forApi) {
297	299	if (forApi === 'textgenerationwebui' && isTokenizerSupported) {
298	300	return tokenizers.API_TEXTGENERATIONWEBUI;
299	301	}
300	302	if (forApi === 'textgenerationwebui' && textgen_settings.type === textgen_types.OPENROUTER) {
301	303	return getCurrentOpenRouterModelTokenizer();
302	304	}
303	305	if (forApi === 'textgenerationwebui' && textgen_settings.type === textgen_types.DREAMGEN) {
304	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 === 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);

+}
 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) => {
                 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);
+}
 body:not(.swipeAllMessages) .mes:not(.last_mes) .swipes-counter {
     opacityvisibility: 0.3hidden;
 +}
++
 +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.includesstartsWith('gemini-exp-1121')) && 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, 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+65 -22 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 || 'YouUser';
     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;
 +            } else if (Array.isArray(jsonData.data_visible)) { // oobabooga's format
 +                importFunc = importOobaChat;
 +            } else if (Array.isArray(jsonData.messages)) { // Agnai's format
 +                importFunc = importAgnaiChat;
 +            } else { // Unknown format
 +                console.log('Incorrect chat format .json');
 +                return response.send({ error: true });
+            }
 -                return response.send({ res: true });
++
 -            } else if (Array.isArray(jsonData.data_visible)) {
 +            const handleChat = (chat) => {
 -                // oobabooga's format
 -                const chat = importOobaChat(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 });
 -            } else if (Array.isArray(jsonData.messages)) {
 -                // Agnai format
 -                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	67	const user = await storage.getItem(toKey(request.body.handle));
68	68
69	69	if (!user) {
70	70	console.log('Login failed: User', request.body.handle, 'not found');
71	71	return response.status(403).json({ error: 'Incorrect credentials' });
72	72	}
73	73
74	74	if (!user.enabled) {
75	75	console.log('Login failed: User', user.handle, 'is disabled');
76	76	return response.status(403).json({ error: 'User is disabled' });
77	77	}
78	78
79	79	if (user.password && user.password !== getPasswordHash(request.body.password, user.salt)) {
80	80	console.log('Login failed: Incorrect password for', user.handle);
81	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'from', ip, 'at', new Date().sessiontoLocaleString());
         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	115	const user = await storage.getItem(toKey(request.body.handle));
116	116
117	117	if (!user) {
118	118	console.log('Recover step 1 failed: User', request.body.handle, 'not found');
119	119	return response.status(404).json({ error: 'User not found' });
120	120	}
121	121
122	122	if (!user.enabled) {
123	123	console.log('Recover step 1 failed: User', user.handle, 'is disabled');
124	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	153	const ip = getIpFromRequest(request);
154	154
155	155	if (!user) {
156	156	console.log('Recover step 2 failed: User', request.body.handle, 'not found');
157	157	return response.status(404).json({ error: 'User not found' });
158	158	}
159	159
160	160	if (!user.enabled) {
161	161	console.log('Recover step 2 failed: User', user.handle, 'is disabled');
162	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 || 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