Merge pull request #3766 from bmen25124/custom_request_stop_string_cleanup Added stop string cleanup, better stopping string param

0a85178846cfd268a9fdd5fc4f78f7918155c3c8

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

Signed

Parents: 74efb598f197e9e31b3d028984a894459af048c4 d93aba5706a084e90dee5b5e26ff85151a00d3d7

public/scripts/custom-request.js+67 -8 Viewed

 import { extractMessageFromData, getGenerateUrl, getRequestHeaders } from '../script.js';
 import { getTextGenServer } from './textgen-settings.js';
 import { extractReasoningFromData } from './reasoning.js';
-import { formatInstructModeChat, formatInstructModePrompt, names_behavior_types } from './instruct-mode.js';
+import { formatInstructModeChat, formatInstructModePrompt, getInstructStoppingSequences, names_behavior_types } from './instruct-mode.js';
 import { getStreamingReply, tryParseStreamingError } from './openai.js';
 import EventSourceStream from './sse-stream.js';

      * @param {Object} options - Configuration options
      * @param {string?} [options.presetName] - Name of the preset to use for generation settings
      * @param {string?} [options.instructName] - Name of instruct preset for message formatting
+     * @param {Partial<InstructSettings>?} [options.instructSettings] - Override instruct settings
      * @param {boolean} extractData - Whether to extract structured data from response
      * @param {AbortSignal?} [signal]
      * @returns {Promise<ExtractedData | (() => AsyncGenerator<StreamResponse>)>} If not streaming, returns extracted data; if streaming, returns a function that creates an AsyncGenerator

