Facillitate extension use of ConnectionManagerRequestService (#4841) * Separate prompt-building functionality from request-sending functionality * removing logs and clarifying comments * separating parameter construction functionality to allow ConnectionManagerRequestService to use all other preset parameters * fixing chat completion issues, adding documentation to new functions. * Improving ConnectionManagerRequestService errors. Adding parseReasoningFromString option to override reasoning template. * Adjusting TextCompletionService prompt formatting * linting * Use settingsToUpdate to convert from OAI preset to OAI settings. * lint * throw errors when profile ID not found * Fix missed instances of global completion settings being used (CC and TC), replaced with optional argument. Specified typing for ChatCompletionSettings and TextCompletionSettings. * Adjusting parameters of parseReasoningFromString and adding getReasoningTemplateByName * using messages.role as a fallback for custom requests, fixing newline removal. * parameters => settings I like how it sounds better * ditto * You know I had to do it to 'em * Update getCustomTokenBans * Fix calculateLogitBias * Fix param attributes * Fix type checks * Less strict role type on ChatCompletionMessage * Add missing space * fixing getChatCompletionModel to use an arbitrary chat completion settings object * Fixing issues with preset overriding custom data passed. * Pass model to createGenerationParameters externally * Unify seed param handling for CHUTES * Fix non-existing CC source * Use strict comparison * Use global settings as a base for generation parameters creation * removing unnecessary handling of preset fields * don't pass preset prompts, use the passed payload override messages * refactoring text generation prompt building of last line * Pass model to getReasoningEffort * Pass model name to canPerformToolCalls * Pass model to createTextGenGenerationData --------- Co-authored-by: qvink <qvink@users.noreply.github.com> Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

a4cc9b3989dd1a96b1dc48e21c3b4ca951577dd0

qvink <191186569+qvink@users.noreply.github.com>

Signed

Parents: 6c8eb4d9ac6b9e76fd5ed53ad6e2739f112131bf

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

         paused: boolean;
+    }
 +    interface ChatCompletionMessage {
 +        name?: string;
 +        role: string;
 +        content: string;
 +    }
