Move Kobold Classic settings into related module (#4234) * Move Kobold Classic settings into related module * Update public/scripts/kai-settings.js Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

e0469b48087ae402ddbc2f9ac248dcab0cc80264

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

Signed

Parents: fad1fa3a337415a1c97e0baf4e06b5be762a5f4f

public/script.js+16 -165 Viewed

     generateKoboldWithStreaming,
     kai_settings,
     loadKoboldSettings,
-    formatKoboldUrl,
     getKoboldGenerationData,
     kai_flags,
-    setKoboldFlags,
+    koboldai_settings,
+    koboldai_setting_names,
+    initKoboldSettings,
 } from './scripts/kai-settings.js';
 import {

     getContext,
 };
-/**
- * Exports that were once part of this module. For backwards compatibility.
- */
 export {
     user_avatar,
     setUserAvatar,

     replaceItemizedPromptText,
     deleteItemizedPrompts,
     findItemizedPromptSet,
+    koboldai_settings,
+    koboldai_setting_names,
 };
 /**

 let chat_file_for_del = '';
 export let online_status = 'no_connection';
-export let api_server = '';
 export let is_send_press = false; //Send generation
 let this_del_mes = -1;

 //settings
 export let settings;
-export let koboldai_settings;
-export let koboldai_setting_names;
-var preset_settings = 'gui';
 export let amount_gen = 80; //default max length of AI generated responses
 export let max_context = 2048;

     initDefaultSlashCommands();
     initTextGenModels();
     initOpenAI();
+    initKoboldSettings();
     initSystemPrompts();
     initExtensions();
     initExtensionSlashCommands();

     return resultCheckStatus();
+}
-async function getStatusKobold() {
-    let endpoint = api_server;
-    if (!endpoint) {
-        console.warn('No endpoint for status check');
-        setOnlineStatus('no_connection');
-        return resultCheckStatus();
-    }
-    try {
-        const response = await fetch('/api/backends/kobold/status', {
-            method: 'POST',
-            headers: getRequestHeaders(),
-            body: JSON.stringify({
-                main_api,
-                api_server: endpoint,
-            }),
-            signal: abortStatusCheck.signal,
-        });
-        const data = await response.json();
-        setOnlineStatus(data?.model ?? 'no_connection');
-        if (!data.koboldUnitedVersion) {
-            throw new Error('Missing mandatory Kobold version in data:', data);
-        }
-        // Determine instruct mode preset
-        autoSelectInstructPreset(online_status);
-        // determine if we can use stop sequence and streaming
-        setKoboldFlags(data.koboldUnitedVersion, data.koboldCppVersion);
-        // We didn't get a 200 status code, but the endpoint has an explanation. Which means it DID connect, but I digress.
-        if (online_status === 'no_connection' && data.response) {
-            toastr.error(data.response, t`API Error`, { timeOut: 5000, preventDuplicates: true });
-        }
-    } catch (err) {
-        console.error('Error getting status', err);
-        setOnlineStatus('no_connection');
-    }
-    return resultCheckStatus();
-}
 async function getStatusTextgen() {
     const url = '/api/backends/text-completions/status';

         switch (api) {
             case 'kobold':
             case 'koboldhorde':
-                if (preset_settings === 'gui') {
+                if (kai_settings.preset_settings === 'gui') {
-                    generateData = { prompt: prompt, gui_settings: true, max_length: amount_gen, max_context_length: max_context, api_server };
+                    generateData = { prompt: prompt, gui_settings: true, max_length: amount_gen, max_context_length: max_context, api_server: kai_settings.api_server };
                 } else {
                     const isHorde = api === 'koboldhorde';
-                    const koboldSettings = koboldai_settings[koboldai_setting_names[preset_settings]];
+                    const koboldSettings = koboldai_settings[koboldai_setting_names[kai_settings.preset_settings]];
                     generateData = getKoboldGenerationData(prompt, koboldSettings, amount_gen, max_context, isHorde, 'quiet');
+                }
                 TempResponseLength.restore(api);

                 gui_settings: true,
                 max_length: maxLength,
                 max_context_length: max_context,
-                api_server,
+                api_server: kai_settings.api_server,
             };
-            if (preset_settings != 'gui') {
+            if (kai_settings.preset_settings != 'gui') {
                 const isHorde = main_api == 'koboldhorde';
-                const presetSettings = koboldai_settings[koboldai_setting_names[preset_settings]];
+                const presetSettings = koboldai_settings[koboldai_setting_names[kai_settings.preset_settings]];
                 const maxContext = (adjustedParams && horde_settings.auto_adjust_context_length) ? adjustedParams.maxContextLength : max_context;
                 generate_data = getKoboldGenerationData(finalPrompt, presetSettings, maxLength, maxContext, isHorde, type);
+            }

         // Allow subscribers to mutate settings
         await eventSource.emit(event_types.SETTINGS_LOADED_BEFORE, settings);
-        //Load KoboldAI settings
-        koboldai_setting_names = data.koboldai_setting_names;
-        koboldai_settings = data.koboldai_settings;
-        koboldai_settings.forEach(function (item, i, arr) {
-            koboldai_settings[i] = JSON.parse(item);
-        });
-        let arr_holder = {};
-        $('#settings_preset').empty();
-        $('#settings_preset').append(
-            '<option value="gui">GUI KoboldAI Settings</option>',
-        ); //adding in the GUI settings, since it is not loaded dynamically
-        koboldai_setting_names.forEach(function (item, i, arr) {
-            arr_holder[item] = i;
-            $('#settings_preset').append(`<option value=${i}>${item}</option>`);
-            //console.log('loading preset #'+i+' -- '+item);
-        });
-        koboldai_setting_names = {};
-        koboldai_setting_names = arr_holder;
-        preset_settings = settings.preset_settings;
-        if (preset_settings == 'gui') {
-            selectKoboldGuiPreset();
-        } else {
-            if (typeof koboldai_setting_names[preset_settings] !== 'undefined') {
-                $(`#settings_preset option[value=${koboldai_setting_names[preset_settings]}]`)
-                    .attr('selected', 'true');
-            } else {
-                preset_settings = 'gui';
-                selectKoboldGuiPreset();
-            }
-        }
         novelai_setting_names = data.novelai_setting_names;
         novelai_settings = data.novelai_settings;
         novelai_settings.forEach(function (item, i, arr) {
             novelai_settings[i] = JSON.parse(item);
         });
-        arr_holder = {};
+        const arr_holder = {};
         $('#settings_preset_novel').empty();

         novelai_setting_names = arr_holder;
         //Load AI model config settings
         amount_gen = settings.amount_gen;
         if (settings.max_context !== undefined)
             max_context = parseInt(settings.max_context);

         showSwipeButtons();
         // Kobold
-        loadKoboldSettings(settings.kai_settings ?? settings);
+        loadKoboldSettings(data, settings.kai_settings ?? settings, settings);
         // Novel
         loadNovelSettings(settings.nai_settings ?? settings);

         // TextGen
         loadTextGenSettings(data, settings);
         // OpenAI
         loadOpenAISettings(data, settings.oai_settings ?? settings);

         main_api = settings.main_api;
         $('#main_api').val(main_api);
-        $('#main_api option[value=' + main_api + ']').attr(
+        $(`#main_api option[value=${main_api}]`).attr('selected', 'true');
-            'selected',
-            'true',
-        );
         changeMainAPI();
         //Load User's Name and Avatar
         initUserAvatar(settings.user_avatar);
         setPersonaDescription();

         active_character = settings.active_character;
         active_group = settings.active_group;
-        //Load the API server URL from settings
-        api_server = settings.api_server;
-        $('#api_url_text').val(api_server);
         setWorldInfoSettings(settings.world_info_settings ?? settings, data);
         selected_button = settings.selected_button;

     await eventSource.emit(event_types.SETTINGS_LOADED);
+}
-function selectKoboldGuiPreset() {
-    $('#settings_preset option[value=gui]')
-        .attr('selected', 'true')
-        .trigger('change');
-}
 //MARK: saveSettings()
 export async function saveSettings(loopCounter = 0) {
     if (!settingsReady) {

             username: name1,
             active_character: active_character,
             active_group: active_group,
-            api_server: api_server,
-            preset_settings: preset_settings,
             user_avatar: user_avatar,
             amount_gen: amount_gen,
             max_context: max_context,

@@ -8609,7 +8506,7 @@ export function setGenerationProgress(progress) {
8609	}	8506	}
8610		8507
8611	function isHordeGenerationNotAllowed() {	8508	function isHordeGenerationNotAllowed() {
8612	if (main_api == 'koboldhorde' && preset_settings == 'gui') {	8509	if (main_api == 'koboldhorde' && kai_settings.preset_settings == 'gui') {
8613	toastr.error(t`GUI Settings preset is not supported for Horde. Please select another preset.`);	8510	toastr.error(t`GUI Settings preset is not supported for Horde. Please select another preset.`);
8614	return true;	8511	return true;
8615	}	8512	}

+        }
     });
-    ///////////////////////////////////////////////////////////////////////////////////
-    $('#api_button').on('click', function (e) {
-        if ($('#api_url_text').val() != '') {
-            let value = formatKoboldUrl(String($('#api_url_text').val()).trim());
-            if (!value) {
-                toastr.error('Please enter a valid URL.');
-                return;
-            }
-            $('#api_url_text').val(value);
-            api_server = value;
-            startStatusLoading();
-            main_api = 'kobold';
-            saveSettingsDebounced();
-            getStatusKobold();
-        }
-    });
     $('#api_button_textgenerationwebui').on('click', async function (e) {
         const keys = [
             { id: 'api_key_mancer', secret: SECRET_KEYS.MANCER },

         is_delete_mode = false;
     });
-    $('#settings_preset').on('change', function () {
-        if ($('#settings_preset').find(':selected').val() != 'gui') {
-            preset_settings = $('#settings_preset').find(':selected').text();
-            const preset = koboldai_settings[koboldai_setting_names[preset_settings]];
-            loadKoboldSettings(preset);
-            setGenerationParamsFromPreset(preset);
-            $('#kobold_api-settings').find('input').prop('disabled', false);
-            $('#kobold_api-settings').css('opacity', 1.0);
-            $('#kobold_order')
-                .css('opacity', 1)
-                .sortable('enable');
-        } else {
-            //$('.button').disableSelection();
-            preset_settings = 'gui';
-            $('#kobold_api-settings').find('input').prop('disabled', true);
-            $('#kobold_api-settings').css('opacity', 0.5);
-            $('#kobold_order')
-                .css('opacity', 0.5)
-                .sortable('disable');
-        }
-        saveSettingsDebounced();
-    });
     $('#settings_preset_novel').on('change', function () {
         nai_settings.preset_settings_novel = $('#settings_preset_novel')
             .find(':selected')

public/scripts/RossAscends-mods.js+2 -2 Viewed

     characters,
     online_status,
     main_api,
-    api_server,
     is_send_press,
     max_context,
     saveSettingsDebounced,

 import { Popup } from './popup.js';
 import { accountStorage } from './util/AccountStorage.js';
 import { getCurrentUserHandle } from './user.js';
+import { kai_settings } from './kai-settings.js';
 var RPanelPin = document.getElementById('rm_button_panel_pin');
 var LPanelPin = document.getElementById('lm_button_panel_pin');

     if (online_status === 'no_connection' && power_user.auto_connect) {
         switch (main_api) {
             case 'kobold':
-                if (api_server && isValidUrl(api_server)) {
+                if (kai_settings.api_server && isValidUrl(kai_settings.api_server)) {
                     $('#api_button').trigger('click');
+                }
                 break;

public/scripts/kai-settings.js+148 -6 Viewed

     saveSettingsDebounced,
     getStoppingStrings,
     substituteParams,
-    api_server,
+    setOnlineStatus,
+    resultCheckStatus,
+    main_api,
+    online_status,
+    abortStatusCheck,
+    startStatusLoading,
+    setGenerationParamsFromPreset,
 } from '../script.js';
+import { t } from './i18n.js';
+import { autoSelectInstructPreset } from './instruct-mode.js';
 import {
     power_user,

 import { getEventSourceStream } from './sse-stream.js';
 import { getSortableDelay } from './utils.js';
+export let koboldai_settings;
+export let koboldai_setting_names;
 export const kai_settings = {
     temp: 1,
     rep_pen: 1,

     use_default_badwordsids: false,
     grammar: '',
     seed: -1,
+    api_server: '',
+    preset_settings: 'gui',
 };
 /**

     return null;
+}
-export function loadKoboldSettings(preset) {
+function selectKoboldGuiPreset() {
+    $('#settings_preset option[value=gui]')
+        .attr('selected', 'true')
+        .trigger('change');
+}
+export function loadKoboldSettings(data, preset, settings) {
+    koboldai_setting_names = data.koboldai_setting_names;
+    koboldai_settings = data.koboldai_settings;
+    koboldai_settings.forEach(function (item, i, arr) {
+        koboldai_settings[i] = JSON.parse(item);
+    });
+    $('#settings_preset').empty();
+    $('#settings_preset').append('<option value="gui">GUI KoboldAI Settings</option>');
+    const names = {};
+    koboldai_setting_names.forEach(function (item, i, arr) {
+        names[item] = i;
+        $('#settings_preset').append(`<option value=${i}>${item}</option>`);
+    });
+    koboldai_setting_names = names;
+    kai_settings.preset_settings = preset.preset_settings ?? settings.preset_settings;
+    kai_settings.api_server = preset.api_server ?? settings.api_server;
+    if (kai_settings.preset_settings == 'gui') {
+        selectKoboldGuiPreset();
+    } else {
+        if (typeof koboldai_setting_names[kai_settings.preset_settings] !== 'undefined') {
+            $(`#settings_preset option[value=${koboldai_setting_names[kai_settings.preset_settings]}]`)
+                .attr('selected', 'true');
+        } else {
+            kai_settings.preset_settings = 'gui';
+            selectKoboldGuiPreset();
+        }
+    }
+    loadKoboldSettingsFromPreset(preset);
+    //Load the API server URL from settings
+    $('#api_url_text').val(kai_settings.api_server);
+}
+function loadKoboldSettingsFromPreset(preset) {
     for (const name of Object.keys(kai_settings)) {
         const value = preset[name] ?? defaultValues[name];
         const slider = sliders.find(x => x.name === name);

         use_default_badwordsids: (kai_flags.can_use_default_badwordsids || isHorde) ? kai_settings.use_default_badwordsids : undefined,
         grammar: (kai_flags.can_use_grammar || isHorde) ? substituteParams(kai_settings.grammar) : undefined,
         sampler_seed: kai_settings.seed >= 0 ? kai_settings.seed : undefined,
+        api_server: kai_settings.api_server,
-        api_server,
     };
     return generate_data;
+}

+    }
+}
-jQuery(function () {
+export async function getStatusKobold() {
+    let endpoint = kai_settings.api_server;
+    if (!endpoint) {
+        console.warn('No endpoint for status check');
+        setOnlineStatus('no_connection');
+        return resultCheckStatus();
+    }
+    try {
+        const response = await fetch('/api/backends/kobold/status', {
+            method: 'POST',
+            headers: getRequestHeaders(),
+            body: JSON.stringify({
+                main_api,
+                api_server: endpoint,
+            }),
+            signal: abortStatusCheck.signal,
+        });
+        const data = await response.json();
+        setOnlineStatus(data?.model ?? 'no_connection');
+        if (!data.koboldUnitedVersion) {
+            throw new Error(`Missing mandatory Kobold version in data: ${JSON.stringify(data)}`);
+        }
+        // Determine instruct mode preset
+        autoSelectInstructPreset(online_status);
+        // determine if we can use stop sequence and streaming
+        setKoboldFlags(data.koboldUnitedVersion, data.koboldCppVersion);
+        // We didn't get a 200 status code, but the endpoint has an explanation. Which means it DID connect, but I digress.
+        if (online_status === 'no_connection' && data.response) {
+            toastr.error(data.response, t`API Error`, { timeOut: 5000, preventDuplicates: true });
+        }
+    } catch (err) {
+        console.error('Error getting status', err);
+        setOnlineStatus('no_connection');
+    }
+    return resultCheckStatus();
+}
+export function initKoboldSettings() {
     sliders.forEach(slider => {
         $(document).on('input', slider.sliderId, function () {
             const value = $(this).val();

         });
     });
+    $('#api_button').on('click', function (e) {
+        if ($('#api_url_text').val() != '') {
+            const value = formatKoboldUrl(String($('#api_url_text').val()).trim());
+            if (!value) {
+                toastr.error('Please enter a valid URL.');
+                return;
+            }
+            $('#api_url_text').val(value);
+            kai_settings.api_server = value;
+            startStatusLoading();
+            saveSettingsDebounced();
+            getStatusKobold();
+        }
+    });
     $('#streaming_kobold').on('input', function () {
         const value = !!$(this).prop('checked');
         kai_settings.streaming_kobold = value;

         sortItemsByOrder(kai_settings.sampler_order);
         saveSettingsDebounced();
     });
-});
+    $('#settings_preset').on('change', function () {
+        if ($('#settings_preset').find(':selected').val() != 'gui') {
+            kai_settings.preset_settings = $('#settings_preset').find(':selected').text();
+            const preset = koboldai_settings[koboldai_setting_names[kai_settings.preset_settings]];
+            loadKoboldSettingsFromPreset(preset);
+            setGenerationParamsFromPreset(preset);
+            $('#kobold_api-settings').find('input').prop('disabled', false);
+            $('#kobold_api-settings').css('opacity', 1.0);
+            $('#kobold_order')
+                .css('opacity', 1)
+                .sortable('enable');
+        } else {
+            kai_settings.preset_settings = 'gui';
+            $('#kobold_api-settings').find('input').prop('disabled', true);
+            $('#kobold_api-settings').css('opacity', 0.5);
+            $('#kobold_order')
+                .css('opacity', 0.5)
+                .sortable('disable');
+        }
+        saveSettingsDebounced();
+    });
+}

public/scripts/preset-manager.js+2 -0 Viewed

+        }
         const filteredKeys = [
+            'api_server',
             'preset',
             'streaming',
             'truncation_length',

             'can_use_tokenization',
             'can_use_streaming',
             'preset_settings_novel',
+            'preset_settings',
             'streaming_novel',
             'nai_preamble',
             'model_novel',

public/scripts/slash-commands.js+3 -3 Viewed

     UNIQUE_APIS,
     activateSendButtons,
     addOneMessage,
-    api_server,
     characters,
     chat,
     chat_metadata,

 import { SlashCommandDebugController } from './slash-commands/SlashCommandDebugController.js';
 import { SlashCommandScope } from './slash-commands/SlashCommandScope.js';
 import { t } from './i18n.js';
+import { kai_settings } from './kai-settings.js';
 export {
     executeSlashCommands, executeSlashCommandsWithOptions, getSlashCommandsHelp, registerSlashCommand,
 };

     const isCurrentlyKoboldClassic = main_api === 'kobold';
     if (api === 'kobold' || (!api && isCurrentlyKoboldClassic)) {
         if (!url) {
-            return api_server ?? '';
+            return kai_settings.api_server ?? '';
+        }
         if (!isCurrentlyKoboldClassic && autoConnect) {

@@ -4571,7 +4571,7 @@ async function setApiUrlCallback({ api = null, connect = 'true', quiet = 'false'
4571	$('#api_button').trigger('click');	4571	$('#api_button').trigger('click');
4572	}	4572	}
4573		4573
4574	return api_server ?? '';	4574	return kai_settings.api_server ?? '';
4575	}	4575	}
4576		4576
4577	// Do some checks and get the api type we are targeting with this command	4577	// Do some checks and get the api type we are targeting with this command

public/scripts/tokenizers.js+4 -4 Viewed

 import { localforage } from '../lib.js';
-import { characters, main_api, api_server, nai_settings, online_status, this_chid } from '../script.js';
+import { characters, main_api, nai_settings, online_status, this_chid } from '../script.js';
 import { power_user, registerDebugFunction } from './power-user.js';
 import { chat_completion_sources, model_list, oai_settings } from './openai.js';
 import { groups, selected_group } from './group-chats.js';
 import { getStringHash } from './utils.js';
-import { kai_flags } from './kai-settings.js';
+import { kai_flags, kai_settings } from './kai-settings.js';
 import { textgen_types, textgenerationwebui_settings as textgen_settings, getTextGenServer, getTextGenModel } from './textgen-settings.js';
 import { getCurrentDreamGenModelTokenizer, getCurrentOpenRouterModelTokenizer, openRouterModels } from './textgen-models.js';

         url: TOKENIZER_URLS[tokenizers.API_KOBOLD].count,
         data: JSON.stringify({
             text: str,
-            url: api_server,
+            url: kai_settings.api_server,
         }),
         dataType: 'json',
         contentType: 'application/json',

         url: TOKENIZER_URLS[tokenizers.API_KOBOLD].encode,
         data: JSON.stringify({
             text: str,
-            url: api_server,
+            url: kai_settings.api_server,
         }),
         dataType: 'json',
         contentType: 'application/json',