Add {{maxContext}}, {{maxResponse}} macros and {{maxPromptTokens}} alias (#5176) * Initial plan * Add maxContext, maxResponse macros and maxPromptTokens alias Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com> * Refactor getMaxContextSize to use getMaxContextTokens/getMaxResponseTokens and remove maxReply aliases Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com> * Align aliases in single line * Rename getMaxPromptTokens --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: Cohee1207 <18619528+Cohee1207@users.noreply.github.com>

eeda4d377ee2d4fb21f536ae793cda6d1673b449

Copilot <198982749+Copilot@users.noreply.github.com>

Signed

Parents: 3bd10346394c4ef29a0a550efc1f22b0e66e07a4

public/script.js+37 -15 Viewed

     setCharacterSettingsOverrides as setScenarioOverride,
     /** @deprecated Use appendMediaToMessage instead. */
     appendMediaToMessage as appendImageToMessage,
+    /** @deprecated Use getMaxPromptTokens instead. */
+    getMaxPromptTokens as getMaxContextSize,
 };
 /**

+    }
     // Determine token limit
-    let this_max_context = getMaxContextSize();
+    let this_max_context = getMaxPromptTokens();
     if (!dryRun) {
         console.debug('Running extension interceptors');

+}
 /**
- * Gets the maximum usable context size for the current API.
+ * Gets the maximum context token limit (the full context window size before subtracting response length).
- * @param {number|null} overrideResponseLength Optional override for the response length.
+ * @returns {number} The maximum context token limit for the current API.
- * @returns {number} Maximum usable context size.
  */