+            }
+        }
+        /** @type {InstructSettings | undefined} */
+        let instructPreset;
         // Handle instruct formatting if requested
         if (Array.isArray(prompt) && instructName) {
             const instructPresetManager = getPresetManager('instruct');
-            let instructPreset = instructPresetManager?.getCompletionPresetByName(instructName);
+            instructPreset = instructPresetManager?.getCompletionPresetByName(instructName);
             if (instructPreset) {
                 // Clone the preset to avoid modifying the original
                 instructPreset = structuredClone(instructPreset);
-                instructPreset.macro = false;
                 instructPreset.names_behavior = names_behavior_types.NONE;
+                if (options.instructSettings) {
+                    Object.assign(instructPreset, options.instructSettings);
+                }
                 // Format messages using instruct formatting
                 const formattedMessages = [];

                     formattedMessages.push(messageContent);
+                }
                 requestData.prompt = formattedMessages.join('');
-                if (instructPreset.output_suffix) {
+                const stoppingStrings = getInstructStoppingSequences({ customInstruct: instructPreset, useStopStrings: false });
-                    requestData.stop = [instructPreset.output_suffix];
+                requestData.stop = stoppingStrings;
-                    requestData.stopping_strings = [instructPreset.output_suffix];
+                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');

         // @ts-ignore
         const data = this.createRequestData(requestData);
-        return await this.sendRequest(data, extractData, signal);
+        const response = await this.sendRequest(data, extractData, signal);
+        // Remove stopping strings from the end
+        if (!data.stream && extractData) {
+            /** @type {ExtractedData} */
+            // @ts-ignore
+            const extractedData = response;
+            let message = extractedData.content;
+            message = message.replace(/[^\S\r\n]+$/gm, '');
+            if (requestData.stopping_strings) {
+                for (const stoppingString of requestData.stopping_strings) {
+                    if (stoppingString.length) {
+                        for (let j = stoppingString.length; j > 0; j--) {
+                            if (message.slice(-j) === stoppingString.slice(0, j)) {
+                                message = message.slice(0, -j);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (instructPreset) {
+                [
+                    instructPreset.stop_sequence,
+                    instructPreset.input_sequence,
+                ].forEach(sequence => {
+                    if (sequence?.trim()) {
+                        const index = message.indexOf(sequence);
+                        if (index !== -1) {
+                            message = message.substring(0, index);
+                        }
+                    }
+                });
+                [
+                    instructPreset.output_sequence,
+                    instructPreset.last_output_sequence,
+                ].forEach(sequences => {
+                    if (sequences) {
+                        sequences.split('\n')
+                            .filter(line => line.trim() !== '')
+                            .forEach(line => {
+                                message = message.replaceAll(line, '');
+                            });
+                    }
+                });
+            }
+            extractedData.content = message;
+        }
+        return response;
+    }
     /**

public/scripts/extensions/shared.js+10 -2 Viewed

         extractData: true,
         includePreset: true,
         includeInstruct: true,
+        instructSettings: {},
     };
     static getAllowedTypes() {

      * @param {string} profileId
      * @param {string | (import('../custom-request.js').ChatCompletionMessage & {ignoreInstruct?: boolean})[]} prompt
      * @param {number} maxTokens
-     * @param {{stream?: boolean, signal?: AbortSignal, extractData?: boolean, includePreset?: boolean, includeInstruct?: boolean}} custom - default values are true
+     * @param {Object} custom
+     * @param {boolean?} [custom.stream=false]
+     * @param {AbortSignal?} [custom.signal]
+     * @param {boolean?} [custom.extractData=true]
+     * @param {boolean?} [custom.includePreset=true]
+     * @param {boolean?} [custom.includeInstruct=true]
+     * @param {Partial<InstructSettings>?} [custom.instructSettings] Override instruct settings
      * @returns {Promise<import('../custom-request.js').ExtractedData | (() => AsyncGenerator<import('../custom-request.js').StreamResponse>)>} If not streaming, returns extracted data; if streaming, returns a function that creates an AsyncGenerator
      */
     static async sendRequest(profileId, prompt, maxTokens, custom = this.defaultSendRequestParams) {
-        const { stream, signal, extractData, includePreset, includeInstruct } = { ...this.defaultSendRequestParams, ...custom };
+        const { stream, signal, extractData, includePreset, includeInstruct, instructSettings } = { ...this.defaultSendRequestParams, ...custom };
         const context = SillyTavern.getContext();
         if (context.extensionSettings.disabledExtensions.includes('connection-manager')) {

                     }, {
                         instructName: includeInstruct ? profile.instruct : undefined,
                         presetName: includePreset ? profile.preset : undefined,
+                        instructSettings: includeInstruct ? instructSettings : undefined,
                     }, extractData, signal);
+                }
                 default: {

public/scripts/instruct-mode.js+18 -12 Viewed

 /**
  * Converts instruct mode sequences to an array of stopping strings.
+ * @param {Object} options
+ * @param {InstructSettings?} [options.customInstruct=null] - Custom instruct settings.
+ * @param {boolean?} [options.useStopStrings] - Decides whether to use "Chat Start" and "Example Separator"
  * @returns {string[]} Array of instruct mode stopping strings.
  */
-export function getInstructStoppingSequences() {
+export function getInstructStoppingSequences({ customInstruct = null, useStopStrings = null } = {}) {
+    const instruct = structuredClone(customInstruct ?? power_user.instruct);
     /**
      * Adds instruct mode sequence to the result array.
      * @param {string} sequence Sequence string.

     function addInstructSequence(sequence) {
         // Cohee: oobabooga's textgen always appends newline before the sequence as a stopping string
         // But it's a problem for Metharme which doesn't use newlines to separate them.
-        const wrap = (s) => power_user.instruct.wrap ? '\n' + s : s;
+        const wrap = (s) => instruct.wrap ? '\n' + s : s;
         // Sequence must be a non-empty string
         if (typeof sequence === 'string' && sequence.length > 0) {
             // If sequence is just a whitespace or newline - we don't want to make it a stopping string

@@ -262,7 +267,7 @@ export function getInstructStoppingSequences() {
262	if (sequence.trim().length > 0) {	267	if (sequence.trim().length > 0) {
263	const wrappedSequence = wrap(sequence);	268	const wrappedSequence = wrap(sequence);
264	// Need to respect "insert macro" setting	269	// Need to respect "insert macro" setting
265	const stopString = power_user.instruct.macro ? substituteParams(wrappedSequence) : wrappedSequence;	270	const stopString = instruct.macro ? substituteParams(wrappedSequence) : wrappedSequence;
266	result.push(stopString);	271	result.push(stopString);
267	}	272	}
268	}	273	}

     const result = [];
-    if (power_user.instruct.enabled) {
+    // Since preset's don't have "enabled", we assume it's always enabled
-        const stop_sequence = power_user.instruct.stop_sequence || '';
+    if (customInstruct ?? instruct.enabled) {
-        const input_sequence = power_user.instruct.input_sequence?.replace(/{{name}}/gi, name1) || '';
+        const stop_sequence = instruct.stop_sequence || '';
-        const output_sequence = power_user.instruct.output_sequence?.replace(/{{name}}/gi, name2) || '';
+        const input_sequence = instruct.input_sequence?.replace(/{{name}}/gi, name1) || '';
-        const first_output_sequence = power_user.instruct.first_output_sequence?.replace(/{{name}}/gi, name2) || '';
+        const output_sequence = instruct.output_sequence?.replace(/{{name}}/gi, name2) || '';
-        const last_output_sequence = power_user.instruct.last_output_sequence?.replace(/{{name}}/gi, name2) || '';
+        const first_output_sequence = instruct.first_output_sequence?.replace(/{{name}}/gi, name2) || '';
-        const system_sequence = power_user.instruct.system_sequence?.replace(/{{name}}/gi, 'System') || '';
+        const last_output_sequence = instruct.last_output_sequence?.replace(/{{name}}/gi, name2) || '';
-        const last_system_sequence = power_user.instruct.last_system_sequence?.replace(/{{name}}/gi, 'System') || '';
+        const system_sequence = instruct.system_sequence?.replace(/{{name}}/gi, 'System') || '';
+        const last_system_sequence = instruct.last_system_sequence?.replace(/{{name}}/gi, 'System') || '';
         const combined_sequence = [
             stop_sequence,

@@ -292,7 +298,7 @@ export function getInstructStoppingSequences() {
292	combined_sequence.split('\n').filter((line, index, self) => self.indexOf(line) === index).forEach(addInstructSequence);	298	combined_sequence.split('\n').filter((line, index, self) => self.indexOf(line) === index).forEach(addInstructSequence);
293	}	299	}
294		300
295	if (power_user.context.use_stop_strings) {	301	if (useStopStrings ?? power_user.context.use_stop_strings) {
296	if (power_user.context.chat_start) {	302	if (power_user.context.chat_start) {
297	result.push(`\n${substituteParams(power_user.context.chat_start)}`);	303	result.push(`\n${substituteParams(power_user.context.chat_start)}`);
298	}	304	}