Merge branch 'staging' into vision-cleanup

3fd12b28dc58c2f408a6aba66c6a8092e888c366

equal-l2 <eng.equall2@gmail.com>

Parents: 903839c9c50055db58fd2c6eb6010ded385df7f7 c16be2ec0e48b6d8df393bbffea8c2fbeb179ee8

public/index.html+7 -3 Viewed

                                             </span>
                                         </div>
                                     </div>
-                                    <div class="flex-container flexFlowColumn wide100p textAlignCenter marginTop10" data-source="openai,custom,claude,xai">
+                                    <div class="flex-container flexFlowColumn wide100p textAlignCenter marginTop10" data-source="openai,custom,claude,xai,makersuite,openrouter">
-                                        <div class="flex-container oneline-dropdown" title="Constrains effort on reasoning for reasoning models.&#10;Currently supported values are low, medium, and high.&#10;Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response." data-i18n="[title]Constrains effort on reasoning for reasoning models.">
+                                        <div class="flex-container oneline-dropdown" title="Constrains effort on reasoning for reasoning models.&#10;Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response." data-i18n="[title]Constrains effort on reasoning for reasoning models.">
                                             <label for="openai_reasoning_effort">
                                                 <span data-i18n="Reasoning Effort">Reasoning Effort</span>
-                                                <i data-source="claude" class="opacity50p fa-solid fa-circle-info" title="Allocates a portion of the response length for thinking (low: 10%, medium: 25%, high: 50%), but minimum 1024 tokens."></i>
+                                                <i data-source="openai,custom,xai,openrouter" class="opacity50p fa-solid fa-circle-info" title="OpenAI-style options: low, medium, high. Minimum and maximum are aliased to low and high. Auto does not send an effort level."></i>
+                                                <i data-source="claude,makersuite" class="opacity50p fa-solid fa-circle-info" title="Allocates a portion of the response length for thinking (low: 10%, medium: 25%, high: 50%). Other options are model-dependent."></i>
                                             </label>
                                             <select id="openai_reasoning_effort">
+                                                <option data-i18n="openai_reasoning_effort_auto" value="auto">Auto</option>
+                                                <option data-i18n="openai_reasoning_effort_minimum" value="min">Mininum</option>
                                                 <option data-i18n="openai_reasoning_effort_low" value="low">Low</option>
                                                 <option data-i18n="openai_reasoning_effort_medium" value="medium">Medium</option>
                                                 <option data-i18n="openai_reasoning_effort_high" value="high">High</option>
+                                                <option data-i18n="openai_reasoning_effort_maximum" value="max">Maximum</option>
                                             </select>
                                         </div>
                                     </div>

public/script.js+15 -7 Viewed

             throw new Error(result.statusText);
+        }
-        const forceSaveConfirmed = await Popup.show.confirm(
+        const popupResult = await Popup.show.input(
-            t`ERROR: Chat integrity check failed.`,
+            t`ERROR: Chat integrity check failed while saving the file.`,
-            t`Continuing the operation may result in data loss. Would you like to overwrite the chat file anyway? Pressing "NO" will cancel the save operation.`,
+            t`<p>After you click OK, the page will be reloaded to prevent data corruption.</p>
-            { okButton: t`Yes, overwrite`, cancelButton: t`No, cancel` },
+              <p>To confirm an overwrite (and potentially <b>LOSE YOUR DATA</b>), enter <code>OVERWRITE</code> (in all caps) in the box below before clicking OK.</p>`,
-        ) === POPUP_RESULT.AFFIRMATIVE;
+            '',
+            { okButton: 'OK', cancelButton: false },
+        );
-        if (forceSaveConfirmed) {
+        const forceSaveConfirmed = popupResult === 'OVERWRITE';
-            await saveChat({ chatName, withMetadata, mesId, force: true });
+        if (!forceSaveConfirmed) {
+            console.warn('Chat integrity check failed, and user did not confirm the overwrite. Reloading the page.');
+            window.location.reload();
+            return;
+        }
+        await saveChat({ chatName, withMetadata, mesId, force: true });
     } catch (error) {
         console.error(error);
         toastr.error(t`Check the server connection and reload the page to prevent data loss.`, t`Chat could not be saved`);

public/scripts/openai.js+37 -3 Viewed

     OFF: 'off',
 };
