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+160 -149 Viewed

 import { getPresetManager } from './preset-manager.js';
-import { extractJsonFromData, extractMessageFromData, getGenerateUrl, getRequestHeaders } from '../script.js';
+import { extractJsonFromData, extractMessageFromData, getGenerateUrl, getRequestHeaders, name1, name2 } from '../script.js';
-import { getTextGenServer } from './textgen-settings.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 { formatInstructModeChat, formatInstructModePrompt, getInstructStoppingSequences } from './instruct-mode.js';
-import { getStreamingReply, tryParseStreamingError } from './openai.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) {

+    }
     /**
+    * Return a formatted prompt string given an array of messages, a chosen instruct preset, and instruct settings.
+    * @param {(ChatCompletionMessage & {ignoreInstruct?: boolean})[]} prompt An array of messages
+    * @param {InstructSettings|string} instructPreset Either the name of an instruct preset or the instruct preset object itself.
+    * @param {Partial<InstructSettings>} instructSettings Optional instruct settings
+    */
+    static constructPrompt(prompt, instructPreset, instructSettings) {
+        // InstructPreset may either be a name or itself a preset
+        if (typeof instructPreset === 'string') {
+            const instructPresetManager = getPresetManager('instruct');
+            instructPreset = instructPresetManager?.getCompletionPresetByName(instructPreset);
+        }
+        // Clone the preset to avoid modifying the original
+        instructPreset = structuredClone(instructPreset);
+        if (instructSettings) {  // apply any additional settings
+            Object.assign(instructPreset, 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
+        const formattedMessages = [];
+        const prefillActive = prompt.length > 0 ? prompt[prompt.length - 1].role === 'assistant' : false;
+        for (const message of prompt) {
+            let messageContent = message.content;
+            if (!message.ignoreInstruct) {
+                const isLastMessage = message === prompt[prompt.length - 1];
+                // This complicated logic means:
+                // 1. If prefill is not active, format all messages
+                // 2. If prefill is active, format all messages except the last one
+                if (!isLastMessage || !prefillActive) {
+                    messageContent = formatInstructModeChat(
+                        message.name ?? message.role,
+                        message.content,
+                        message.role === 'user',
+                        message.role === 'system',
+                        undefined,
+                        name1,  // for macros
+                        name2,  // for macros
+                        undefined,
+                        instructPreset,
+                    );
+                }
+                // Add prompt formatting for the last message.
+                // e.g. "<|im_start|>assistant"
+                if (isLastMessage) {
+                    let last_line = formatInstructModePrompt(
+                        'assistant',  // for sequences using {{name}}
+                        false,  // not an impersonation
+                        prefillActive ? message.content : undefined,  // if using prefill, last message is the prefill
+                        name1,  // for macros
+                        name2,  // for macros
+                        true,   // quiet
+                        false,
+                        instructPreset,
+                    );
+                    if (prefillActive) {  // content is the prefilled message
+                        if (last_line.endsWith('\n') && !message.content.endsWith('\n')) {
+                            last_line = last_line.slice(0, -1);  // remove newline after prefill if it's not in the prefill itself
+                        }
+                        messageContent = last_line;
+                    } else {  // append last line to content (e.g. "<|im_start|>assistant:")
+                        messageContent += last_line;
+                    }
+                }
+            }
+            formattedMessages.push(messageContent);
+        }
+        return formattedMessages.join('');
+    }
+    /**
      * Process and send a text completion request with optional preset & instruct
-     * @param {Record<string, any> & TextCompletionRequestBase & {prompt: (ChatCompletionMessage & {ignoreInstruct?: boolean})[] |string}} custom
+     * @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

      * @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 async processRequest(requestData, options = {}, extractData = true, signal = null) {
-        custom,
-        options = {},
-        extractData = true,
-        signal = null,
-    ) {
         const { presetName, instructName } = options;
-        let requestData = { ...custom };
-        const prompt = custom.prompt;
+        // 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;
+                } else {
+                    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) {

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

+            }
+        }
+        const response = await this.sendRequest(requestData, extractData, signal);
-        /** @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 (options.instructSettings) {
-                    Object.assign(instructPreset, options.instructSettings);
-                }
-                // Format messages using instruct formatting
-                const formattedMessages = [];
-                const prefillActive = prompt.length > 0 ? prompt[prompt.length - 1].role === 'assistant' : false;
-                for (const message of prompt) {
-                    let messageContent = message.content;
-                    if (!message.ignoreInstruct) {
-                        const isLastMessage = message === prompt[prompt.length - 1];
-                        // This complicated logic means:
-                        // 1. If prefill is not active, format all messages
-                        // 2. If prefill is active, format all messages except the last one
-                        if (!isLastMessage || !prefillActive) {
-                            messageContent = formatInstructModeChat(
-                                message.role,
-                                message.content,
-                                message.role === 'user',
-                                message.role === 'system',
-                                undefined,
-                                undefined,
-                                undefined,
-                                undefined,
-                                instructPreset,
-                            );
-                        }
-                        // Add prompt formatting for the last message.
-                        if (isLastMessage) {
-                            if (!prefillActive) { // e.g. "<|im_start|>user:"
-                                messageContent += formatInstructModePrompt(
-                                    undefined,
-                                    false,
-                                    undefined,
-                                    undefined,
-                                    undefined,
-                                    false,
-                                    false,
-                                    instructPreset,
-                                );
-                            } else { // e.g. "<|im_start|>assistant: Hello, my name is"
-                                const overriddenInstructPreset = structuredClone(instructPreset);
-                                overriddenInstructPreset.output_suffix = '';
-                                overriddenInstructPreset.wrap = false;
-                                messageContent = formatInstructModeChat(
-                                    message.role,
-                                    message.content,
-                                    false, // since it is assistant
-                                    false,
-                                    undefined,
-                                    undefined,
-                                    undefined,
-                                    undefined,
-                                    overriddenInstructPreset,
-                                );
-                            }
-                        }
-                    }
-                    formattedMessages.push(messageContent);
-                }
-                requestData.prompt = formattedMessages.join('');
-                const stoppingStrings = getInstructStoppingSequences({ customInstruct: instructPreset, useStopStrings: false });
-                requestData.stop = stoppingStrings;
-                requestData.stopping_strings = stoppingStrings;
-            } else {
-                console.warn(`Instruct preset "${instructName}" not found, using basic formatting`);
-                requestData.prompt = prompt.map(x => x.content).join('\n\n');
-            }
-        } else if (typeof prompt === 'string') {
-            requestData.prompt = prompt;
-        } else {
-            requestData.prompt = prompt.map(x => x.content).join('\n\n');
-        }
-        // @ts-ignore
-        const data = this.createRequestData(requestData);
-        const response = await this.sendRequest(data, extractData, signal);
         // Remove stopping strings from the end
-        if (!data.stream && extractData) {
+        if (!requestData.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} customPreset - Additional parameters to override preset values
+     * @param {Object} overridePreset - 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, customPreset = {}) {
+    static presetToGeneratePayload(preset, overridePreset = {}, overridePayload = {}) {
         if (!preset || typeof preset !== 'object') {
             throw new Error('Invalid preset: must be an object');
+        }
-        // Merge preset with custom parameters
+        // apply preset overrides
-        const settings = { ...preset, ...customPreset };
+        preset = { ...preset, ...overridePreset };
-        // Initialize base payload with common parameters
+        // Only take fields from the preset specified in setting_names to use as TextCompletionSettings
-        let payload = {
+        const settings = structuredClone(textgenerationwebui_settings);
-            'temperature': settings.temp >= 0 ? Number(settings.temp) : undefined,
+        for (const [key, value] of Object.entries(preset)) {
-            'min_p': settings.min_p >= 0 ? Number(settings.min_p) : undefined,
+            if (!setting_names.includes(key)) continue;
-        };
+            settings[key] = value;
+        }
-        // Remove undefined values to avoid API errors
+        // convert to a generation payload
-        Object.keys(payload).forEach(key => {
+        const payload = createTextGenGenerationData(settings, overridePayload.model, overridePayload.prompt, preset.genamt);
-            if (payload[key] === undefined) {
-                delete payload[key];
-            }
-        });
-        return payload;
+        // 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} custom
+     * @param {ChatCompletionPayload} requestData - 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(custom, options, extractData = true, signal = null) {
+    static async processRequest(requestData, options, extractData = true, signal = null) {
         const { presetName } = options;
-        let requestData = { ...custom };
+        requestData = this.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 presetPayload = this.presetToGeneratePayload(preset, {});
+                    requestData = await this.presetToGeneratePayload(preset, {}, requestData);
-                    requestData = { ...presetPayload, ...requestData };
                 } else {
                     console.warn(`Preset "${presetName}" not found, continuing with default settings`);
+                }

+            }
+        }
-        const data = this.createRequestData(requestData);
+        return await this.sendRequest(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} customParams - Additional parameters to override preset values
+     * @param {Object} overridePreset - Additional parameters to override preset values
-     * @returns {Object} - Formatted payload for chat completion API
+     * @param {Object} overridePayload - Additional parameters to override payload values
+     * @returns {Promise<any>} - Formatted payload for chat completion API
      */
-    static presetToGeneratePayload(preset, customParams = {}) {
+    static async presetToGeneratePayload(preset, overridePreset = {}, overridePayload = {}) {
         if (!preset || typeof preset !== 'object') {
             throw new Error('Invalid preset: must be an object');
+        }
-        // Merge preset with custom parameters
+        // apply preset overrides
-        const settings = { ...preset, ...customParams };
+        preset = { ...preset, ...overridePreset };
-        // Initialize base payload with common parameters
+        // Fix any fields before converting to 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,
-        };
-        // Remove undefined values to avoid API errors
+        // Convert from preset to ChatCompletionSettings
-        Object.keys(payload).forEach(key => {
+        const settings = structuredClone(oai_settings);
-            if (payload[key] === undefined) {
+        for (const [key, value] of Object.entries(preset)) {
-                delete payload[key];
+            const settingToUpdate = 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 {string} source If it's set, ignores active source
+ * @param {ChatCompletionSettings} settings Chat completion settings
  * @returns {string} API model
  */
-export function getChatCompletionModel(source = null) {
+export function getChatCompletionModel(settings = null) {
-    const activeSource = source ?? oai_settings.chat_completion_source;
+    settings = settings ?? oai_settings;
-    switch (activeSource) {
+    const source = settings.chat_completion_source;
+    switch (source) {
         case chat_completion_sources.CLAUDE:
-            return oai_settings.claude_model;
+            return settings.claude_model;
         case chat_completion_sources.OPENAI:
-            return oai_settings.openai_model;
+            return settings.openai_model;
         case chat_completion_sources.MAKERSUITE:
-            return oai_settings.google_model;
+            return settings.google_model;
         case chat_completion_sources.VERTEXAI:
-            return oai_settings.vertexai_model;
+            return settings.vertexai_model;
         case chat_completion_sources.OPENROUTER:
-            return oai_settings.openrouter_model !== openrouter_website_model ? oai_settings.openrouter_model : null;
+            return settings.openrouter_model !== openrouter_website_model ? settings.openrouter_model : null;
         case chat_completion_sources.AI21:
-            return oai_settings.ai21_model;
+            return settings.ai21_model;
         case chat_completion_sources.MISTRALAI:
-            return oai_settings.mistralai_model;
+            return settings.mistralai_model;
         case chat_completion_sources.CUSTOM:
-            return oai_settings.custom_model;
+            return settings.custom_model;
         case chat_completion_sources.COHERE:
-            return oai_settings.cohere_model;
+            return settings.cohere_model;
         case chat_completion_sources.PERPLEXITY:
-            return oai_settings.perplexity_model;
+            return settings.perplexity_model;
         case chat_completion_sources.GROQ:
-            return oai_settings.groq_model;
+            return settings.groq_model;
         case chat_completion_sources.SILICONFLOW:
-            return oai_settings.siliconflow_model;
+            return settings.siliconflow_model;
         case chat_completion_sources.ELECTRONHUB:
-            return oai_settings.electronhub_model;
+            return settings.electronhub_model;
         case chat_completion_sources.CHUTES:
-            return oai_settings.chutes_model;
+            return settings.chutes_model;
         case chat_completion_sources.NANOGPT:
-            return oai_settings.nanogpt_model;
+            return settings.nanogpt_model;
         case chat_completion_sources.DEEPSEEK:
-            return oai_settings.deepseek_model;
+            return settings.deepseek_model;
         case chat_completion_sources.AIMLAPI:
-            return oai_settings.aimlapi_model;
+            return settings.aimlapi_model;
         case chat_completion_sources.XAI:
-            return oai_settings.xai_model;
+            return settings.xai_model;
         case chat_completion_sources.POLLINATIONS:
-            return oai_settings.pollinations_model;
+            return settings.pollinations_model;
         case chat_completion_sources.COMETAPI:
-            return oai_settings.cometapi_model;
+            return settings.cometapi_model;
         case chat_completion_sources.MOONSHOT:
-            return oai_settings.moonshot_model;
+            return settings.moonshot_model;
         case chat_completion_sources.FIREWORKS:
-            return oai_settings.fireworks_model;
+            return settings.fireworks_model;
         case chat_completion_sources.AZURE_OPENAI:
-            return oai_settings.azure_openai_model;
+            return settings.azure_openai_model;
         case chat_completion_sources.ZAI:
-            return oai_settings.zai_model;
+            return settings.zai_model;
         default:
-            console.error(`Unknown chat completion source: ${activeSource}`);
+            console.error(`Unknown chat completion source: ${source}`);
             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_settings.chat_completion_source)) {
+    if (!reasoningEffortSources.includes(settings.chat_completion_source)) {
-        return oai_settings.reasoning_effort;
+        return settings.reasoning_effort;
+    }
     function resolveReasoningEffort() {
-        switch (oai_settings.reasoning_effort) {
+        switch (settings.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_settings.chat_completion_source) && /^gpt-5/.test(getChatCompletionModel())
+                return [chat_completion_sources.OPENAI, chat_completion_sources.AZURE_OPENAI].includes(settings.chat_completion_source) && /^gpt-5/.test(model)
                     ? reasoning_effort_types.min
                     : reasoning_effort_types.low;
             case reasoning_effort_types.max:
                 return reasoning_effort_types.high;
             default:
-                return oai_settings.reasoning_effort;
+                return settings.reasoning_effort;
+        }
+    }
     const reasoningEffort = resolveReasoningEffort();
     // Check if the resolved effort supported by the model
-    if (oai_settings.chat_completion_source === chat_completion_sources.ELECTRONHUB) {
+    if (settings.chat_completion_source === chat_completion_sources.ELECTRONHUB) {
         if (Array.isArray(model_list) && reasoningEffort) {
-            const currentModel = model_list.find(m => m.id === oai_settings.electronhub_model);
+            const currentModel = model_list.find(m => m.id === model);
             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_settings.verbosity;
+    return settings.verbosity;
+}
 /**
- * Send a chat completion request to backend
+ * Build the generation parameter object for an OAI request.
- * @param {string} type (impersonate, quiet, continue, etc)
+ * @param {ChatCompletionSettings} settings Initial chat completion settings
- * @param {Array} messages
+ * @param {string} model 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_settings.bias_preset_selected
+    if (settings.bias_preset_selected
-        && logitBiasSources.includes(oai_settings.chat_completion_source)
+        && logitBiasSources.includes(settings.chat_completion_source)
-        && Array.isArray(oai_settings.bias_presets[oai_settings.bias_preset_selected])
+        && Array.isArray(settings.bias_presets[settings.bias_preset_selected])
-        && oai_settings.bias_presets[oai_settings.bias_preset_selected].length) {
+        && settings.bias_presets[settings.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_settings.temp_openai),
+        'temperature': Number(settings.temp_openai),
-        'frequency_penalty': Number(oai_settings.freq_pen_openai),
+        'frequency_penalty': Number(settings.freq_pen_openai),
-        'presence_penalty': Number(oai_settings.pres_pen_openai),
+        'presence_penalty': Number(settings.pres_pen_openai),
-        'top_p': Number(oai_settings.top_p_openai),
+        'top_p': Number(settings.top_p_openai),
-        'max_tokens': oai_settings.openai_max_tokens,
+        'max_tokens': settings.openai_max_tokens,
         'stream': stream,
         'logit_bias': logit_bias,
         'stop': getCustomStoppingStrings(openai_max_stop_strings),
-        'chat_completion_source': oai_settings.chat_completion_source,
+        'chat_completion_source': settings.chat_completion_source,
-        'n': canMultiSwipe ? oai_settings.n : undefined,
+        'n': canMultiSwipe ? settings.n : undefined,
         'user_name': name1,
         'char_name': name2,
         'group_names': getGroupNames(),
-        'include_reasoning': Boolean(oai_settings.show_thoughts),
+        'include_reasoning': Boolean(settings.show_thoughts),
-        'reasoning_effort': getReasoningEffort(),
+        'reasoning_effort': getReasoningEffort(settings, model),
-        'enable_web_search': Boolean(oai_settings.enable_web_search),
+        'enable_web_search': Boolean(settings.enable_web_search),
-        'request_images': Boolean(oai_settings.request_images),
+        'request_images': Boolean(settings.request_images),
-        'request_image_resolution': String(oai_settings.request_image_resolution),
+        'request_image_resolution': String(settings.request_image_resolution),
-        'request_image_aspect_ratio': String(oai_settings.request_image_aspect_ratio),
+        'request_image_aspect_ratio': String(settings.request_image_aspect_ratio),
-        'custom_prompt_post_processing': oai_settings.custom_prompt_post_processing,
+        'custom_prompt_post_processing': settings.custom_prompt_post_processing,
-        'verbosity': getVerbosity(),
+        'verbosity': getVerbosity(settings),
     };
-    if (isAzureOpenAI) {
+    if (settings.chat_completion_source === chat_completion_sources.AZURE_OPENAI) {
-        generate_data.azure_base_url = oai_settings.azure_base_url;
+        generate_data.azure_base_url = settings.azure_base_url;
-        generate_data.azure_deployment_name = oai_settings.azure_deployment_name;
+        generate_data.azure_deployment_name = settings.azure_deployment_name;
-        generate_data.azure_api_version = oai_settings.azure_api_version;
+        generate_data.azure_api_version = settings.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_model)) {
+        if (/^gpt-[34]/.test(model)) {
             delete generate_data.reasoning_effort;
+        }
+    }
-    if (!canMultiSwipe && ToolManager.canPerformToolCalls(type)) {
+    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_settings.reverse_proxy;
+        generate_data['reverse_proxy'] = settings.reverse_proxy;
-        generate_data['proxy_password'] = oai_settings.proxy_password;
+        generate_data['proxy_password'] = settings.proxy_password;
+    }
-    // Add logprobs request (currently OpenAI only, max 5 on their side)
+    // Add logprobs request (max 5 per OpenAI docs)
-    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 (isClaude) {
+    if (settings.chat_completion_source === chat_completion_sources.CLAUDE) {
-        generate_data['top_k'] = Number(oai_settings.top_k_openai);
+        generate_data['top_k'] = Number(settings.top_k_openai);
-        generate_data['use_sysprompt'] = oai_settings.use_sysprompt;
+        generate_data['use_sysprompt'] = settings.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 (!isQuiet && !(isContinue && oai_settings.continue_prefill)) {
+        if (type !== 'quiet' && !(type === 'continue' && settings.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 (isOpenRouter) {
+    if (settings.chat_completion_source === chat_completion_sources.OPENROUTER) {
-        generate_data['top_k'] = Number(oai_settings.top_k_openai);
+        generate_data['top_k'] = Number(settings.top_k_openai);
-        generate_data['min_p'] = Number(oai_settings.min_p_openai);
+        generate_data['min_p'] = Number(settings.min_p_openai);
-        generate_data['repetition_penalty'] = Number(oai_settings.repetition_penalty_openai);
+        generate_data['repetition_penalty'] = Number(settings.repetition_penalty_openai);
-        generate_data['top_a'] = Number(oai_settings.top_a_openai);
+        generate_data['top_a'] = Number(settings.top_a_openai);
-        generate_data['use_fallback'] = oai_settings.openrouter_use_fallback;
+        generate_data['use_fallback'] = settings.openrouter_use_fallback;
-        generate_data['provider'] = oai_settings.openrouter_providers;
+        generate_data['provider'] = settings.openrouter_providers;
-        generate_data['allow_fallbacks'] = oai_settings.openrouter_allow_fallbacks;
+        generate_data['allow_fallbacks'] = settings.openrouter_allow_fallbacks;
-        generate_data['middleout'] = oai_settings.openrouter_middleout;
+        generate_data['middleout'] = settings.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_settings.top_k_openai);
+        generate_data['top_k'] = Number(settings.top_k_openai);
         generate_data['stop'] = getCustomStoppingStrings(stopStringsLimit).slice(0, stopStringsLimit).filter(x => x.length >= 1 && x.length <= 16);
-        generate_data['use_sysprompt'] = oai_settings.use_sysprompt;
+        generate_data['use_sysprompt'] = settings.use_sysprompt;
-        if (isVertexAI) {
+        if (settings.chat_completion_source === chat_completion_sources.VERTEXAI) {
-            generate_data['vertexai_auth_mode'] = oai_settings.vertexai_auth_mode;
+            generate_data['vertexai_auth_mode'] = settings.vertexai_auth_mode;
-            generate_data['vertexai_region'] = oai_settings.vertexai_region;
+            generate_data['vertexai_region'] = settings.vertexai_region;
-            generate_data['vertexai_express_project_id'] = oai_settings.vertexai_express_project_id;
+            generate_data['vertexai_express_project_id'] = settings.vertexai_express_project_id;
+        }
+    }
-    if (isMistral) {
+    if (settings.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 (isCustom) {
+    if (settings.chat_completion_source === chat_completion_sources.CUSTOM) {
-        generate_data['custom_url'] = oai_settings.custom_url;
+        generate_data['custom_url'] = settings.custom_url;
-        generate_data['custom_include_body'] = oai_settings.custom_include_body;
+        generate_data['custom_include_body'] = settings.custom_include_body;
-        generate_data['custom_exclude_body'] = oai_settings.custom_exclude_body;
+        generate_data['custom_exclude_body'] = settings.custom_exclude_body;
-        generate_data['custom_include_headers'] = oai_settings.custom_include_headers;
+        generate_data['custom_include_headers'] = settings.custom_include_headers;
+    }
-    if (isCohere) {
+    if (settings.chat_completion_source === chat_completion_sources.COHERE) {
         // Clamp to 0.01 -> 0.99
-        generate_data['top_p'] = Math.min(Math.max(Number(oai_settings.top_p_openai), 0.01), 0.99);
+        generate_data['top_p'] = Math.min(Math.max(Number(settings.top_p_openai), 0.01), 0.99);
-        generate_data['top_k'] = Number(oai_settings.top_k_openai);
+        generate_data['top_k'] = Number(settings.top_k_openai);
         // Clamp to 0 -> 1
-        generate_data['frequency_penalty'] = Math.min(Math.max(Number(oai_settings.freq_pen_openai), 0), 1);
+        generate_data['frequency_penalty'] = Math.min(Math.max(Number(settings.freq_pen_openai), 0), 1);
-        generate_data['presence_penalty'] = Math.min(Math.max(Number(oai_settings.pres_pen_openai), 0), 1);
+        generate_data['presence_penalty'] = Math.min(Math.max(Number(settings.pres_pen_openai), 0), 1);
         generate_data['stop'] = getCustomStoppingStrings(5);
+    }
-    if (isPerplexity) {
+    if (settings.chat_completion_source === chat_completion_sources.PERPLEXITY) {
-        generate_data['top_k'] = Number(oai_settings.top_k_openai);
+        generate_data['top_k'] = Number(settings.top_k_openai);
-        generate_data['frequency_penalty'] = Number(oai_settings.freq_pen_openai);
+        generate_data['frequency_penalty'] = Number(settings.freq_pen_openai);
-        generate_data['presence_penalty'] = Number(oai_settings.pres_pen_openai);
+        generate_data['presence_penalty'] = Number(settings.pres_pen_openai);
-        // YEAH BRO JUST USE OPENAI CLIENT BRO
         delete generate_data['stop'];
+    }
     // https://console.groq.com/docs/openai
-    if (isGroq) {
+    if (settings.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 (isDeepSeek) {
+    if (settings.chat_completion_source === chat_completion_sources.DEEPSEEK) {
         generate_data.top_p = generate_data.top_p || Number.EPSILON;
+    }
-    if (isXAI) {
+    if (settings.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 (isPollinations) {
+    if (settings.chat_completion_source === chat_completion_sources.POLLINATIONS) {
         delete generate_data.max_tokens;
+    }
     // https://docs.electronhub.ai/api-reference/chat/completions
-    if (isElectronHub) {
+    if (settings.chat_completion_source === chat_completion_sources.ELECTRONHUB) {
-        generate_data['top_k'] = Number(oai_settings.top_k_openai);
+        generate_data['top_k'] = Number(settings.top_k_openai);
+    }
-    if (isChutes) {
+    if (settings.chat_completion_source === chat_completion_sources.CHUTES) {
-        generate_data['min_p'] = Number(oai_settings.min_p_openai);
+        generate_data['min_p'] = Number(settings.min_p_openai);
-        generate_data['top_k'] = oai_settings.top_k_openai > 0 ? Number(oai_settings.top_k_openai) : undefined;
+        generate_data['top_k'] = settings.top_k_openai > 0 ? Number(settings.top_k_openai) : undefined;
-        generate_data['repetition_penalty'] = Number(oai_settings.repetition_penalty_openai);
+        generate_data['repetition_penalty'] = Number(settings.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 (isZai) {
+    if (settings.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_settings.zai_endpoint || ZAI_ENDPOINT.COMMON;
+        generate_data['zai_endpoint'] = settings.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 (isNanoGPT) {
+    if (settings.chat_completion_source === chat_completion_sources.NANOGPT) {
-        generate_data['top_k'] = Number(oai_settings.top_k_openai);
+        generate_data['top_k'] = Number(settings.top_k_openai);
-        generate_data['min_p'] = Number(oai_settings.min_p_openai);
+        generate_data['min_p'] = Number(settings.min_p_openai);
-        generate_data['repetition_penalty'] = Number(oai_settings.repetition_penalty_openai);
+        generate_data['repetition_penalty'] = Number(settings.repetition_penalty_openai);
-        generate_data['top_a'] = Number(oai_settings.top_a_openai);
+        generate_data['top_a'] = Number(settings.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)/.test(model)) || (isAzureOpenAI && /^(o1|o3|o4)/.test(model))) {
+    if (gptSources.includes(settings.chat_completion_source) && /^(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	if ((isOAI && /^gpt-5/.test(model)) \|\| (isAzureOpenAI && /^gpt-5/.test(model))) {	2710	if (gptSources.includes(settings.chat_completion_source) && /^gpt-5/.test(model)) {
2680	generate_data.max_completion_tokens = generate_data.max_tokens;	2711	generate_data.max_completion_tokens = generate_data.max_tokens;
2681	delete generate_data.max_tokens;	2712	delete generate_data.max_tokens;
2682	delete generate_data.logprobs;	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 } = {}) {
+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.reasoning.prefix || !power_user.reasoning.suffix) {
+    if (!template.prefix || !template.suffix) {
         return null;
+    }
     try {
-        const regex = new RegExp(`${(strict ? '^\\s*?' : '')}${escapeRegex(power_user.reasoning.prefix)}(.*?)${escapeRegex(power_user.reasoning.suffix)}`, 's');
+        const regex = new RegExp(`${(strict ? '^\\s*?' : '')}${escapeRegex(template.prefix)}(.*?)${escapeRegex(template.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 } from './reasoning.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];
-const settings = {
+export const textgenerationwebui_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[settings.type];
+    const selector = SERVER_INPUTS[textgenerationwebui_settings.type];
     if (!selector) {
         return;

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

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

         return;
+    }
-    settings.preset = name;
+    textgenerationwebui_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(settings.type)) {
+        if (noFormatTypes.includes(textgenerationwebui_settings.type)) {
             return value;
+        }

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

@@ -407,11 +406,11 @@ function getTokenizerForTokenIds() {
407	return power_user.tokenizer;	406	return power_user.tokenizer;
408	}	407	}
409		408
410	if (settings.type === OPENROUTER) {	409	if (textgenerationwebui_settings.type === OPENROUTER) {
411	return getCurrentOpenRouterModelTokenizer();	410	return getCurrentOpenRouterModelTokenizer();
412	}	411	}
413		412
414	if (settings.type === DREAMGEN) {	413	if (textgenerationwebui_settings.type === DREAMGEN) {
415	return getCurrentDreamGenModelTokenizer();	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() {
+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);
-    settings.send_banned_tokens = isEnabled;
+    textgenerationwebui_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() {
+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(settings, loadedSettings.textgenerationwebui_settings ?? {});
+    Object.assign(textgenerationwebui_settings, loadedSettings.textgenerationwebui_settings ?? {});
     if (loadedSettings.api_server_textgenerationwebui) {
         for (const type of Object.keys(SERVER_INPUTS)) {
-            settings.server_urls[type] = loadedSettings.api_server_textgenerationwebui;
+            textgenerationwebui_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(settings.server_urls[type] ?? '').on('input', function () {
+        control.val(textgenerationwebui_settings.server_urls[type] ?? '').on('input', function () {
-            settings.server_urls[type] = String($(this).val()).trim();
+            textgenerationwebui_settings.server_urls[type] = String($(this).val()).trim();
             saveSettingsDebounced();
         });
+    }
     if (loadedSettings.api_use_mancer_webui) {
-        settings.type = MANCER;
+        textgenerationwebui_settings.type = MANCER;
+    }
     for (const name of textgenerationwebui_preset_names) {

         $('#settings_preset_textgenerationwebui').append(option);
+    }
-    if (settings.preset) {
+    if (textgenerationwebui_settings.preset) {
-        $('#settings_preset_textgenerationwebui').val(settings.preset);
+        $('#settings_preset_textgenerationwebui').val(textgenerationwebui_settings.preset);
+    }
     for (const i of setting_names) {
-        const value = settings[i];
+        const value = textgenerationwebui_settings[i];
         setSettingByName(i, value);
+    }
-    $('#textgen_type').val(settings.type);
+    $('#textgen_type').val(textgenerationwebui_settings.type);
-    $('#openrouter_providers_text').val(settings.openrouter_providers).trigger('change');
+    $('#openrouter_providers_text').val(textgenerationwebui_settings.openrouter_providers).trigger('change');
-    showSamplerControls(settings.type);
+    showSamplerControls(textgenerationwebui_settings.type);
     BIAS_CACHE.delete(BIAS_KEY);
-    displayLogitBias(settings.logit_bias, BIAS_KEY);
+    displayLogitBias(textgenerationwebui_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	return resultCheckStatus();	653	return resultCheckStatus();
649	}	654	}
650		655
651	if ([textgen_types.GENERIC, textgen_types.OOBA].includes(settings.type) && settings.bypass_status_check) {	656	if ([textgen_types.GENERIC, textgen_types.OOBA].includes(textgenerationwebui_settings.type) && textgenerationwebui_settings.bypass_status_check) {
652	setOnlineStatus(t`Status check bypassed`);	657	setOnlineStatus(t`Status check bypassed`);
653	return resultCheckStatus();	658	return resultCheckStatus();
654	}	659	}

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

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

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

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

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

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

     $('#textgenerationwebui_default_order').on('click', function () {
         sortOobaItemsByOrder(OOBA_DEFAULT_ORDER);
-        settings.sampler_priority = OOBA_DEFAULT_ORDER;
+        textgenerationwebui_settings.sampler_priority = OOBA_DEFAULT_ORDER;
-        console.log('Default samplers order loaded:', settings.sampler_priority);
+        console.log('Default samplers order loaded:', textgenerationwebui_settings.sampler_priority);
         saveSettingsDebounced();
     });
     $('#aphrodite_default_order').on('click', function () {
         sortAphroditeItemsByOrder(APHRODITE_DEFAULT_ORDER);
-        settings.samplers_priorities = APHRODITE_DEFAULT_ORDER;
+        textgenerationwebui_settings.samplers_priorities = APHRODITE_DEFAULT_ORDER;
-        console.log('Default samplers order loaded:', settings.samplers_priorities);
+        console.log('Default samplers order loaded:', textgenerationwebui_settings.samplers_priorities);
         saveSettingsDebounced();
     });
     $('#textgen_type').on('change', function () {
         const type = String($(this).val());
-        settings.type = type;
+        textgenerationwebui_settings.type = type;
-        if ([VLLM, APHRODITE, INFERMATICAI].includes(settings.type)) {
+        if ([VLLM, APHRODITE, INFERMATICAI].includes(textgenerationwebui_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' || settings['top_k'] === 0) {
+            if ($('#top_k_textgenerationwebui').val() === '0' || textgenerationwebui_settings['top_k'] === 0) {
-                settings['top_k'] = -1;
+                textgenerationwebui_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' || settings['top_k'] === -1) {
+            if ($('#top_k_textgenerationwebui').val() === '-1' || textgenerationwebui_settings['top_k'] === -1) {
-                settings['top_k'] = 0;
+                textgenerationwebui_settings['top_k'] = 0;
                 $('#top_k_textgenerationwebui').val('0').trigger('input');
+            }
+        }

@@ -913,7 +918,7 @@ export function initTextGenSettings() {
913		918
914	$('#main_api').trigger('change');	919	$('#main_api').trigger('change');
915		920
916	if (!SERVER_INPUTS[type] \|\| settings.server_urls[type]) {	921	if (!SERVER_INPUTS[type] \|\| textgenerationwebui_settings.server_urls[type]) {
917	$('#api_button_textgenerationwebui').trigger('click');	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(settings.type) ? -1 : 0,
+            'top_k_textgenerationwebui': [INFERMATICAI, APHRODITE, VLLM].includes(textgenerationwebui_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	if (isCheckbox) {	1013	if (isCheckbox) {
1009	const value = $(this).prop('checked');	1014	const value = $(this).prop('checked');
1010	settings[id] = value;	1015	textgenerationwebui_settings[id] = value;
1011	}	1016	}
1012	else if (isText) {	1017	else if (isText) {
1013	const value = $(this).val();	1018	const value = $(this).val();
1014	settings[id] = value;	1019	textgenerationwebui_settings[id] = value;
1015	}	1020	}
1016	else {	1021	else {
1017	const value = Number($(this).val());	1022	const value = Number($(this).val());
1018	$(`#${id}_counter_textgenerationwebui`).val(value);	1023	$(`#${id}_counter_textgenerationwebui`).val(value);
1019	settings[id] = value;	1024	textgenerationwebui_settings[id] = value;
1020	//special handling for vLLM/Aphrodite using -1 as disabled instead of 0	1025	//special handling for vLLM/Aphrodite using -1 as disabled instead of 0
1021	if ($(this).attr('id') === 'top_k_textgenerationwebui' && [INFERMATICAI, APHRODITE, VLLM].includes(settings.type) && value === 0) {	1026	if ($(this).attr('id') === 'top_k_textgenerationwebui' && [INFERMATICAI, APHRODITE, VLLM].includes(textgenerationwebui_settings.type) && value === 0) {
1022	settings[id] = -1;	1027	textgenerationwebui_settings[id] = -1;
1023	$(this).val(-1);	1028	$(this).val(-1);
1024	}	1029	}
1025	}	1030	}

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

             return;
+        }
-        settings.openrouter_providers = selectedProviders;
+        textgenerationwebui_settings.openrouter_providers = selectedProviders;
         saveSettingsDebounced();
     });

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

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

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

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

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

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

 /**
  * Sends a streaming request for textgenerationwebui.
- * @param generate_data
+ * @param {object} generate_data
- * @param signal
+ * @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 (settings.type) {
+    switch (textgenerationwebui_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	export function isJsonSchemaSupported() {	1468	export function isJsonSchemaSupported() {
1458	return [TABBY, LLAMACPP].includes(settings.type) && main_api === 'textgenerationwebui';	1469	return [TABBY, LLAMACPP].includes(textgenerationwebui_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	return settings.dynatemp && DYNATEMP_BLOCK?.dataset?.tgType?.includes(settings.type);	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 ?? settings.type;
+    const selectedType = type ?? textgenerationwebui_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();
+    const dynatemp = isDynamicTemperatureSupported(settings);
-    const { banned_tokens, banned_strings } = getCustomTokenBans();
+    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': model,
         'max_new_tokens': maxTokens,
         'max_tokens': maxTokens,
-        'logprobs': power_user.request_token_probabilities ? getLogprobsNumber() : undefined,
+        '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(),
+        '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	if (Array.isArray(settings.logit_bias) && settings.logit_bias.length) {	1747	if (Array.isArray(settings.logit_bias) && settings.logit_bias.length) {
1716	const logitBias = BIAS_CACHE.get(BIAS_KEY) \|\| calculateLogitBias();	1748	const logitBias = BIAS_CACHE.get(BIAS_KEY) \|\| calculateLogitBias(settings);
1717	BIAS_CACHE.set(BIAS_KEY, logitBias);	1749	BIAS_CACHE.set(BIAS_KEY, logitBias);
1718	params.logit_bias = logitBias;	1750	params.logit_bias = logitBias;
1719	}	1751	}

@@ -1750,8 +1782,12 @@ export async function getTextGenGenerationData(finalPrompt, maxTokens, isImperso
1750	delete params.guided_json;	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	await eventSource.emit(event_types.TEXT_COMPLETION_SETTINGS_READY, params);	1791	await eventSource.emit(event_types.TEXT_COMPLETION_SETTINGS_READY, params);
1755
1756	return params;	1792	return params;
1757	}	1793	}

public/scripts/tool-calling.js+33 -53 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, model_list, oai_settings } from './openai.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() {
+    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_settings.custom_prompt_post_processing)) {
+        if (!allowedPromptPostProcessing.includes(settings.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) {
-            if (currentModel) {
+            switch (settings.chat_completion_source) {
-                return currentModel.tools;
+                case chat_completion_sources.POLLINATIONS:
-            }
+                    return currentModel.tools;
-        }
+                case chat_completion_sources.FIREWORKS:
+                    return currentModel.supports_tools;
-        if (oai_settings.chat_completion_source === chat_completion_sources.FIREWORKS && Array.isArray(model_list)) {
+                case chat_completion_sources.OPENROUTER:
-            const currentModel = model_list.find(model => model.id === oai_settings.fireworks_model);
+                    return currentModel.supported_parameters?.includes('tools');
-            if (currentModel) {
+                case chat_completion_sources.MISTRALAI:
-                return currentModel.supports_tools;
+                    return currentModel.capabilities?.function_calling;
-            }
+                case chat_completion_sources.AIMLAPI:
-        }
+                    return currentModel.features?.includes('openai/chat-completion.function');
+                case chat_completion_sources.CHUTES:
-        if (oai_settings.chat_completion_source === chat_completion_sources.OPENROUTER && Array.isArray(model_list)) {
+                    return currentModel.supported_features?.includes('tools');
-            const currentModel = model_list.find(model => model.id === oai_settings.openrouter_model);
+                case chat_completion_sources.ELECTRONHUB:
-            if (Array.isArray(currentModel?.supported_parameters)) {
+                    return currentModel.metadata?.function_call;
-                return currentModel.supported_parameters.includes('tools');
-            }
-        }
-        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');
-            }
-        }
-        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_settings.chat_completion_source);
+        return supportedSources.includes(settings.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) {
+    static canPerformToolCalls(type, settings = null, model = null) {
+        settings = settings ?? oai_settings;
+        model = model ?? getChatCompletionModel(settings);
         const noToolCallTypes = ['impersonate', 'quiet', 'continue'];
-        const isSupported = ToolManager.isToolCallingSupported();
+        const isSupported = ToolManager.isToolCallingSupported(settings, model);
         return isSupported && !noToolCallTypes.includes(type);
+    }