-export function getMaxContextSize(overrideResponseLength = null) {
+export function getMaxContextTokens() {
-    if (typeof overrideResponseLength !== 'number' || overrideResponseLength <= 0 || isNaN(overrideResponseLength)) {
-        overrideResponseLength = null;
-    }
-    let this_max_context = 1487;
     if (main_api == 'kobold' || main_api == 'koboldhorde' || main_api == 'textgenerationwebui') {
-        this_max_context = (max_context - (overrideResponseLength || amount_gen));
+        return max_context;
+    }
     if (main_api == 'novel') {
-        this_max_context = Number(max_context);
+        let this_max_context = Number(max_context);
         if (nai_settings.model_novel.includes('clio')) {
             this_max_context = Math.min(max_context, 8192);
+        }

             // Added special tokens and whatnot
             this_max_context -= 10;
+        }
+        return this_max_context;
+    }
+    if (main_api == 'openai') {
+        return oai_settings.openai_max_context;
+    }
+    return 1487;
+}
-        this_max_context = this_max_context - (overrideResponseLength || amount_gen);
+/**
+ * Gets the maximum response token limit (the max generation/reply length).
+ * @returns {number} The maximum response token limit for the current API.
+ */
+export function getMaxResponseTokens() {
+    if (main_api == 'kobold' || main_api == 'koboldhorde' || main_api == 'textgenerationwebui' || main_api == 'novel') {
+        return amount_gen;
+    }
     if (main_api == 'openai') {
-        this_max_context = oai_settings.openai_max_context - (overrideResponseLength || oai_settings.openai_max_tokens);
+        return oai_settings.openai_max_tokens;
+    }
+    return 0;
+}
+/**
+ * Gets the maximum usable prompt size for the current API.
+ * @param {number|null} overrideResponseLength Optional override for the response length.
+ * @returns {number} Maximum usable prompt size.
+ */
+export function getMaxPromptTokens(overrideResponseLength = null) {
+    if (typeof overrideResponseLength !== 'number' || overrideResponseLength <= 0 || isNaN(overrideResponseLength)) {
+        overrideResponseLength = null;
+    }
-    return this_max_context;
+    return getMaxContextTokens() - (overrideResponseLength || getMaxResponseTokens());
+}
 function parseTokenCounts(counts, thisPromptBits) {

public/scripts/extensions/memory/index.js+2 -2 Viewed

     saveSettingsDebounced,
     substituteParamsExtended,
     generateRaw,
-    getMaxContextSize,
+    getMaxPromptTokens,
     setExtensionPrompt,
     streamingProcessor,
     animation_easing,

@@ -71,7 +71,7 @@ async function getSourceContextSize() {
71	return 1024 - 64;	71	return 1024 - 64;
72	}	72	}
73		73
74	return getMaxContextSize(overrideLength);	74	return getMaxPromptTokens(overrideLength);
75	}	75	}
76		76
77	const formatMemoryValue = function (value) {	77	const formatMemoryValue = function (value) {

public/scripts/macros.js+7 -2 Viewed

 import { Handlebars, moment, seedrandom, droll } from '../lib.js';
-import { chat, chat_metadata, main_api, getMaxContextSize, getCurrentChatId, substituteParams, eventSource, event_types, extension_prompts } from '../script.js';
+import { chat, chat_metadata, main_api, getMaxPromptTokens, getMaxContextTokens, getMaxResponseTokens, getCurrentChatId, substituteParams, eventSource, event_types, extension_prompts } from '../script.js';
 import { timestampToMoment, isDigitsOnly, getStringHash, escapeRegex, uuidv4 } from './utils.js';
 import { textgenerationwebui_banned_in_macros } from './textgen-settings.js';
 import { getInstructMacros } from './instruct-mode.js';

      * @type {Macro[]}
     */
     const postEnvMacros = [
-        { regex: /{{maxPrompt}}/gi, replace: () => String(getMaxContextSize()) },
+        { regex: /{{maxPrompt}}/gi, replace: () => String(getMaxPromptTokens()) },
+        { regex: /{{maxPromptTokens}}/gi, replace: () => String(getMaxPromptTokens()) },
+        { regex: /{{maxContext}}/gi, replace: () => String(getMaxContextTokens()) },
+        { regex: /{{maxContextTokens}}/gi, replace: () => String(getMaxContextTokens()) },
+        { regex: /{{maxResponse}}/gi, replace: () => String(getMaxResponseTokens()) },
+        { regex: /{{maxResponseTokens}}/gi, replace: () => String(getMaxResponseTokens()) },
         { regex: /{{lastMessage}}/gi, replace: () => getLastMessage() },
         { regex: /{{lastMessageId}}/gi, replace: () => String(getLastMessageId() ?? '') },
         { regex: /{{lastUserMessage}}/gi, replace: () => getLastUserMessage() },

public/scripts/macros/definitions/core-macros.js+24 -3 Viewed

 import { seedrandom, droll } from '../../../lib.js';
-import { chat_metadata, main_api, getMaxContextSize, extension_prompts, getCurrentChatId } from '../../../script.js';
+import { chat_metadata, main_api, getMaxPromptTokens, getMaxContextTokens, getMaxResponseTokens, extension_prompts, getCurrentChatId } from '../../../script.js';
 import { getStringHash, isFalseBoolean } from '../../utils.js';
 import { textgenerationwebui_banned_in_macros } from '../../textgen-settings.js';
 import { inject_ids } from '../../constants.js';

         handler: () => (/** @type {HTMLTextAreaElement} */(document.querySelector('#send_textarea')))?.value ?? '',
     });
-    // {{maxPrompt}} -> max context size
+    // {{maxPrompt}} -> max context size (context minus response)
     MacroRegistry.registerMacro('maxPrompt', {
+        aliases: [{ alias: 'maxPromptTokens', visible: true }],
         category: MacroCategory.STATE,
         description: 'Maximum prompt context size.',
         returns: 'Maximum prompt context size.',
         returnType: MacroValueType.INTEGER,
-        handler: () => String(getMaxContextSize()),
+        handler: () => String(getMaxPromptTokens()),
+    });
+    // {{maxContext}} -> max context token limit
+    MacroRegistry.registerMacro('maxContext', {
+        aliases: [{ alias: 'maxContextTokens', visible: true }],
+        category: MacroCategory.STATE,
+        description: 'Maximum context token limit.',
+        returns: 'Maximum context token limit.',
+        returnType: MacroValueType.INTEGER,
+        handler: () => String(getMaxContextTokens()),
+    });
+    // {{maxResponse}} -> max response token limit
+    MacroRegistry.registerMacro('maxResponse', {
+        aliases: [{ alias: 'maxResponseTokens', visible: true }],
+        category: MacroCategory.STATE,
+        description: 'Maximum response token limit.',
+        returns: 'Maximum response token limit.',
+        returnType: MacroValueType.INTEGER,
+        handler: () => String(getMaxResponseTokens()),
     });
     // String utilities