++
     // Global namespace modules
     interface Window {
         ai: any;

public/scripts/custom-request.js+134 -123 Viewed

 import { getPresetManager } from './preset-manager.js';
 import { extractJsonFromData, extractMessageFromData, getGenerateUrl, getRequestHeaders, name1, name2 } from '../script.js';
 import { getTextGenServer, createTextGenGenerationData, setting_names, textgenerationwebui_settings } from './textgen-settings.js';
 import { extractReasoningFromData } from './reasoning.js';
 import { formatInstructModeChat, formatInstructModePrompt, getInstructStoppingSequences, names_behavior_types } from './instruct-mode.js';
 import { getStreamingReply, tryParseStreamingError, createGenerationParameters, settingsToUpdate, oai_settings } from './openai.js';
 import EventSourceStream from './sse-stream.js';
 // #region Type Definitions

 /**
  * @typedef {Object} ChatCompletionMessage
 + * @property {string} [name] - The name of the message author (optional)
  * @property {string} role - The role of the message author (e.g., "user", "assistant", "system")
  * @property {string} content - The content of the message
  */

             const json = await response.json();
             if (!response.ok || json.error) {
 -                throw json;
 +                throw new Error(String(json.error?.message || 'Response not OK'));
+            }
             if (!extractData) {

+    }
     /**
 -     * Process and send a text completion request with optional preset & instruct
 +    * Return a formatted prompt string given an array of messages, a chosen instruct preset, and instruct settings.
          * @param {Record<string, any> & TextCompletionRequestBase & {prompt: (ChatCompletionMessage & {ignoreInstruct?: boolean})[] |string}} customprompt An array of messages
 -     * @param {Object} options - Configuration options
 +    * @param {InstructSettings|string} instructPreset Either the name of an instruct preset or the instruct preset object itself.
 -     * @param {string?} [options.presetName] - Name of the preset to use for generation settings
 +    * @param {Partial<InstructSettings>} instructSettings Optional instruct settings
 -     * @param {string?} [options.instructName] - Name of instruct preset for message formatting
 -     * @param {Partial<InstructSettings>?} [options.instructSettings] - Override instruct settings
 -     * @param {boolean} extractData - Whether to extract structured data from response
 -     * @param {AbortSignal?} [signal]
 -     * @returns {Promise<ExtractedData | (() => AsyncGenerator<StreamResponse>)>} If not streaming, returns extracted data; if streaming, returns a function that creates an AsyncGenerator
 -     * @throws {Error}
     */
 -    static async processRequest(
 +    static constructPrompt(prompt, instructPreset, instructSettings) {
 -        custom,
 +        // InstructPreset may either be a name or itself a preset
 -        options = {},
 +        if (typeof instructPreset === 'string') {
 -        extractData = true,
 +            const instructPresetManager = getPresetManager('instruct');
 -        signal = null,
 +            instructPreset = instructPresetManager?.getCompletionPresetByName(instructPreset);
 -    ) {
 -        const { presetName, instructName } = options;
 -        let requestData = { ...custom };
 -        const prompt = custom.prompt;
+-
 -        // Apply generation preset if specified
 -        if (presetName) {
 -            const presetManager = getPresetManager(this.TYPE);
 -            if (presetManager) {
 -                const preset = presetManager.getCompletionPresetByName(presetName);
 -                if (preset) {
 -                    // Convert preset to payload and merge with custom parameters
 -                    const presetPayload = this.presetToGeneratePayload(preset, {});
 -                    requestData = { ...presetPayload, ...requestData };
 -                } else {
 -                    console.warn(`Preset "${presetName}" not found, continuing with default settings`);
 -                }
 -            } else {
 -                console.warn('Preset manager not found, continuing with default settings');
 -            }
+        }
+-
 -        /** @type {InstructSettings | undefined} */
 -        let instructPreset;
 -        // Handle instruct formatting if requested
 -        if (Array.isArray(prompt) && instructName) {
 -            const instructPresetManager = getPresetManager('instruct');
 -            instructPreset = instructPresetManager?.getCompletionPresetByName(instructName);
 -            if (instructPreset) {
         // Clone the preset to avoid modifying the original
         instructPreset = structuredClone(instructPreset);
 -                instructPreset.names_behavior = names_behavior_types.NONE;
 +        if (instructSettings) {  // apply any additional settings
 -                if (options.instructSettings) {
 +            Object.assign(instructPreset, instructSettings);
 -                    Object.assign(instructPreset, options.instructSettings);
 +        }
++
 +        // Make the type check shut up. We 100% don't have a string here.
 +        if (typeof instructPreset === 'string') {
 +            return;
+        }
         // Format messages using instruct formatting

                 // 2. If prefill is active, format all messages except the last one
                 if (!isLastMessage || !prefillActive) {
                     messageContent = formatInstructModeChat(
 -                                message.role,
 +                        message.name ?? message.role,
                         message.content,
                         message.role === 'user',
                         message.role === 'system',
                         undefined,
 -                                undefined,
 +                        name1,  // for macros
 -                                undefined,
 +                        name2,  // for macros
                         undefined,
                         instructPreset,
                     );
+                }
                 // Add prompt formatting for the last message.
 +                // e.g. "<|im_start|>assistant"
                 if (isLastMessage) {
 -                            if (!prefillActive) { // e.g. "<|im_start|>user:"
 +                    let last_line = formatInstructModePrompt(
 -                                messageContent += formatInstructModePrompt(
 +                        'assistant',  // for sequences using {{name}}
 -                                    undefined,
 +                        false,  // not an impersonation
 -                                    false,
 +                        prefillActive ? message.content : undefined,  // if using prefill, last message is the prefill
 -                                    undefined,
 +                        name1,  // for macros
 -                                    undefined,
 +                        name2,  // for macros
 -                                    undefined,
 +                        true,   // quiet
 -                                    false,
                         false,
                         instructPreset,
                     );
 -                            } else { // e.g. "<|im_start|>assistant: Hello, my name is"
++
 -                                const overriddenInstructPreset = structuredClone(instructPreset);
 +                    if (prefillActive) {  // content is the prefilled message
 -                                overriddenInstructPreset.output_suffix = '';
 +                        if (last_line.endsWith('\n') && !message.content.endsWith('\n')) {
 -                                overriddenInstructPreset.wrap = false;
 +                            last_line = last_line.slice(0, -1);  // remove newline after prefill if it's not in the prefill itself
 -                                messageContent = formatInstructModeChat(
 +                        }
 -                                    message.role,
 +                        messageContent = last_line;
 -                                    message.content,
 +                    } else {  // append last line to content (e.g. "<|im_start|>assistant:")
 -                                    false, // since it is assistant
 +                        messageContent += last_line;
 -                                    false,
 -                                    undefined,
 -                                    undefined,
 -                                    undefined,
 -                                    undefined,
 -                                    overriddenInstructPreset,
 -                                );
+                    }
+                }
+            }
             formattedMessages.push(messageContent);
+        }
                 requestData.prompt =        return formattedMessages.join('');
 +    }
++
++
 +    /**
 +     * Process and send a text completion request with optional preset & instruct
 +     * @param {TextCompletionPayload} requestData
 +     * @param {Object} options - Configuration options
 +     * @param {string?} [options.presetName] - Name of the preset to use for generation settings
 +     * @param {string?} [options.instructName] - Name of instruct preset for message formatting
 +     * @param {Partial<InstructSettings>?} [options.instructSettings] - Override instruct settings
 +     * @param {boolean} extractData - Whether to extract structured data from response
 +     * @param {AbortSignal?} [signal]
 +     * @returns {Promise<ExtractedData | (() => AsyncGenerator<StreamResponse>)>} If not streaming, returns extracted data; if streaming, returns a function that creates an AsyncGenerator
 +     * @throws {Error}
 +     */
 +    static async processRequest(requestData, options = {}, extractData = true, signal = null) {
 +        const { presetName, instructName } = options;
++
 +        // remove any undefined params in given request data
 +        requestData = this.createRequestData(requestData);
++
 +        /** @type {InstructSettings | undefined} */
 +        let instructPreset;
 +        const prompt = requestData.prompt;
 +        // Handle instruct formatting if requested
 +        if (Array.isArray(prompt)) {
 +            if (instructName) {
 +                const instructPresetManager = getPresetManager('instruct');
 +                instructPreset = instructPresetManager?.getCompletionPresetByName(instructName);
 +                if (instructPreset) {
 +                    requestData.prompt = this.constructPrompt(prompt, instructPreset, options.instructSettings);
                     const stoppingStrings = getInstructStoppingSequences({ customInstruct: instructPreset, useStopStrings: false });
                     requestData.stop = stoppingStrings;
                     requestData.stopping_strings = stoppingStrings;

                     console.warn(`Instruct preset "${instructName}" not found, using basic formatting`);
                     requestData.prompt = prompt.map(x => x.content).join('\n\n');
+                }
 +            } else {
 +                requestData.prompt = prompt.map(x => x.content).join('\n\n');
 +            }
         } else if (typeof prompt === 'string') {
             requestData.prompt = prompt;
 +        }
++
 +        // Apply generation preset if specified
 +        if (presetName) {
 +            const presetManager = getPresetManager(this.TYPE);
 +            if (presetManager) {
 +                const preset = presetManager.getCompletionPresetByName(presetName);
 +                if (preset) {
 +                    // Convert preset to payload and merge with custom data
 +                    requestData = this.presetToGeneratePayload(preset, {}, requestData);
                 } else {
 -            requestData.prompt = prompt.map(x => x.content).join('\n\n');
 +                    console.warn(`Preset "${presetName}" not found, continuing with default settings`);
 +                }
 +            } else {
 +                console.warn('Preset manager not found, continuing with default settings');
 +            }
+        }
 -        // @ts-ignore
 +        const response = await this.sendRequest(requestData, extractData, signal);
 -        const data = this.createRequestData(requestData);
 -        const response = await this.sendRequest(data, extractData, signal);
         // Remove stopping strings from the end
         if (!datarequestData.stream && extractData) {
             /** @type {ExtractedData} */
             // @ts-ignore
             const extractedData = response;

      * Converts a preset to a valid text completion payload.
      * Only supports temperature.
      * @param {Object} preset - The preset configuration
      * @param {Object} customPresetoverridePreset - Additional parameters to override preset values
 +     * @param {Object} overridePayload - Additional parameters to override payload values
      * @returns {Object} - Formatted payload for text completion API
      */
     static presetToGeneratePayload(preset, customPresetoverridePreset = {}, overridePayload = {}) {
         if (!preset || typeof preset !== 'object') {
             throw new Error('Invalid preset: must be an object');
+        }
         // Mergeapply preset with custom parametersoverrides
         const settingspreset = { ...preset, ...customPresetoverridePreset };
+-
 -        // Initialize base payload with common parameters
 -        let payload = {
 -            'temperature': settings.temp >= 0 ? Number(settings.temp) : undefined,
 -            'min_p': settings.min_p >= 0 ? Number(settings.min_p) : undefined,
 -        };
 -        // Remove undefined values to avoid API errors
 +        // Only take fields from the preset specified in setting_names to use as TextCompletionSettings
 -        Object.keys(payload).forEach(key => {
 +        const settings = structuredClone(textgenerationwebui_settings);
 -            if (payload[key] === undefined) {
 +        for (const [key, value] of Object.entries(preset)) {
 -                delete payload[key];
 +            if (!setting_names.includes(key)) continue;
 +            settings[key] = value;
+        }
 -        });
 -        return payload;
 +        // convert to a generation payload
 +        const payload = createTextGenGenerationData(settings, overridePayload.model, overridePayload.prompt, preset.genamt);
++
 +        // apply overrides
 +        return this.createRequestData({ ...payload, ...overridePayload });
+    }
+}

         if (!data.stream) {
             const json = await response.json();
             if (!response.ok || json.error) {
 -                throw json;
 +                throw new Error(String(json.error?.message || 'Response not OK'));
+            }
             if (!extractData) {

     /**
      * Process and send a chat completion request with optional preset
      * @param {ChatCompletionPayload} customrequestData - payload data, overriding preset if given
      * @param {Object} options - Configuration options
      * @param {string?} [options.presetName] - Name of the preset to use for generation settings
      * @param {boolean} [extractData=true] - Whether to extract structured data from response

      * @returns {Promise<ExtractedData | (() => AsyncGenerator<StreamResponse>)>} If not streaming, returns extracted data; if streaming, returns a function that creates an AsyncGenerator
      * @throws {Error}
      */
     static async processRequest(customrequestData, options, extractData = true, signal = null) {
         const { presetName } = options;
         let requestData = { ..this.custom }createRequestData(requestData);
         // Apply generation preset if specified
         if (presetName) {

                 const preset = presetManager.getCompletionPresetByName(presetName);
                 if (preset) {
                     // Convert preset to payload and merge with custom parameters
                     const presetPayloadrequestData = await this.presetToGeneratePayload(preset, {}, requestData);
 -                    requestData = { ...presetPayload, ...requestData };
                 } else {
                     console.warn(`Preset "${presetName}" not found, continuing with default settings`);
+                }

+            }
+        }
         const datareturn =await this.createRequestDatasendRequest(requestData, extractData, signal);
+-
 -        return await this.sendRequest(data, extractData, signal);
+    }
     /**
      * Converts a preset to a valid chat completion payload
      * Only supports temperature.
      * @param {Object} preset - The preset configuration
      * @param {Object} customParamsoverridePreset - Additional parameters to override preset values
      * @returnsparam {Object} overridePayload - FormattedAdditional payloadparameters forto chatoverride completionpayload APIvalues
 +     * @returns {Promise<any>} - Formatted payload for chat completion API
      */
     static async presetToGeneratePayload(preset, customParamsoverridePreset = {}, overridePayload = {}) {
         if (!preset || typeof preset !== 'object') {
             throw new Error('Invalid preset: must be an object');
+        }
         // Mergeapply preset with custom parametersoverrides
         const settingspreset = { ...preset, ...customParamsoverridePreset };
         // InitializeFix baseany payloadfields withbefore commonconverting parametersto settings
 -        const payload = {
 +        preset.bias_preset_selected = preset.bias_presets !== undefined ? preset.bias_preset_selected : undefined;  // presets might have bias_preset_selected but not bias_presets, but settings need both or neither.
 -            temperature: settings.temperature >= 0 ? Number(settings.temperature) : undefined,
 -        };
         // RemoveConvert undefinedfrom valuespreset to avoid API errorsChatCompletionSettings
 -        Object.keys(payload).forEach(key => {
 +        const settings = structuredClone(oai_settings);
 -            if (payload[key] === undefined) {
 +        for (const [key, value] of Object.entries(preset)) {
                 delete            const payloadsettingToUpdate = settingsToUpdate[key];
 +            if (!settingToUpdate) continue;
 +            settings[settingToUpdate[1]] = value;
+        }
 -        });
 -        return payload;
 +        // Convert from settings to generation payload
 +        const data = await createGenerationParameters(settings, overridePayload.model, 'quiet', overridePayload.messages);
 +        const payload = data.generate_data;
++
 +        // apply overrides
 +        return this.createRequestData({ ...payload, ...overridePayload });
+    }
+}

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

             throw new Error('Connection Manager is not available');
+        }
 -        const profile = context.extensionSettings.connectionManager.profiles.find((p) => p.id === profileId);
 +        const profile = this.getProfile(profileId);
         const selectedApiMap = this.validateProfile(profile);
         try {

+    }
     /**
 +    * If using text completion, return a formatted prompt string given an array of messages, a given profile ID, and optional instruct settings.
 +    * If using chat completion, simply return the given prompt as-is.
 +    * @param {ChatCompletionMessage[]} prompt An array of prompt messages.
 +    * @param {string} profileId ID of a given connection profile (from which to infer a completion preset).
 +    * @param {InstructSettings} instructSettings optional instruct settings
 +    */
 +    static constructPrompt(prompt, profileId, instructSettings = null) {
 +        const context = SillyTavern.getContext();
 +        const profile = this.getProfile(profileId);
 +        const selectedApiMap = this.validateProfile(profile);
 +        const instructName = profile.instruct;
++
 +        switch (selectedApiMap.selected) {
 +            case 'openai': {
 +                if (!selectedApiMap.source) {
 +                    throw new Error(`API type ${selectedApiMap.selected} does not support chat completions`);
 +                }
 +                return prompt;
 +            }
 +            case 'textgenerationwebui': {
 +                if (!selectedApiMap.type) {
 +                    throw new Error(`API type ${selectedApiMap.selected} does not support text completions`);
 +                }
 +                return context.TextCompletionService.constructPrompt(prompt, instructName, instructSettings);
 +            }
 +            default: {
 +                throw new Error(`Unknown API type ${selectedApiMap.selected}`);
 +            }
 +        }
 +    }
++
 +    /**
      * Respects allowed types.
      * @returns {import('./connection-manager/index.js').ConnectionProfile[]}
      */

+    }
     /**
 +     * Return profile data given the profile ID
 +     * @param {string} profileId
 +     * @returns {import('./connection-manager/index.js').ConnectionProfile?} [profile]
 +     * @throws {Error}
 +     */
 +    static getProfile(profileId) {
 +        const profile = SillyTavern.getContext().extensionSettings.connectionManager.profiles.find((p) => p.id === profileId);
 +        if (!profile) throw new Error(`Profile not found (ID: ${profileId})`);
 +        return profile;
 +    }
++
 +    /**
      * @param {import('./connection-manager/index.js').ConnectionProfile?} [profile]
      * @returns {boolean}
      */

public/scripts/openai.js+251 -200 Viewed

     getMediaDisplay,
     getMediaIndex,
     getRequestHeaders,
 -    getStoppingStrings,
     is_send_press,
     main_api,
     name1,

 /**
  * Gets the API model for the selected chat completion source.
  * @param {stringChatCompletionSettings} source If it's set,settings ignoresChat activecompletion sourcesettings
  * @returns {string} API model
  */
 export function getChatCompletionModel(sourcesettings = null) {
     const activeSourcesettings = sourcesettings ?? oai_settings.chat_completion_source;
 -    switch (activeSource) {
 +    const source = settings.chat_completion_source;
 +    switch (source) {
         case chat_completion_sources.CLAUDE:
             return oai_settingssettings.claude_model;
         case chat_completion_sources.OPENAI:
             return oai_settingssettings.openai_model;
         case chat_completion_sources.MAKERSUITE:
             return oai_settingssettings.google_model;
         case chat_completion_sources.VERTEXAI:
             return oai_settingssettings.vertexai_model;
         case chat_completion_sources.OPENROUTER:
             return oai_settingssettings.openrouter_model !== openrouter_website_model ? oai_settingssettings.openrouter_model : null;
         case chat_completion_sources.AI21:
             return oai_settingssettings.ai21_model;
         case chat_completion_sources.MISTRALAI:
             return oai_settingssettings.mistralai_model;
         case chat_completion_sources.CUSTOM:
             return oai_settingssettings.custom_model;
         case chat_completion_sources.COHERE:
             return oai_settingssettings.cohere_model;
         case chat_completion_sources.PERPLEXITY:
             return oai_settingssettings.perplexity_model;
         case chat_completion_sources.GROQ:
             return oai_settingssettings.groq_model;
         case chat_completion_sources.SILICONFLOW:
             return oai_settingssettings.siliconflow_model;
         case chat_completion_sources.ELECTRONHUB:
             return oai_settingssettings.electronhub_model;
         case chat_completion_sources.CHUTES:
             return oai_settingssettings.chutes_model;
         case chat_completion_sources.NANOGPT:
             return oai_settingssettings.nanogpt_model;
         case chat_completion_sources.DEEPSEEK:
             return oai_settingssettings.deepseek_model;
         case chat_completion_sources.AIMLAPI:
             return oai_settingssettings.aimlapi_model;
         case chat_completion_sources.XAI:
             return oai_settingssettings.xai_model;
         case chat_completion_sources.POLLINATIONS:
             return oai_settingssettings.pollinations_model;
         case chat_completion_sources.COMETAPI:
             return oai_settingssettings.cometapi_model;
         case chat_completion_sources.MOONSHOT:
             return oai_settingssettings.moonshot_model;
         case chat_completion_sources.FIREWORKS:
             return oai_settingssettings.fireworks_model;
         case chat_completion_sources.AZURE_OPENAI:
             return oai_settingssettings.azure_openai_model;
         case chat_completion_sources.ZAI:
             return oai_settingssettings.zai_model;
         default:
             console.error(`Unknown chat completion source: ${activeSourcesource}`);
             return '';
+    }
+}

     `));
+}
 -function getReasoningEffort() {
 +/**
 + * Get the reasoning effort from chat completion settings
 + * @param {ChatCompletionSettings} settings Chat completion settings
 + * @param {string} model Model name (optional, used for ElectronHub)
 + * @returns {string} Reasoning effort, if present
 + */
 +function getReasoningEffort(settings = null, model = null) {
 +    settings = settings ?? oai_settings;
 +    model = model ?? getChatCompletionModel(settings);
++
     // These sources expect the effort as string.
     const reasoningEffortSources = [
         chat_completion_sources.OPENAI,

         chat_completion_sources.CHUTES,
     ];
     if (!reasoningEffortSources.includes(oai_settingssettings.chat_completion_source)) {
         return oai_settingssettings.reasoning_effort;
+    }
     function resolveReasoningEffort() {
         switch (oai_settingssettings.reasoning_effort) {
             case reasoning_effort_types.auto:
                 return undefined;
             case reasoning_effort_types.min:
                 return [chat_completion_sources.OPENAI, chat_completion_sources.AZURE_OPENAI].includes(oai_settingssettings.chat_completion_source) && /^gpt-5/.test(getChatCompletionModel()model)
                     ? reasoning_effort_types.min
                     : reasoning_effort_types.low;
             case reasoning_effort_types.max:
                 return reasoning_effort_types.high;
             default:
                 return oai_settingssettings.reasoning_effort;
+        }
+    }
     const reasoningEffort = resolveReasoningEffort();
     // Check if the resolved effort supported by the model
     if (oai_settingssettings.chat_completion_source === chat_completion_sources.ELECTRONHUB) {
         if (Array.isArray(model_list) && reasoningEffort) {
             const currentModel = model_list.find(m => m.id === oai_settings.electronhub_modelmodel);
             const supportedEfforts = currentModel?.metadata?.supported_reasoning_efforts;
             if (Array.isArray(supportedEfforts) && supportedEfforts.includes(reasoningEffort)) {
                 return reasoningEffort;

     return reasoningEffort;
+}
 -function getVerbosity() {
 +/**
 -    if (oai_settings.verbosity === verbosity_levels.auto) {
 + * Get the verbosity from chat completion settings
 + * @param {ChatCompletionSettings} settings Chat completion settings
 + * @returns {string} Verbosity level, if present
 + */
 +function getVerbosity(settings = null) {
 +    settings = settings ?? oai_settings;
++
 +    if (settings.verbosity === verbosity_levels.auto) {
         return undefined;
+    }
     // TODO: Adjust verbosity based on model capabilities
     return oai_settingssettings.verbosity;
+}
 /**
 - * Send a chat completion request to backend
 + * Build the generation parameter object for an OAI request.
  * @param {stringChatCompletionSettings} typesettings (impersonate,Initial quiet,chat continue,completion etc)settings
  * @param {Arraystring} messagesmodel Model name
 - * @param {AbortSignal?} signal
 + * @param {string} type Request type (impersonate, quiet, continue, etc)
 - * @param {import('../script.js').AdditionalRequestOptions} options
 + * @param {ChatCompletionMessage[]} messages Array of chat completion messages
 - * @returns {Promise<unknown>}
 + * @param {import('../script.js').AdditionalRequestOptions} options Additional request options
 - * @throws {Error}
 + * @returns {Promise<object>} Final generation parameters object appropriate for the chat completion source
  */
+-
 +export async function createGenerationParameters(settings, model, type, messages, { jsonSchema = null } = {}) {
 -async function sendOpenAIRequest(type, messages, signal, { jsonSchema = null } = {}) {
 -    // Provide default abort signal
 -    if (!signal) {
 -        signal = new AbortController().signal;
 -    }
+-
     // HACK: Filter out null and non-object messages
     if (!Array.isArray(messages)) {
         throw new Error('messages must be an array');
+    }
+-
     messages = messages.filter(msg => msg && typeof msg === 'object');
 -    let logit_bias = {};
 +    // "OpenAI-like" sources
 -    const isClaude = oai_settings.chat_completion_source == chat_completion_sources.CLAUDE;
 +    const gptSources = [
 -    const isOpenRouter = oai_settings.chat_completion_source == chat_completion_sources.OPENROUTER;
 +        chat_completion_sources.OPENAI,
 -    const isGoogle = oai_settings.chat_completion_source == chat_completion_sources.MAKERSUITE;
 +        chat_completion_sources.AZURE_OPENAI,
 -    const isVertexAI = oai_settings.chat_completion_source == chat_completion_sources.VERTEXAI;
 +        chat_completion_sources.OPENROUTER,
 -    const isOAI = oai_settings.chat_completion_source == chat_completion_sources.OPENAI;
 +    ];
 -    const isMistral = oai_settings.chat_completion_source == chat_completion_sources.MISTRALAI;
++
 -    const isCustom = oai_settings.chat_completion_source == chat_completion_sources.CUSTOM;
 +    // Sources that support the "seed" parameter
 -    const isCohere = oai_settings.chat_completion_source == chat_completion_sources.COHERE;
 +    const seedSupportedSources = [
 -    const isPerplexity = oai_settings.chat_completion_source == chat_completion_sources.PERPLEXITY;
 +        chat_completion_sources.OPENAI,
 -    const isGroq = oai_settings.chat_completion_source == chat_completion_sources.GROQ;
 +        chat_completion_sources.AZURE_OPENAI,
 -    const isDeepSeek = oai_settings.chat_completion_source == chat_completion_sources.DEEPSEEK;
 +        chat_completion_sources.OPENROUTER,
 -    const isAimlapi = oai_settings.chat_completion_source == chat_completion_sources.AIMLAPI;
 +        chat_completion_sources.MISTRALAI,
 -    const isElectronHub = oai_settings.chat_completion_source == chat_completion_sources.ELECTRONHUB;
 +        chat_completion_sources.CUSTOM,
 -    const isChutes = oai_settings.chat_completion_source == chat_completion_sources.CHUTES;
 +        chat_completion_sources.COHERE,
 -    const isXAI = oai_settings.chat_completion_source == chat_completion_sources.XAI;
 +        chat_completion_sources.GROQ,
 -    const isPollinations = oai_settings.chat_completion_source == chat_completion_sources.POLLINATIONS;
 +        chat_completion_sources.ELECTRONHUB,
 -    const isMoonshot = oai_settings.chat_completion_source == chat_completion_sources.MOONSHOT;
 +        chat_completion_sources.NANOGPT,
 -    const isAzureOpenAI = oai_settings.chat_completion_source == chat_completion_sources.AZURE_OPENAI;
 +        chat_completion_sources.XAI,
 -    const isZai = oai_settings.chat_completion_source == chat_completion_sources.ZAI;
 +        chat_completion_sources.POLLINATIONS,
 -    const isNanoGPT = oai_settings.chat_completion_source == chat_completion_sources.NANOGPT;
 +        chat_completion_sources.AIMLAPI,
 -    const isTextCompletion = isOAI && textCompletionModels.includes(oai_settings.openai_model);
 +        chat_completion_sources.VERTEXAI,
 -    const isQuiet = type === 'quiet';
 +        chat_completion_sources.MAKERSUITE,
 -    const isImpersonate = type === 'impersonate';
 +        chat_completion_sources.CHUTES,
 -    const isContinue = type === 'continue';
 +    ];
 -    const stream = oai_settings.stream_openai && !isQuiet && !((isOAI || isAzureOpenAI) && ['o1-2024-12-17', 'o1'].includes(getChatCompletionModel()));
++
 -    const useLogprobs = !!power_user.request_token_probabilities;
 +    // Sources that support proxying
 -    const canMultiSwipe = oai_settings.n > 1 && !isContinue && !isImpersonate && !isQuiet && (isOAI || isAzureOpenAI || isCustom || isXAI || isAimlapi || isMoonshot);
 +    const proxySupportedSources = [
 +        chat_completion_sources.CLAUDE,
 +        chat_completion_sources.OPENAI,
 +        chat_completion_sources.MISTRALAI,
 +        chat_completion_sources.MAKERSUITE,
 +        chat_completion_sources.VERTEXAI,
 +        chat_completion_sources.DEEPSEEK,
 +        chat_completion_sources.XAI,
 +    ];
++
 +    // Sources that support logprobs
 +    const logprobsSupportedSources = [
 +        chat_completion_sources.OPENAI,
 +        chat_completion_sources.AZURE_OPENAI,
 +        chat_completion_sources.CUSTOM,
 +        chat_completion_sources.DEEPSEEK,
 +        chat_completion_sources.XAI,
 +        chat_completion_sources.AIMLAPI,
 +        chat_completion_sources.CHUTES,
 +    ];
++
 +    // Sources that support logit bias
 +    const logitBiasSources = [
 +        chat_completion_sources.OPENAI,
 +        chat_completion_sources.AZURE_OPENAI,
 +        chat_completion_sources.OPENROUTER,
 +        chat_completion_sources.ELECTRONHUB,
 +        chat_completion_sources.CHUTES,
 +        chat_completion_sources.CUSTOM,
 +    ];
++
 +    // Sources that support "n" parameter for multi-swipe
 +    const multiswipeSources = [
 +        chat_completion_sources.OPENAI,
 +        chat_completion_sources.AZURE_OPENAI,
 +        chat_completion_sources.CUSTOM,
 +        chat_completion_sources.XAI,
 +        chat_completion_sources.AIMLAPI,
 +        chat_completion_sources.MOONSHOT,
 +    ];
++
 +    const isO1 = gptSources.includes(settings.chat_completion_source) && ['o1-2024-12-17', 'o1'].includes(model);
 +    const stream = settings.stream_openai && type !== 'quiet' && !isO1;
++
 +    const noMultiSwipeTypes = ['quiet', 'impersonate', 'continue'];
 +    const canMultiSwipe = settings.n > 1 && !noMultiSwipeTypes.includes(type) && multiswipeSources.includes(settings.chat_completion_source);
 -    const logitBiasSources = [chat_completion_sources.OPENAI, chat_completion_sources.AZURE_OPENAI, chat_completion_sources.OPENROUTER, chat_completion_sources.ELECTRONHUB, chat_completion_sources.CHUTES, chat_completion_sources.CUSTOM];
 +    let logit_bias = {};
     if (oai_settingssettings.bias_preset_selected
         && logitBiasSources.includes(oai_settingssettings.chat_completion_source)
         && Array.isArray(oai_settingssettings.bias_presets[oai_settingssettings.bias_preset_selected])
         && oai_settingssettings.bias_presets[oai_settingssettings.bias_preset_selected].length) {
         logit_bias = biasCache || await calculateLogitBias();
         biasCache = logit_bias;
+    }

         logit_bias = undefined;
+    }
 -    const model = getChatCompletionModel();
     const generate_data = {
         'type': type,
         'messages': messages,
         'model': model,
         'temperature': Number(oai_settingssettings.temp_openai),
         'frequency_penalty': Number(oai_settingssettings.freq_pen_openai),
         'presence_penalty': Number(oai_settingssettings.pres_pen_openai),
         'top_p': Number(oai_settingssettings.top_p_openai),
         'max_tokens': oai_settingssettings.openai_max_tokens,
         'stream': stream,
         'logit_bias': logit_bias,
         'stop': getCustomStoppingStrings(openai_max_stop_strings),
         'chat_completion_source': oai_settingssettings.chat_completion_source,
         'n': canMultiSwipe ? oai_settingssettings.n : undefined,
         'user_name': name1,
         'char_name': name2,
         'group_names': getGroupNames(),
         'include_reasoning': Boolean(oai_settingssettings.show_thoughts),
         'reasoning_effort': getReasoningEffort(settings, model),
         'enable_web_search': Boolean(oai_settingssettings.enable_web_search),
         'request_images': Boolean(oai_settingssettings.request_images),
         'request_image_resolution': String(oai_settingssettings.request_image_resolution),
         'request_image_aspect_ratio': String(oai_settingssettings.request_image_aspect_ratio),
         'custom_prompt_post_processing': oai_settingssettings.custom_prompt_post_processing,
         'verbosity': getVerbosity(settings),
     };
     if (isAzureOpenAIsettings.chat_completion_source === chat_completion_sources.AZURE_OPENAI) {
         generate_data.azure_base_url = oai_settingssettings.azure_base_url;
         generate_data.azure_deployment_name = oai_settingssettings.azure_deployment_name;
         generate_data.azure_api_version = oai_settingssettings.azure_api_version;
         // Reasoning effort is not supported on some Azure models (e.g. GPT-3.x, GPT-4.x)
         if (/^gpt-[34]/.test(oai_settings.azure_openai_modelmodel)) {
             delete generate_data.reasoning_effort;
+        }
+    }
     if (!canMultiSwipe && ToolManager.canPerformToolCalls(type, settings, model)) {
         await ToolManager.registerFunctionToolsOpenAI(generate_data);
+    }

         delete generate_data.stop;
+    }
 -    // Proxy is only supported for Claude, OpenAI, Mistral, Google MakerSuite, and Vertex AI
 +    if (settings.reverse_proxy && proxySupportedSources.includes(settings.chat_completion_source)) {
 -    if (oai_settings.reverse_proxy && [chat_completion_sources.CLAUDE, chat_completion_sources.OPENAI, chat_completion_sources.MISTRALAI, chat_completion_sources.MAKERSUITE, chat_completion_sources.VERTEXAI, chat_completion_sources.DEEPSEEK, chat_completion_sources.XAI].includes(oai_settings.chat_completion_source)) {
         await validateReverseProxy();
         generate_data['reverse_proxy'] = oai_settingssettings.reverse_proxy;
         generate_data['proxy_password'] = oai_settingssettings.proxy_password;
+    }
     // Add logprobs request (currently OpenAI only, max 5 onper theirOpenAI sidedocs)
 -    if (useLogprobs && (isOAI || isAzureOpenAI || isCustom || isDeepSeek || isXAI || isAimlapi || isChutes)) {
 +    const useLogprobs = !!power_user.request_token_probabilities;
 +    if (useLogprobs && logprobsSupportedSources.includes(settings.chat_completion_source)) {
         generate_data['logprobs'] = 5;
+    }
     // Remove logit bias/logprobs/stop-strings if not supported by the model
     const isVision = (m) => ['gpt', 'vision'].every(x => m.includes(x));
 -    if ((isOAI && isVision(oai_settings.openai_model)) || (isAzureOpenAI && isVision(oai_settings.azure_openai_model)) || (isOpenRouter && isVision(oai_settings.openrouter_model))) {
 +    if (gptSources.includes(settings.chat_completion_source) && isVision(model)) {
         delete generate_data.logit_bias;
         delete generate_data.stop;
         delete generate_data.logprobs;
+    }
 -    if ((isOAI && oai_settings.openai_model.includes('gpt-4.5')) || (isAzureOpenAI && oai_settings.azure_openai_model.includes('gpt-4.5')) || (isOpenRouter && oai_settings.openrouter_model.includes('gpt-4.5'))) {
 +    if (gptSources.includes(settings.chat_completion_source) && model.includes('gpt-4.5')) {
         delete generate_data.logprobs;
+    }
     if (isClaudesettings.chat_completion_source === chat_completion_sources.CLAUDE) {
         generate_data['top_k'] = Number(oai_settingssettings.top_k_openai);
         generate_data['use_sysprompt'] = oai_settingssettings.use_sysprompt;
         generate_data['stop'] = getCustomStoppingStrings(); // Claude shouldn't have limits on stop strings.
         // Don't add a prefill on quiet gens (summarization) and when using continue prefill.
         if (type !isQuiet== 'quiet' && !(isContinuetype === 'continue' && oai_settingssettings.continue_prefill)) {
 -            generate_data['assistant_prefill'] = isImpersonate ? substituteParams(oai_settings.assistant_impersonation) : substituteParams(oai_settings.assistant_prefill);
 +            generate_data['assistant_prefill'] = type === 'impersonate'
 +                ? substituteParams(settings.assistant_impersonation)
 +                : substituteParams(settings.assistant_prefill);
+        }
+    }
     if (isOpenRoutersettings.chat_completion_source === chat_completion_sources.OPENROUTER) {
         generate_data['top_k'] = Number(oai_settingssettings.top_k_openai);
         generate_data['min_p'] = Number(oai_settingssettings.min_p_openai);
         generate_data['repetition_penalty'] = Number(oai_settingssettings.repetition_penalty_openai);
         generate_data['top_a'] = Number(oai_settingssettings.top_a_openai);
         generate_data['use_fallback'] = oai_settingssettings.openrouter_use_fallback;
         generate_data['provider'] = oai_settingssettings.openrouter_providers;
         generate_data['allow_fallbacks'] = oai_settingssettings.openrouter_allow_fallbacks;
         generate_data['middleout'] = oai_settingssettings.openrouter_middleout;
+-
 -        if (isTextCompletion) {
 -            generate_data['stop'] = getStoppingStrings(isImpersonate, isContinue);
 -        }
+    }
 -    if (isGoogle || isVertexAI) {
 +    if ([chat_completion_sources.MAKERSUITE, chat_completion_sources.VERTEXAI].includes(settings.chat_completion_source)) {
         const stopStringsLimit = 5;
         generate_data['top_k'] = Number(oai_settingssettings.top_k_openai);
         generate_data['stop'] = getCustomStoppingStrings(stopStringsLimit).slice(0, stopStringsLimit).filter(x => x.length >= 1 && x.length <= 16);
         generate_data['use_sysprompt'] = oai_settingssettings.use_sysprompt;
         if (isVertexAIsettings.chat_completion_source === chat_completion_sources.VERTEXAI) {
             generate_data['vertexai_auth_mode'] = oai_settingssettings.vertexai_auth_mode;
             generate_data['vertexai_region'] = oai_settingssettings.vertexai_region;
             generate_data['vertexai_express_project_id'] = oai_settingssettings.vertexai_express_project_id;
+        }
+    }
     if (isMistralsettings.chat_completion_source === chat_completion_sources.MISTRALAI) {
         generate_data['safe_prompt'] = false; // already defaults to false, but just incase they change that in the future.
         generate_data['stop'] = getCustomStoppingStrings(); // Mistral shouldn't have limits on stop strings.
+    }
     if (isCustomsettings.chat_completion_source === chat_completion_sources.CUSTOM) {
         generate_data['custom_url'] = oai_settingssettings.custom_url;
         generate_data['custom_include_body'] = oai_settingssettings.custom_include_body;
         generate_data['custom_exclude_body'] = oai_settingssettings.custom_exclude_body;
         generate_data['custom_include_headers'] = oai_settingssettings.custom_include_headers;
+    }
     if (isCoheresettings.chat_completion_source === chat_completion_sources.COHERE) {
         // Clamp to 0.01 -> 0.99
         generate_data['top_p'] = Math.min(Math.max(Number(oai_settingssettings.top_p_openai), 0.01), 0.99);
         generate_data['top_k'] = Number(oai_settingssettings.top_k_openai);
         // Clamp to 0 -> 1
         generate_data['frequency_penalty'] = Math.min(Math.max(Number(oai_settingssettings.freq_pen_openai), 0), 1);
         generate_data['presence_penalty'] = Math.min(Math.max(Number(oai_settingssettings.pres_pen_openai), 0), 1);
         generate_data['stop'] = getCustomStoppingStrings(5);
+    }
     if (isPerplexitysettings.chat_completion_source === chat_completion_sources.PERPLEXITY) {
         generate_data['top_k'] = Number(oai_settingssettings.top_k_openai);
         generate_data['frequency_penalty'] = Number(oai_settingssettings.freq_pen_openai);
         generate_data['presence_penalty'] = Number(oai_settingssettings.pres_pen_openai);
+-
 -        // YEAH BRO JUST USE OPENAI CLIENT BRO
         delete generate_data['stop'];
+    }
     // https://console.groq.com/docs/openai
     if (isGroqsettings.chat_completion_source === chat_completion_sources.GROQ) {
         delete generate_data.logprobs;
         delete generate_data.logit_bias;
         delete generate_data.top_logprobs;

+    }
     // https://api-docs.deepseek.com/api/create-chat-completion
     if (isDeepSeeksettings.chat_completion_source === chat_completion_sources.DEEPSEEK) {
         generate_data.top_p = generate_data.top_p || Number.EPSILON;
+    }
     if (isXAIsettings.chat_completion_source === chat_completion_sources.XAI) {
 -        const model = generate_data.model;
         if (model.includes('grok-3-mini')) {
             delete generate_data.presence_penalty;
             delete generate_data.frequency_penalty;

+        }
+    }
     if (isPollinationssettings.chat_completion_source === chat_completion_sources.POLLINATIONS) {
         delete generate_data.max_tokens;
+    }
     // https://docs.electronhub.ai/api-reference/chat/completions
     if (isElectronHubsettings.chat_completion_source === chat_completion_sources.ELECTRONHUB) {
         generate_data['top_k'] = Number(oai_settingssettings.top_k_openai);
+    }
     if (isChutessettings.chat_completion_source === chat_completion_sources.CHUTES) {
         generate_data['min_p'] = Number(oai_settingssettings.min_p_openai);
         generate_data['top_k'] = oai_settingssettings.top_k_openai > 0 ? Number(oai_settingssettings.top_k_openai) : undefined;
         generate_data['repetition_penalty'] = Number(oai_settingssettings.repetition_penalty_openai);
 -        generate_data['seed'] = oai_settings.seed >= 0 ? oai_settings.seed : undefined;
         generate_data['stop'] = getCustomStoppingStrings();
+    }
     // https://docs.z.ai/api-reference/llm/chat-completion
     if (isZaisettings.chat_completion_source === chat_completion_sources.ZAI) {
         generate_data['top_p'] = generate_data.top_p || 0.01;
         generate_data['stop'] = getCustomStoppingStrings(1);
         generate_data['zai_endpoint'] = oai_settingssettings.zai_endpoint || ZAI_ENDPOINT.COMMON;
         delete generate_data.presence_penalty;
         delete generate_data.frequency_penalty;
+    }
     // https://docs.nano-gpt.com/api-reference/endpoint/chat-completion#temperature-&-nucleus
     if (isNanoGPTsettings.chat_completion_source === chat_completion_sources.NANOGPT) {
         generate_data['top_k'] = Number(oai_settingssettings.top_k_openai);
         generate_data['min_p'] = Number(oai_settingssettings.min_p_openai);
         generate_data['repetition_penalty'] = Number(oai_settingssettings.repetition_penalty_openai);
         generate_data['top_a'] = Number(oai_settingssettings.top_a_openai);
+    }
 -    const seedSupportedSources = [
 +    if (seedSupportedSources.includes(settings.chat_completion_source) && settings.seed >= 0) {
 -        chat_completion_sources.OPENAI,
 +        generate_data['seed'] = settings.seed;
 -        chat_completion_sources.AZURE_OPENAI,
 -        chat_completion_sources.OPENROUTER,
 -        chat_completion_sources.MISTRALAI,
 -        chat_completion_sources.CUSTOM,
 -        chat_completion_sources.COHERE,
 -        chat_completion_sources.GROQ,
 -        chat_completion_sources.ELECTRONHUB,
 -        chat_completion_sources.NANOGPT,
 -        chat_completion_sources.XAI,
 -        chat_completion_sources.POLLINATIONS,
 -        chat_completion_sources.AIMLAPI,
 -        chat_completion_sources.VERTEXAI,
 -        chat_completion_sources.MAKERSUITE,
 -    ];
 -    if (seedSupportedSources.includes(oai_settings.chat_completion_source) && oai_settings.seed >= 0) {
 -        generate_data['seed'] = oai_settings.seed;
+    }
     if ((isOAI && /^(o1|o3|o4)/gptSources.testincludes(model)settings.chat_completion_source) || (isAzureOpenAI && /^(o1|o3|o4)/.test(model))) {
         generate_data.max_completion_tokens = generate_data.max_tokens;
         delete generate_data.max_tokens;
         delete generate_data.logprobs;

@@ -2676,7 +2707,7 @@ async function sendOpenAIRequest(type, messages, signal, { jsonSchema = null } =
2676	2707	}
2677	2708	}
2678	2709
2679	2710	if ((isOAI && /^gpt-5/gptSources.testincludes(model)settings.chat_completion_source) \|\| (isAzureOpenAI && /^gpt-5/.test(model))) {
2680	2711	generate_data.max_completion_tokens = generate_data.max_tokens;
2681	2712	delete generate_data.max_tokens;
2682	2713	delete generate_data.logprobs;

         generate_data.json_schema = jsonSchema;
+    }
 +    return { generate_data, stream, canMultiSwipe };
 +}
++
 +/**
 + * Send a chat completion request to backend
 + * @param {string} type Request type (impersonate, quiet, continue, etc)
 + * @param {ChatCompletionMessage[]} messages Array of chat completion messages
 + * @param {AbortSignal?} signal Abort signal for request cancellation
 + * @param {import('../script.js').AdditionalRequestOptions} options Additional request options
 + * @returns {Promise<unknown>}
 + * @throws {Error}
 + */
 +async function sendOpenAIRequest(type, messages, signal, { jsonSchema = null } = {}) {
 +    // Provide default abort signal
 +    if (!signal) {
 +        signal = new AbortController().signal;
 +    }
++
 +    const model = getChatCompletionModel(oai_settings);
 +    const { generate_data, stream, canMultiSwipe } = await createGenerationParameters(oai_settings, model, type, messages, { jsonSchema });
     await eventSource.emit(event_types.CHAT_COMPLETION_SETTINGS_READY, generate_data);
     const generate_url = '/api/backends/chat-completions/generate';

public/scripts/reasoning.js+19 -4 Viewed

+}
 /**
 - * Parses reasoning from a string using the power user reasoning settings.
 + * Returns the reasoning template object from its name
 + * @param {string} name of the template
 + * @returns {ReasoningTemplate} the reasoning template object
 + * @throws {Error}
 + */
 +export function getReasoningTemplateByName(name) {
 +    const template = reasoning_templates.find(p => p.name === name);
 +    if (!template) throw new Error(`Unknown reasoning template name: "${name}"`);
 +    return template;
 +}
++
 +/**
 + * Parses reasoning from a string using the power user reasoning settings or optional template.
  * @typedef {Object} ParsedReasoning
  * @property {string} reasoning Reasoning block
  * @property {string} content Message content
  * @param {string} str Content of the message
  * @param {Object} options Optional arguments
  * @param {boolean} [options.strict=true] Whether the reasoning block **has** to be at the beginning of the provided string (excluding whitespaces), or can be anywhere in it
 + * @param {ReasoningTemplate} template Optional reasoning template to use instead of power_user.reasoning
  * @returns {ParsedReasoning|null} Parsed reasoning block and message content
  */
 export function parseReasoningFromString(str, { strict = true } = {}, template = null) {
 +    template = template ?? power_user.reasoning;  // if no template given, use the currently selected template
++
     // Both prefix and suffix must be defined
     if (!power_user.reasoningtemplate.prefix || !power_user.reasoningtemplate.suffix) {
         return null;
+    }
     try {
         const regex = new RegExp(`${(strict ? '^\\s*?' : '')}${escapeRegex(power_user.reasoningtemplate.prefix)}(.*?)${escapeRegex(power_user.reasoningtemplate.suffix)}`, 's');
         let didReplace = false;
         let reasoning = '';

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

 import { convertCharacterBook, getWorldInfoPrompt, loadWorldInfo, reloadEditor, saveWorldInfo, updateWorldInfoList } from './world-info.js';
 import { ChatCompletionService, TextCompletionService } from './custom-request.js';
 import { ConnectionManagerRequestService } from './extensions/shared.js';
 import { updateReasoningUI, parseReasoningFromString, getReasoningTemplateByName } from './reasoning.js';
 import { IGNORE_SYMBOL } from './constants.js';
 export function getContext() {

         ConnectionManagerRequestService,
         updateReasoningUI,
         parseReasoningFromString,
 +        getReasoningTemplateByName,
         unshallowCharacter,
         unshallowGroupMembers,
         openThirdPartyExtensionMenu,

public/scripts/textgen-settings.js+147 -111 Viewed

 };
 const KOBOLDCPP_ORDER = [6, 0, 1, 3, 4, 2, 5];
 export const settingstextgenerationwebui_settings = {
     temp: 0.7,
     temperature_last: true,
     top_p: 0.5,

 };
 export {
 -    settings as textgenerationwebui_settings,
     showSamplerControls as showTGSamplerControls,
 };

 const DYNATEMP_BLOCK = document.getElementById('dynatemp_block_ooba');
 export function validateTextGenUrl() {
     const selector = SERVER_INPUTS[settingstextgenerationwebui_settings.type];
     if (!selector) {
         return;

  * @returns {string} API URL
  */
 export function getTextGenServer(type = null) {
     const selectedType = type ?? settingstextgenerationwebui_settings.type;
     switch (selectedType) {
         case FEATHERLESS:
             return FEATHERLESS_SERVER;

@@ -357,7 +356,7 @@ export function getTextGenServer(type = null) {
357	356	case OPENROUTER:
358	357	return OPENROUTER_SERVER;
359	358	default:
360	359	return settingstextgenerationwebui_settings.server_urls[selectedType] ?? '';
361	360	}
362	361	}
363	362

         return;
+    }
     settingstextgenerationwebui_settings.preset = name;
     for (const name of setting_names) {
         const value = preset[name];
         setSettingByName(name, value, true);

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

@@ -399,7 +398,7 @@ function convertPresets(presets) {
399	398	}
400	399
401	400	function getTokenizerForTokenIds() {
402	401	if (power_user.tokenizer === tokenizers.API_CURRENT && TEXTGEN_TOKENIZERS.includes(settingstextgenerationwebui_settings.type)) {
403	402	return tokenizers.API_CURRENT;
404	403	}
405	404

@@ -407,11 +406,11 @@ function getTokenizerForTokenIds() {
407	406	return power_user.tokenizer;
408	407	}
409	408
410	409	if (settingstextgenerationwebui_settings.type === OPENROUTER) {
411	410	return getCurrentOpenRouterModelTokenizer();
412	411	}
413	412
414	413	if (settingstextgenerationwebui_settings.type === DREAMGEN) {
415	414	return getCurrentDreamGenModelTokenizer();
416	415	}
417	416

+}
 /**
 + * Gets the custom token bans from settings and macros.
 + * @param {TextCompletionSettings} settings Text completion settings to use
  * @typedef {{banned_tokens: string, banned_strings: string[]}} TokenBanResult
  * @returns {TokenBanResult} String with comma-separated banned token IDs
  */
 function getCustomTokenBans(settings = null) {
 +    settings = settings ?? textgenerationwebui_settings;
     if (!settings.send_banned_tokens || (!settings.banned_tokens && !settings.global_banned_tokens && !textgenerationwebui_banned_in_macros.length)) {
         return {
             banned_tokens: '',

 function toggleBannedStringsKillSwitch(isEnabled, title) {
     $('#send_banned_tokens_textgenerationwebui').prop('checked', isEnabled);
     $('#send_banned_tokens_label').find('.menu_button').toggleClass('toggleEnabled', isEnabled).prop('title', title);
     settingstextgenerationwebui_settings.send_banned_tokens = isEnabled;
     saveSettingsDebounced();
+}
 /**
  * Calculates logit bias object from the logit bias list.
 + * @param {TextCompletionSettings} settings Text completion settings
  * @returns {object} Logit bias object
  */
 function calculateLogitBias(settings = null) {
 +    settings = settings ?? textgenerationwebui_settings;
++
     if (!Array.isArray(settings.logit_bias) || settings.logit_bias.length === 0) {
         return {};
+    }

     await loadApiSelectedSamplers();
     textgenerationwebui_presets = convertPresets(data.textgenerationwebui_presets);
     textgenerationwebui_preset_names = data.textgenerationwebui_preset_names ?? [];
     Object.assign(settingstextgenerationwebui_settings, loadedSettings.textgenerationwebui_settings ?? {});
     if (loadedSettings.api_server_textgenerationwebui) {
         for (const type of Object.keys(SERVER_INPUTS)) {
             settingstextgenerationwebui_settings.server_urls[type] = loadedSettings.api_server_textgenerationwebui;
+        }
         delete loadedSettings.api_server_textgenerationwebui;
+    }
     for (const [type, selector] of Object.entries(SERVER_INPUTS)) {
         const control = $(selector);
         control.val(settingstextgenerationwebui_settings.server_urls[type] ?? '').on('input', function () {
             settingstextgenerationwebui_settings.server_urls[type] = String($(this).val()).trim();
             saveSettingsDebounced();
         });
+    }
     if (loadedSettings.api_use_mancer_webui) {
         settingstextgenerationwebui_settings.type = MANCER;
+    }
     for (const name of textgenerationwebui_preset_names) {

         $('#settings_preset_textgenerationwebui').append(option);
+    }
     if (settingstextgenerationwebui_settings.preset) {
         $('#settings_preset_textgenerationwebui').val(settingstextgenerationwebui_settings.preset);
+    }
     for (const i of setting_names) {
         const value = settingstextgenerationwebui_settings[i];
         setSettingByName(i, value);
+    }
     $('#textgen_type').val(settingstextgenerationwebui_settings.type);
     $('#openrouter_providers_text').val(settingstextgenerationwebui_settings.openrouter_providers).trigger('change');
     showSamplerControls(settingstextgenerationwebui_settings.type);
     BIAS_CACHE.delete(BIAS_KEY);
     displayLogitBias(settingstextgenerationwebui_settings.logit_bias, BIAS_KEY);
     registerDebugFunction('change-mancer-url', 'Change Mancer base URL', 'Change Mancer API server base URL', () => {
         const result = prompt(`Enter Mancer base URL\nDefault: ${MANCER_SERVER_DEFAULT}`, MANCER_SERVER);

@@ -648,7 +653,7 @@ async function getStatusTextgen() {
648	653	return resultCheckStatus();
649	654	}
650	655
651	656	if ([textgen_types.GENERIC, textgen_types.OOBA].includes(settingstextgenerationwebui_settings.type) && settingstextgenerationwebui_settings.bypass_status_check) {
652	657	setOnlineStatus(t`Status check bypassed`);
653	658	return resultCheckStatus();
654	659	}

             headers: getRequestHeaders(),
             body: JSON.stringify({
                 api_server: endpoint,
                 api_type: settingstextgenerationwebui_settings.type,
             }),
             signal: abortStatusCheck.signal,
         });
         const data = await response.json();
         if (settingstextgenerationwebui_settings.type === textgen_types.MANCER) {
             loadMancerModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.mancer_model);
         } else if (settingstextgenerationwebui_settings.type === textgen_types.TOGETHERAI) {
             loadTogetherAIModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.togetherai_model);
         } else if (settingstextgenerationwebui_settings.type === textgen_types.OLLAMA) {
             loadOllamaModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.ollama_model || t`Connected`);
         } else if (settingstextgenerationwebui_settings.type === textgen_types.INFERMATICAI) {
             loadInfermaticAIModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.infermaticai_model);
         } else if (settingstextgenerationwebui_settings.type === textgen_types.DREAMGEN) {
             loadDreamGenModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.dreamgen_model);
         } else if (settingstextgenerationwebui_settings.type === textgen_types.OPENROUTER) {
             loadOpenRouterModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.openrouter_model);
         } else if (settingstextgenerationwebui_settings.type === textgen_types.VLLM) {
             loadVllmModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.vllm_model);
         } else if (settingstextgenerationwebui_settings.type === textgen_types.APHRODITE) {
             loadAphroditeModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.aphrodite_model);
         } else if (settingstextgenerationwebui_settings.type === textgen_types.FEATHERLESS) {
             loadFeatherlessModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.featherless_model);
         } else if (settingstextgenerationwebui_settings.type === textgen_types.TABBY) {
             loadTabbyModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.tabby_model || data?.result);
         } else if (settingstextgenerationwebui_settings.type === textgen_types.GENERIC) {
             loadGenericModels(data?.data);
             setOnlineStatus(settingstextgenerationwebui_settings.generic_model || data?.result || t`Connected`);
         } else {
             setOnlineStatus(data?.result);
+        }

         const wantsInstructDerivation = !autoSelected && (power_user.instruct.enabled && power_user.instruct_derived);
         const wantsContextDerivation = !autoSelected && power_user.context_derived;
         const wantsContextSize = power_user.context_size_derived;
         const supportsChatTemplate = [textgen_types.KOBOLDCPP, textgen_types.LLAMACPP].includes(settingstextgenerationwebui_settings.type);
         if (supportsChatTemplate && (wantsInstructDerivation || wantsContextDerivation || wantsContextSize)) {
             const response = await fetch('/api/backends/text-completions/props', {

                 headers: getRequestHeaders(),
                 body: JSON.stringify({
                     api_server: endpoint,
                     api_type: settingstextgenerationwebui_settings.type,
                 }),
             });

             $('#koboldcpp_order').children().each(function () {
                 order.push($(this).data('id'));
             });
             settingstextgenerationwebui_settings.sampler_order = order;
             console.log('Samplers reordered:', settingstextgenerationwebui_settings.sampler_order);
             saveSettingsDebounced();
         },
     });
     $('#koboldcpp_default_order').on('click', function () {
         settingstextgenerationwebui_settings.sampler_order = KOBOLDCPP_ORDER;
         sortKoboldItemsByOrder(settingstextgenerationwebui_settings.sampler_order);
         saveSettingsDebounced();
     });

             $('#llamacpp_samplers_sortable').children().each(function () {
                 order.push($(this).data('name'));
             });
             settingstextgenerationwebui_settings.samplers = order;
             console.log('Samplers reordered:', settingstextgenerationwebui_settings.samplers);
             saveSettingsDebounced();
         },
     });
     $('#llamacpp_samplers_default_order').on('click', function () {
         sortLlamacppItemsByOrder(LLAMACPP_DEFAULT_ORDER);
         settingstextgenerationwebui_settings.samplers = LLAMACPP_DEFAULT_ORDER;
         console.log('Default samplers order loaded:', settingstextgenerationwebui_settings.samplers);
         saveSettingsDebounced();
     });

             $('#sampler_priority_container').children().each(function () {
                 order.push($(this).data('name'));
             });
             settingstextgenerationwebui_settings.sampler_priority = order;
             console.log('Samplers reordered:', settingstextgenerationwebui_settings.sampler_priority);
             saveSettingsDebounced();
         },
     });

             $('#sampler_priority_container_aphrodite').children().each(function () {
                 order.push($(this).data('name'));
             });
             settingstextgenerationwebui_settings.samplers_priorities = order;
             console.log('Samplers reordered:', settingstextgenerationwebui_settings.samplers_priorities);
             saveSettingsDebounced();
         },
     });

         if (json_schema_string) {
             try {
                 settingstextgenerationwebui_settings.json_schema = JSON.parse(json_schema_string);
             } catch {
                 settingstextgenerationwebui_settings.json_schema = null;
+            }
         } else {
             settingstextgenerationwebui_settings.json_schema = null;
+        }
         saveSettingsDebounced();

     $('#textgenerationwebui_default_order').on('click', function () {
         sortOobaItemsByOrder(OOBA_DEFAULT_ORDER);
         settingstextgenerationwebui_settings.sampler_priority = OOBA_DEFAULT_ORDER;
         console.log('Default samplers order loaded:', settingstextgenerationwebui_settings.sampler_priority);
         saveSettingsDebounced();
     });
     $('#aphrodite_default_order').on('click', function () {
         sortAphroditeItemsByOrder(APHRODITE_DEFAULT_ORDER);
         settingstextgenerationwebui_settings.samplers_priorities = APHRODITE_DEFAULT_ORDER;
         console.log('Default samplers order loaded:', settingstextgenerationwebui_settings.samplers_priorities);
         saveSettingsDebounced();
     });
     $('#textgen_type').on('change', function () {
         const type = String($(this).val());
         settingstextgenerationwebui_settings.type = type;
         if ([VLLM, APHRODITE, INFERMATICAI].includes(settingstextgenerationwebui_settings.type)) {
             $('#mirostat_mode_textgenerationwebui').attr('step', 2); //Aphro disallows mode 1
             $('#do_sample_textgenerationwebui').prop('checked', true); //Aphro should always do sample; 'otherwise set temp to 0 to mimic no sample'
             $('#ban_eos_token_textgenerationwebui').prop('checked', false); //Aphro should not ban EOS, just ignore it; 'add token '2' to ban list do to this'
             //special handling for vLLM/Aphrodite topK -1 disable state
             $('#top_k_textgenerationwebui').attr('min', -1);
             if ($('#top_k_textgenerationwebui').val() === '0' || settingstextgenerationwebui_settings['top_k'] === 0) {
                 settingstextgenerationwebui_settings['top_k'] = -1;
                 $('#top_k_textgenerationwebui').val('-1').trigger('input');
+            }
         } else {
             $('#mirostat_mode_textgenerationwebui').attr('step', 1);
             //undo special vLLM/Aphrodite setup for topK
             $('#top_k_textgenerationwebui').attr('min', 0);
             if ($('#top_k_textgenerationwebui').val() === '-1' || settingstextgenerationwebui_settings['top_k'] === -1) {
                 settingstextgenerationwebui_settings['top_k'] = 0;
                 $('#top_k_textgenerationwebui').val('0').trigger('input');
+            }
+        }

@@ -913,7 +918,7 @@ export function initTextGenSettings() {
913	918
914	919	$('#main_api').trigger('change');
915	920
916	921	if (!SERVER_INPUTS[type] \|\| settingstextgenerationwebui_settings.server_urls[type]) {
917	922	$('#api_button_textgenerationwebui').trigger('click');
918	923	}
919	924

     $('#samplerResetButton').off('click').on('click', function () {
         const inputs = {
             'temp_textgenerationwebui': 1,
             'top_k_textgenerationwebui': [INFERMATICAI, APHRODITE, VLLM].includes(settingstextgenerationwebui_settings.type) ? -1 : 0,
             'top_p_textgenerationwebui': 1,
             'min_p_textgenerationwebui': 0,
             'rep_pen_textgenerationwebui': 1,

@@ -1007,19 +1012,19 @@ export function initTextGenSettings() {
1007	1012
1008	1013	if (isCheckbox) {
1009	1014	const value = $(this).prop('checked');
1010	1015	settingstextgenerationwebui_settings[id] = value;
1011	1016	}
1012	1017	else if (isText) {
1013	1018	const value = $(this).val();
1014	1019	settingstextgenerationwebui_settings[id] = value;
1015	1020	}
1016	1021	else {
1017	1022	const value = Number($(this).val());
1018	1023	$(`#${id}_counter_textgenerationwebui`).val(value);
1019	1024	settingstextgenerationwebui_settings[id] = value;
1020	1025	//special handling for vLLM/Aphrodite using -1 as disabled instead of 0
1021	1026	if ($(this).attr('id') === 'top_k_textgenerationwebui' && [INFERMATICAI, APHRODITE, VLLM].includes(settingstextgenerationwebui_settings.type) && value === 0) {
1022	1027	settingstextgenerationwebui_settings[id] = -1;
1023	1028	$(this).val(-1);
1024	1029	}
1025	1030	}

         });
+    }
     $('#textgen_logit_bias_new_entry').on('click', () => createNewLogitBiasEntry(settingstextgenerationwebui_settings.logit_bias, BIAS_KEY));
     $('#openrouter_providers_text').on('change', function () {
         const selectedProviders = $(this).val();

             return;
+        }
         settingstextgenerationwebui_settings.openrouter_providers = selectedProviders;
         saveSettingsDebounced();
     });

         if (!typeSpecificControlled) $(this).show();
     });
     showTypeSpecificControls(apiType ?? settingstextgenerationwebui_settings.type);
     const prioritizeManualSamplerSelect = isSamplerManualPriorityEnabled(apiType ?? settingstextgenerationwebui_settings.type);
     const samplersActivatedManually = getActiveManualApiSamplers(apiType ?? settingstextgenerationwebui_settings.type);
     if (!samplersActivatedManually?.length || !prioritizeManualSamplerSelect) return;

 function setSettingByName(setting, value, trigger) {
     if ('extensions' === setting) {
         value = value || {};
         settingstextgenerationwebui_settings.extensions = value;
         return;
+    }
     if ('json_schema' === setting) {
         settingstextgenerationwebui_settings.json_schema = value ?? null;
         $('#tabby_json_schema').val(value ? JSON.stringify(settingstextgenerationwebui_settings.json_schema, null, 2) : '');
         return;
+    }

     if ('sampler_order' === setting) {
         value = Array.isArray(value) ? value : KOBOLDCPP_ORDER;
         sortKoboldItemsByOrder(value);
         settingstextgenerationwebui_settings.sampler_order = value;
         return;
+    }

         value = Array.isArray(value) ? value : OOBA_DEFAULT_ORDER;
         insertMissingArrayItems(OOBA_DEFAULT_ORDER, value);
         sortOobaItemsByOrder(value);
         settingstextgenerationwebui_settings.sampler_priority = value;
         return;
+    }

         value = Array.isArray(value) ? value : APHRODITE_DEFAULT_ORDER;
         insertMissingArrayItems(APHRODITE_DEFAULT_ORDER, value);
         sortAphroditeItemsByOrder(value);
         settingstextgenerationwebui_settings.samplers_priorities = value;
         return;
+    }

         value = Array.isArray(value) ? value : LLAMACPP_DEFAULT_ORDER;
         insertMissingArrayItems(LLAMACPP_DEFAULT_ORDER, value);
         sortLlamacppItemsByOrder(value);
         settingstextgenerationwebui_settings.samplers = value;
         return;
