Added stop string cleanup, better stopping string param

c5f251c6e376701a273876affaa7a87910420453

bmen25124 <bmen25124@gmail.com>

Parents: f4eb32c71c78bcdc0ee87bbbd91a67c9990bff29

public/scripts/custom-request.js+65 -7 Viewed

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

+            }
+        }
++
 +        /** @type {InstructSettings | undefined} */
 +        let instructPreset;
         // Handle instruct formatting if requested
         if (Array.isArray(prompt) && instructName) {
             const instructPresetManager = getPresetManager('instruct');
             let instructPreset = instructPresetManager?.getCompletionPresetByName(instructName);
             if (instructPreset) {
                 // Clone the preset to avoid modifying the original
                 instructPreset = structuredClone(instructPreset);

                     formattedMessages.push(messageContent);
+                }
                 requestData.prompt = formattedMessages.join('');
 -                if (instructPreset.output_suffix) {
 +                const stoppingStrings = getInstructStoppingSequences({ customInstruct: instructPreset, useStopString: false });
                                     requestData.stop = [instructPreset.output_suffix];stoppingStrings
                                     requestData.stopping_strings = [instructPreset.output_suffix]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);
         returnconst 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) {
 +                if (instructPreset.stop_sequence) {
 +                    const index = message.indexOf(instructPreset.stop_sequence);
 +                    if (index != -1) {
 +                        message = message.substring(0, index);
 +                    }
 +                }
 +                if (instructPreset.input_sequence && instructPreset.input_sequence.trim()) {
 +                    const index = message.indexOf(instructPreset.input_sequence);
 +                    if (index != -1) {
 +                        message = message.substring(0, index);
 +                    }
 +                }
 +                if (instructPreset.output_sequence) {
 +                    instructPreset.output_sequence.split('\n')
 +                        .filter(line => line.trim() !== '')
 +                        .forEach(line => {
 +                            message = message.replaceAll(line, '');
 +                        });
 +                }
 +                if (instructPreset.last_output_sequence) {
 +                    instructPreset.last_output_sequence.split('\n')
 +                        .filter(line => line.trim() !== '')
 +                        .forEach(line => {
 +                            message = message.replaceAll(line, '');
 +                        });
 +                }
 +            }
++
 +            extractedData.content = message;
 +        }
++
 +        return response;
+    }
     /**

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

 /**
  * Converts instruct mode sequences to an array of stopping strings.
 + * @param {{customInstruct?: InstructSettings, useStopString?: boolean}} options
  * @returns {string[]} Array of instruct mode stopping strings.
  */
 -export function getInstructStoppingSequences() {
 +export function getInstructStoppingSequences({ customInstruct = null, useStopString = false } = {}) {
 +    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;
         // 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 +265,7 @@ export function getInstructStoppingSequences() {
262	265	if (sequence.trim().length > 0) {
263	266	const wrappedSequence = wrap(sequence);
264	267	// Need to respect "insert macro" setting
265	268	const stopString = power_user.instruct.macro ? substituteParams(wrappedSequence) : wrappedSequence;
266	269	result.push(stopString);
267	270	}
268	271	}

     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_sequencestop_sequence = power_user.instruct.input_sequence?.replace(/{{name}}/gi, name1)stop_sequence || '';
         const output_sequenceinput_sequence = power_user.instruct.output_sequenceinput_sequence?.replace(/{{name}}/gi, name2name1) || '';
         const first_output_sequenceoutput_sequence = power_user.instruct.first_output_sequenceoutput_sequence?.replace(/{{name}}/gi, name2) || '';
         const last_output_sequencefirst_output_sequence = power_user.instruct.last_output_sequencefirst_output_sequence?.replace(/{{name}}/gi, name2) || '';
         const system_sequencelast_output_sequence = power_user.instruct.system_sequencelast_output_sequence?.replace(/{{name}}/gi, 'System'name2) || '';
         const last_system_sequencesystem_sequence = power_user.instruct.last_system_sequencesystem_sequence?.replace(/{{name}}/gi, 'System') || '';
 +        const last_system_sequence = instruct.last_system_sequence?.replace(/{{name}}/gi, 'System') || '';
         const combined_sequence = [
             stop_sequence,

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