055a6527 · permissionBRICK/SillyTavern

public/scripts/extensions/quick-reply/src/QuickReplySet.js+1 -0 Viewed

 import { getRequestHeaders, substituteParams } from '../../../../script.js';
 import { Popup, POPUP_RESULT, POPUP_TYPE } from '../../../popup.js';
 import { executeSlashCommandsOnChatInput, executeSlashCommandsWithOptions } from '../../../slash-commands.js';
 +import { SlashCommandScope } from '../../../slash-commands/SlashCommandScope.js';
 import { SlashCommandParser } from '../../../slash-commands/SlashCommandParser.js';
 import { debounceAsync, warn } from '../index.js';
 import { QuickReply } from './QuickReply.js';

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

+    }
     const onStreamResult = (res, err) => {
         if (err) {return;
 -            return;
 -        }
         const thisContent = res?.message?.content;

src/endpoints/assets.js+6 -16 Viewed

         // Delete if previous download failed
         if (fs.existsSync(temp_path)) {
             fs.unlink(temp_path, (err) => {
                 if (err) {throw err;
 -                    throw err;
 -                }
             });
+        }
         const fileStream = fs.createWriteStream(destination, { flags: 'wx' });

         // Delete if previous download failed
         if (fs.existsSync(file_path)) {
             fs.unlink(file_path, (err) => {
                 if (err) {throw err;
 -                    throw err;
 -                }
             });
             console.info('Asset deleted.');
+        }

  * @returns {void}
  */
 router.post('/character', jsonParser, async (request, response) => {
     if (request.query.name === undefined) {return response.sendStatus(400);
 -        return response.sendStatus(400);
 -    }
     // For backwards compatibility, don't reject invalid character names, just sanitize them
     const name = sanitize(request.query.name.toString());

     // Check category
     let category = null;
     for (let i of VALID_CATEGORIES) {
         if (i == inputCategory) {
             category = i;
 -        }
 -    }
     if (category === null) {
         console.error('Bad request: unsupported asset category.');

             if (category == 'live2d') {
                 const folders = fs.readdirSync(folderPath, { withFileTypes: true });
                 for (const folderInfo of folders) {
                     if (!folderInfo.isDirectory()) {continue;
 -                        continue;
 -                    }
                     const modelFolder = folderInfo.name;
                     const live2dModelPath = path.join(folderPath, modelFolder);

src/endpoints/backends/chat-completions.js+3 -4 Viewed

  * @param {express.Response} response Express response
  */
 async function sendAI21Request(request, response) {
     if (!request.body) {return response.sendStatus(400);
 -        return response.sendStatus(400);
 -    }
     const controller = new AbortController();
     console.debug(request.body.messages);

 });
 router.post('/bias', jsonParser, async function (request, response) {
     if (!request.body || !Array.isArray(request.body)) return response.sendStatus(400);
 +        return response.sendStatus(400);
     try {
         const result = {};

src/endpoints/backends/kobold.js+1 -2 Viewed

             return response.sendStatus(400);
+        }
         console.infodebug('Transcribing audio with KoboldCpp', server);
 -        console.debug(server);
         const fileBase64 = fs.readFileSync(request.file.path).toString('base64');
         fs.rmSync(request.file.path);

src/endpoints/backends/text-completions.js+4 -11 Viewed

             request.body.api_server = request.body.api_server.replace('localhost', '127.0.0.1');
+        }
         console.infodebug('Trying to connect to API', request.body);
 -        console.debug(request.body);
         const baseUrl = trimV1(request.body.api_server);
         const args = {

 });
 router.post('/props', jsonParser, async function (request, response) {
     if (!request.body.api_server) {return response.sendStatus(400);
 -        return response.sendStatus(400);
 -    }
     try {
         const baseUrl = trimV1(request.body.api_server);

 });
 router.post('/generate', jsonParser, async function (request, response) {
     if (!request.body) {return response.sendStatus(400);
 -        return response.sendStatus(400);
 -    }
     try {
         if (request.body.api_server.indexOf('localhost') !== -1) {

 ollama.post('/download', jsonParser, async function (request, response) {
     try {
         if (!request.body.name || !request.body.api_server) {return response.sendStatus(400);
 -            return response.sendStatus(400);
 -        }
         const name = request.body.name;
         const url = String(request.body.api_server).replace(/\/$/, '');

src/endpoints/caption.js+1 -1 Viewed

         const pipe = await getPipeline(TASK);
         const result = await pipe(rawImage);
         const text = result[0].generated_text;
         console.debuginfo('Image caption:', text);
         return res.json({ caption: text });
     } catch (error) {

src/endpoints/google.js+1 -1 Viewed

         /** @type {any} */
         const data = await result.json();
         console.debuginfo('Multimodal captioning response', data);
         const candidates = data?.candidates;
         if (!candidates) {

src/endpoints/horde.js+2 -2 Viewed

             return response.sendStatus(400);
+        }
         console.debuginfo('Horde image generation request:', generation);
         const controller = new AbortController();
         request.socket.removeAllListeners('close');
         request.socket.on('close', function () {
             console.infowarn('Horde image generation request aborted.');
             controller.abort();
             if (generation.id) ai_horde.deleteImageGenerationRequest(generation.id);
         });

src/endpoints/novelai.js+1 -1 Viewed

             /** @type {any} */
             const data = await response.json();
             console.debuginfo('NovelAI Output', data?.output);
             return res.send(data);
+        }
     } catch (error) {

src/endpoints/openai.js+1 -1 Viewed

         /** @type {any} */
         const data = await result.json();
         console.debuginfo('Multimodal captioning response', data);
         const caption = data?.choices[0]?.message?.content;
         if (!caption) {

src/endpoints/speech.js+2 -2 Viewed

         const start = performance.now();
         const result = await pipe(wav, { language: lang || null, task: 'transcribe' });
         const end = performance.now();
         console.debuginfo(`Execution duration: ${(end - start) / 1000} seconds`);
         console.debuginfo('Transcribed audio:', result.text);
         return res.json({ text: result.text });
     } catch (error) {

src/endpoints/translate.js+1 -1 Viewed

@@ -35,7 +35,7 @@ function decodeBuffer(buffer) {
35	35	try {
36	36	return iconv.decode(Buffer.from(buffer), 'utf-8');
37	37	} catch (error) {
38	38	console.warnerror('Failed to decode buffer:', error);
39	39	return Buffer.from(buffer).toString('utf-8');
40	40	}
41	41	}

src/util.js+3 -6 Viewed

  */
 export async function extractFileFromZipBuffer(archiveBuffer, fileExtension) {
     return await new Promise((resolve, reject) => yauzl.fromBuffer(Buffer.from(archiveBuffer), { lazyEntries: true }, (err, zipfile) => {
         if (err) {reject(err);
 -            reject(err);
 -        }
         zipfile.readEntry();
         zipfile.on('entry', (entry) => {

         from.body.pipe(to);
         to.socket.on('close', function () {
             if (from.body instanceof Readable) {from.body.destroy(); // Close the remote stream
 -                from.body.destroy(); // Close the remote stream
++
 -            }
             to.end(); // End the Express response
         });

PR fixes