+    }
     if ('logit_bias' === setting) {
         settingstextgenerationwebui_settings.logit_bias = Array.isArray(value) ? value : [];
         return;
+    }

 /**
  * Sends a streaming request for textgenerationwebui.
  * @param {object} generate_data
  * @param {AbortSignal} signal
  * @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
  */

         return null;
+    }
     switch (settingstextgenerationwebui_settings.type) {
         case KOBOLDCPP:
         case TABBY:
         case VLLM:

     return string.split(',').map(x => parseInt(x)).filter(x => !isNaN(x));
+}
 -export function getTextGenModel() {
 +/**
 + * Gets the text generation model specified by the given text completion settings
 + * @param {TextCompletionSettings} settings Text completion settings to use
 + * @returns {string} model name
 + */
 +export function getTextGenModel(settings = null) {
 +    settings = settings ?? textgenerationwebui_settings;
     switch (settings.type) {
         case OOBA:
             if (settings.custom_model) {

@@ -1455,10 +1466,16 @@ export function getTextGenModel() {
1455	1466	}
1456	1467
1457	1468	export function isJsonSchemaSupported() {
1458	1469	return [TABBY, LLAMACPP].includes(settingstextgenerationwebui_settings.type) && main_api === 'textgenerationwebui';
1459	1470	}
1460	1471
1461		-function isDynamicTemperatureSupported() {
	1472	+/**
	1473	+ * Returns whether dynamic temperature is supported by the given text completion settings
	1474	+ * @param {TextCompletionSettings} settings Text completion settings to use
	1475	+ * @returns {boolean} Whether dynamic temperature supported
	1476	+ */
	1477	+function isDynamicTemperatureSupported(settings = null) {
	1478	+ settings = settings ?? textgenerationwebui_settings;
1462	1479	return settings.dynatemp && DYNATEMP_BLOCK?.dataset?.tgType?.includes(settings.type);
1463	1480	}
1464	1481

  * @returns {number} Number of logprobs to request
  */
 export function getLogprobsNumber(type = null) {
     const selectedType = type ?? settingstextgenerationwebui_settings.type;
     if (selectedType === VLLM || selectedType === INFERMATICAI) {
         return 5;
+    }

+    }
+}
 -export async function getTextGenGenerationData(finalPrompt, maxTokens, isImpersonate, isContinue, cfgValues, type) {
 +/**
 + * Build the generation parameter object for an text completion request
 + * @param {TextCompletionSettings} settings Text completion settings to use
 + * @param {string} model Model to use
 + * @param {string} finalPrompt The final prompt to send
 + * @param {number} maxTokens Max allowed generation tokens
 + * @param {boolean} isImpersonate Whether this is for an impersonation
 + * @param {boolean} isContinue Whether this is for a continue
 + * @param {object} cfgValues Additional parameters (guidanceScale, negativePrompt)
 + * @param {string} type Request type (impersonate, quiet, continue, etc)
 + * @returns {object} Final generation parameters object appropriate for the text completion source
 + */
 +export function createTextGenGenerationData(settings, model, finalPrompt = null, maxTokens = null, isImpersonate = false, isContinue = false, cfgValues = null, type = 'quiet') {
 +    settings = settings ?? textgenerationwebui_settings;
 +    model = model ?? getTextGenModel(settings);
++
     const canMultiSwipe = !isContinue && !isImpersonate && type !== 'quiet';
     const dynatemp = isDynamicTemperatureSupported(settings);
     const { banned_tokens, banned_strings } = getCustomTokenBans(settings);
     const jsonSchema = isObject(settings.json_schema)
         ? settings.json_schema_allow_empty
             ? settings.json_schema

     let params = {
         'prompt': finalPrompt,
         'model': getTextGenModel()model,
         'max_new_tokens': maxTokens,
         'max_tokens': maxTokens,
         'logprobs': power_user.request_token_probabilities ? getLogprobsNumber(settings.type) : undefined,
         'temperature': dynatemp ? (settings.min_temp + settings.max_temp) / 2 : settings.temp,
         'top_p': settings.top_p,
         'typical_p': settings.typical_p,

             banned_tokens,
         'banned_strings': banned_strings,
         'api_type': settings.type,
         'api_server': getTextGenServer(settings.type),
         'sampler_order': settings.type === textgen_types.KOBOLDCPP ? settings.sampler_order : undefined,
         'xtc_threshold': settings.xtc_threshold,
         'xtc_probability': settings.xtc_probability,

@@ -1713,7 +1745,7 @@ export async function getTextGenGenerationData(finalPrompt, maxTokens, isImperso
1713	1745	}
1714	1746
1715	1747	if (Array.isArray(settings.logit_bias) && settings.logit_bias.length) {
1716	1748	const logitBias = BIAS_CACHE.get(BIAS_KEY) \|\| calculateLogitBias(settings);
1717	1749	BIAS_CACHE.set(BIAS_KEY, logitBias);
1718	1750	params.logit_bias = logitBias;
1719	1751	}

@@ -1750,8 +1782,12 @@ export async function getTextGenGenerationData(finalPrompt, maxTokens, isImperso
1750	1782	delete params.guided_json;
1751	1783	}
1752	1784	}
	1785	+ return params;
	1786	+}
1753	1787
	1788	+export async function getTextGenGenerationData(finalPrompt, maxTokens, isImpersonate, isContinue, cfgValues, type) {
	1789	+ const model = getTextGenModel(textgenerationwebui_settings);
	1790	+ const params = createTextGenGenerationData(textgenerationwebui_settings, model, finalPrompt, maxTokens, isImpersonate, isContinue, cfgValues, type);
1754	1791	await eventSource.emit(event_types.TEXT_COMPLETION_SETTINGS_READY, params);
1755		-
1756	1792	return params;
1757	1793	}

public/scripts/tool-calling.js+28 -48 Viewed

 import { DOMPurify } from '../lib.js';
 import { addOneMessage, chat, event_types, eventSource, main_api, saveChatConditional, system_avatar, systemUserName } from '../script.js';
 import { chat_completion_sources, custom_prompt_post_processing_types, getChatCompletionModel, model_list, oai_settings } from './openai.js';
 import { Popup } from './popup.js';
 import { SlashCommand } from './slash-commands/SlashCommand.js';
 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './slash-commands/SlashCommandArgument.js';

     /**
      * Checks if tool calling is supported for the current settings and generation type.
 +     * @param {ChatCompletionSettings} settings Optional chat completion settings
 +     * @param {string} model Optional model name
      * @returns {boolean} Whether tool calling is supported for the given type
      */
     static isToolCallingSupported(settings = null, model = null) {
 -        if (main_api !== 'openai' || !oai_settings.function_calling) {
 +        settings = settings ?? oai_settings;
 +        model = model ?? getChatCompletionModel(settings);
++
 +        if (main_api !== 'openai' || !settings.function_calling) {
             return false;
+        }
         // Post-processing will forcefully remove past tool calls from the prompt, making them useless
         const { NONE, MERGE_TOOLS, SEMI_TOOLS, STRICT_TOOLS } = custom_prompt_post_processing_types;
         const allowedPromptPostProcessing = [NONE, MERGE_TOOLS, SEMI_TOOLS, STRICT_TOOLS];
         if (!allowedPromptPostProcessing.includes(oai_settingssettings.custom_prompt_post_processing)) {
             return false;
+        }
 -        if (oai_settings.chat_completion_source === chat_completion_sources.POLLINATIONS && Array.isArray(model_list)) {
 +        const currentModel = Array.isArray(model_list) ? model_list.find(m => m.id === model) : null;
 -            const currentModel = model_list.find(model => model.id === oai_settings.pollinations_model);
         if (currentModel) {
 +            switch (settings.chat_completion_source) {
 +                case chat_completion_sources.POLLINATIONS:
                     return currentModel.tools;
 -            }
 +                case chat_completion_sources.FIREWORKS:
 -        }
+-
 -        if (oai_settings.chat_completion_source === chat_completion_sources.FIREWORKS && Array.isArray(model_list)) {
 -            const currentModel = model_list.find(model => model.id === oai_settings.fireworks_model);
 -            if (currentModel) {
                     return currentModel.supports_tools;
 -            }
 +                case chat_completion_sources.OPENROUTER:
 -        }
 +                    return currentModel.supported_parameters?.includes('tools');
+-
 +                case chat_completion_sources.MISTRALAI:
 -        if (oai_settings.chat_completion_source === chat_completion_sources.OPENROUTER && Array.isArray(model_list)) {
 +                    return currentModel.capabilities?.function_calling;
 -            const currentModel = model_list.find(model => model.id === oai_settings.openrouter_model);
 +                case chat_completion_sources.AIMLAPI:
 -            if (Array.isArray(currentModel?.supported_parameters)) {
 +                    return currentModel.features?.includes('openai/chat-completion.function');
 -                return currentModel.supported_parameters.includes('tools');
 +                case chat_completion_sources.CHUTES:
 -            }
 -        }
+-
 -        if (oai_settings.chat_completion_source === chat_completion_sources.MISTRALAI && Array.isArray(model_list)) {
 -            const currentModel = model_list.find(model => model.id === oai_settings.mistralai_model);
 -            if (currentModel && currentModel.capabilities) {
 -                return currentModel.capabilities.function_calling;
 -            }
 -        }
+-
 -        if (oai_settings.chat_completion_source === chat_completion_sources.AIMLAPI && Array.isArray(model_list)) {
 -            const currentModel = model_list.find(model => model.id === oai_settings.aimlapi_model);
 -            if (Array.isArray(currentModel?.features)) {
 -                return currentModel.features.includes('openai/chat-completion.function');
 -            }
 -        }
+-
 -        if (oai_settings.chat_completion_source === chat_completion_sources.CHUTES && Array.isArray(model_list)) {
 -            const currentModel = model_list.find(model => model.id === oai_settings.chutes_model);
 -            if (currentModel) {
                     return currentModel.supported_features?.includes('tools');
 -            }
 +                case chat_completion_sources.ELECTRONHUB:
 -        }
+-
 -        if (oai_settings.chat_completion_source === chat_completion_sources.ELECTRONHUB && Array.isArray(model_list)) {
 -            const currentModel = model_list.find(model => model.id === oai_settings.electronhub_model);
 -            if (currentModel) {
                     return currentModel.metadata?.function_call;
+            }
+        }

             chat_completion_sources.ZAI,
             chat_completion_sources.SILICONFLOW,
         ];
         return supportedSources.includes(oai_settingssettings.chat_completion_source);
+    }
     /**
      * Checks if tool calls can be performed for the current settings and generation type.
      * @param {string} type Generation type
 +     * @param {ChatCompletionSettings} settings Optional chat completion settings
 +     * @param {string} model Optional model name
      * @returns {boolean} Whether tool calls can be performed for the given type
      */
     static canPerformToolCalls(type, settings = null, model = null) {
 +        settings = settings ?? oai_settings;
 +        model = model ?? getChatCompletionModel(settings);
         const noToolCallTypes = ['impersonate', 'quiet', 'continue'];
         const isSupported = ToolManager.isToolCallingSupported(settings, model);
         return isSupported && !noToolCallTypes.includes(type);
+    }