+export const reasoning_effort_types = {
+    auto: 'auto',
+    low: 'low',
+    medium: 'medium',
+    high: 'high',
+    min: 'min',
+    max: 'max',
+};
 const sensitiveFields = [
     'reverse_proxy',
     'proxy_password',

     continue_postfix: continue_postfix_types.SPACE,
     custom_prompt_post_processing: custom_prompt_post_processing_types.NONE,
     show_thoughts: true,
-    reasoning_effort: 'medium',
+    reasoning_effort: reasoning_effort_types.auto,
     enable_web_search: false,
     request_images: false,
     seed: -1,

     continue_postfix: continue_postfix_types.SPACE,
     custom_prompt_post_processing: custom_prompt_post_processing_types.NONE,
     show_thoughts: true,
-    reasoning_effort: 'medium',
+    reasoning_effort: reasoning_effort_types.auto,
     enable_web_search: false,
     request_images: false,
     seed: -1,

     return data.output;
+}
+function getReasoningEffort() {
+    // These sources expect the effort as string.
+    const reasoningEffortSources = [
+        chat_completion_sources.OPENAI,
+        chat_completion_sources.CUSTOM,
+        chat_completion_sources.XAI,
+        chat_completion_sources.OPENROUTER,
+    ];
+    if (!reasoningEffortSources.includes(oai_settings.chat_completion_source)) {
+        return oai_settings.reasoning_effort;
+    }
+    switch (oai_settings.reasoning_effort) {
+        case reasoning_effort_types.auto:
+            return undefined;
+        case reasoning_effort_types.min:
+            return reasoning_effort_types.low;
+        case reasoning_effort_types.max:
+            return reasoning_effort_types.high;
+        default:
+            return oai_settings.reasoning_effort;
+    }
+}
 /**
  * Send a chat completion request to backend
  * @param {string} type (impersonate, quiet, continue, etc)

         'char_name': name2,
         'group_names': getGroupNames(),
         'include_reasoning': Boolean(oai_settings.show_thoughts),
-        'reasoning_effort': String(oai_settings.reasoning_effort),
+        'reasoning_effort': getReasoningEffort(),
         'enable_web_search': Boolean(oai_settings.enable_web_search),
         'request_images': Boolean(oai_settings.request_images),
         'custom_prompt_post_processing': oai_settings.custom_prompt_post_processing,

src/endpoints/backends/chat-completions.js+24 -5 Viewed

     cachingAtDepthForOpenRouterClaude,
     cachingAtDepthForClaude,
     getPromptNames,
-    calculateBudgetTokens,
+    calculateClaudeBudgetTokens,
+    calculateGoogleBudgetTokens,
 } from '../../prompt-converters.js';
 import { readSecret, SECRET_KEYS } from '../secrets.js';

             // No prefill when thinking
             voidPrefill = true;
             const reasoningEffort = request.body.reasoning_effort;
-            const budgetTokens = calculateBudgetTokens(requestBody.max_tokens, reasoningEffort, requestBody.stream);
+            const budgetTokens = calculateClaudeBudgetTokens(requestBody.max_tokens, reasoningEffort, requestBody.stream);
             const minThinkTokens = 1024;
             if (requestBody.max_tokens <= minThinkTokens) {
                 const newValue = requestBody.max_tokens + minThinkTokens;

     const stream = Boolean(request.body.stream);
     const enableWebSearch = Boolean(request.body.enable_web_search);
     const requestImages = Boolean(request.body.request_images);
+    const reasoningEffort = String(request.body.reasoning_effort);
     const isThinking = model.includes('thinking');
     const isGemma = model.includes('gemma');

             tools.push({ function_declarations: functionDeclarations });
+        }
+        // One more models list to maintain, yay
+        const thinkingBudgetModels = [
+            'gemini-2.5-flash-preview-04-17',
+        ];
+        if (thinkingBudgetModels.includes(model)) {
+            const thinkingBudget = calculateGoogleBudgetTokens(generationConfig.maxOutputTokens, reasoningEffort);
+            if (Number.isInteger(thinkingBudget)) {
+                generationConfig.thinkingConfig = { thinkingBudget: thinkingBudget };
+            }
+        }
         let body = {
             contents: prompt.contents,
             safetySettings: safetySettings,
             generationConfig: generationConfig,
         };
-        if (useSystemPrompt) {
+        if (useSystemPrompt && Array.isArray(prompt.system_instruction.parts) && prompt.system_instruction.parts.length) {
             body.systemInstruction = prompt.system_instruction;
+        }

@@ -868,7 +883,7 @@ async function sendXaiRequest(request, response) {
868	bodyParams['stop'] = request.body.stop;	883	bodyParams['stop'] = request.body.stop;
869	}	884	}
870		885
871	if (['grok-3-mini-beta', 'grok-3-mini-fast-beta'].includes(request.body.model)) {	886	if (request.body.reasoning_effort && ['grok-3-mini-beta', 'grok-3-mini-fast-beta'].includes(request.body.model)) {
872	bodyParams['reasoning_effort'] = request.body.reasoning_effort === 'high' ? 'high' : 'low';	887	bodyParams['reasoning_effort'] = request.body.reasoning_effort === 'high' ? 'high' : 'low';
873	}	888	}
874		889

             bodyParams['route'] = 'fallback';
+        }
+        if (request.body.reasoning_effort) {
+            bodyParams['reasoning'] = { effort: request.body.reasoning_effort };
+        }
         let cachingAtDepth = getConfigValue('claude.cachingAtDepth', -1, 'number');
         if (Number.isInteger(cachingAtDepth) && cachingAtDepth >= 0 && request.body.model?.startsWith('anthropic/claude-3')) {
             cachingAtDepthForOpenRouterClaude(request.body.messages, cachingAtDepth);

@@ -1258,7 +1277,7 @@ router.post('/generate', function (request, response) {
1258	}	1277	}
1259		1278
1260	// A few of OpenAIs reasoning models support reasoning effort	1279	// A few of OpenAIs reasoning models support reasoning effort
1261	if ([CHAT_COMPLETION_SOURCES.CUSTOM, CHAT_COMPLETION_SOURCES.OPENAI].includes(request.body.chat_completion_source)) {	1280	if (request.body.reasoning_effort && [CHAT_COMPLETION_SOURCES.CUSTOM, CHAT_COMPLETION_SOURCES.OPENAI].includes(request.body.chat_completion_source)) {
1262	if (['o1', 'o3-mini', 'o3-mini-2025-01-31', 'o4-mini', 'o4-mini-2025-04-16', 'o3', 'o3-2025-04-16'].includes(request.body.model)) {	1281	if (['o1', 'o3-mini', 'o3-mini-2025-01-31', 'o4-mini', 'o4-mini-2025-04-16', 'o3', 'o3-2025-04-16'].includes(request.body.model)) {
1263	bodyParams['reasoning_effort'] = request.body.reasoning_effort;	1282	bodyParams['reasoning_effort'] = request.body.reasoning_effort;
1264	}	1283	}

src/prompt-converters.js+59 -9 Viewed

 const PROMPT_PLACEHOLDER = getConfigValue('promptPlaceholder', 'Let\'s get started.');
+const REASONING_EFFORT = {
+    auto: 'auto',
+    low: 'low',
+    medium: 'medium',
+    high: 'high',
+    min: 'min',
+    max: 'max',
+};
 /**
  * @typedef {object} PromptNames
  * @property {string} charName Character name

  * @param {string} model Model name
  * @param {boolean} useSysPrompt Use system prompt
  * @param {PromptNames} names Prompt names
- * @returns {{contents: *[], system_instruction: {parts: {text: string}}}} Prompt for Google MakerSuite models
+ * @returns {{contents: *[], system_instruction: {parts: {text: string}[]}}} Prompt for Google MakerSuite models
  */
 export function convertGooglePrompt(messages, model, useSysPrompt, names) {
     const visionSupportedModelPrefix = [

     ];
     const isMultimodal = visionSupportedModelPrefix.some(prefix => model.startsWith(prefix));
+    const sysPrompt = [];
-    let sys_prompt = '';
     if (useSysPrompt) {
         while (messages.length > 1 && messages[0].role === 'system') {
             // Append example names if not already done by the frontend (e.g. for group chats).

@@ -384,12 +393,12 @@ export function convertGooglePrompt(messages, model, useSysPrompt, names) {
384	messages[0].content = `${names.charName}: ${messages[0].content}`;	393	messages[0].content = `${names.charName}: ${messages[0].content}`;
385	}	394	}
386	}	395	}
387	sys_prompt += `${messages[0].content}\n\n`;	396	sysPrompt.push(messages[0].content);
388	messages.shift();	397	messages.shift();
389	}	398	}
390	}	399	}
391		400
392	const system_instruction = { parts: [{ text: sys_prompt.trim() }] };	401	const system_instruction = { parts: sysPrompt.map(text => ({ text })) };
393	const toolNameMap = {};	402	const toolNameMap = {};
394		403
395	const contents = [];	404	const contents = [];

+}
 /**
- * Calculate the budget tokens for a given reasoning effort.
+ * Calculate the Claude budget tokens for a given reasoning effort.
  * @param {number} maxTokens Maximum tokens
  * @param {string} reasoningEffort Reasoning effort
  * @param {boolean} stream If streaming is enabled
  * @returns {number} Budget tokens
  */
-export function calculateBudgetTokens(maxTokens, reasoningEffort, stream) {
+export function calculateClaudeBudgetTokens(maxTokens, reasoningEffort, stream) {
     let budgetTokens = 0;
     switch (reasoningEffort) {
-        case 'low':
+        case REASONING_EFFORT.min:
+            budgetTokens = 1024;
+            break;
+        case REASONING_EFFORT.low:
             budgetTokens = Math.floor(maxTokens * 0.1);
             break;
-        case 'medium':
+        case REASONING_EFFORT.auto:
+        case REASONING_EFFORT.medium:
             budgetTokens = Math.floor(maxTokens * 0.25);
             break;
-        case 'high':
+        case REASONING_EFFORT.high:
             budgetTokens = Math.floor(maxTokens * 0.5);
             break;
+        case REASONING_EFFORT.max:
+            budgetTokens = Math.floor(maxTokens * 0.95);
+            break;
+    }
     budgetTokens = Math.max(budgetTokens, 1024);

     return budgetTokens;
+}
+/**
+ * Calculate the Google budget tokens for a given reasoning effort.
+ * @param {number} maxTokens Maximum tokens
+ * @param {string} reasoningEffort Reasoning effort
+ * @returns {number?} Budget tokens
+ */
+export function calculateGoogleBudgetTokens(maxTokens, reasoningEffort) {
+    let budgetTokens = 0;
+    switch (reasoningEffort) {
+        case REASONING_EFFORT.auto:
+            return null;
+        case REASONING_EFFORT.min:
+            budgetTokens = 0;
+            break;
+        case REASONING_EFFORT.low:
+            budgetTokens = Math.floor(maxTokens * 0.1);
+            break;
+        case REASONING_EFFORT.medium:
+            budgetTokens = Math.floor(maxTokens * 0.25);
+            break;
+        case REASONING_EFFORT.high:
+            budgetTokens = Math.floor(maxTokens * 0.5);
+            break;
+        case REASONING_EFFORT.max:
+            budgetTokens = maxTokens;
+            break;
+    }
+    budgetTokens = Math.min(budgetTokens, 24576);
+    return budgetTokens;
+}