4fcad075 · permissionBRICK/SillyTavern

package-lock.json+0 -1 Viewed

                 "@types/lodash": "^4.17.10",
                 "@types/mime-types": "^2.1.4",
                 "@types/multer": "^1.4.12",
 -                "@types/node-fetch": "^2.6.11",
                 "@types/node-persist": "^3.1.8",
                 "@types/png-chunk-text": "^1.0.3",
                 "@types/png-chunks-encode": "^1.0.2",

package.json+0 -1 Viewed

         "@types/lodash": "^4.17.10",
         "@types/mime-types": "^2.1.4",
         "@types/multer": "^1.4.12",
 -        "@types/node-fetch": "^2.6.11",
         "@types/node-persist": "^3.1.8",
         "@types/png-chunk-text": "^1.0.3",
         "@types/png-chunks-encode": "^1.0.2",

src/character-card-parser.js+2 -2 Viewed

  * @returns {Buffer} PNG image buffer with metadata
  */
 export const write = (image, data) => {
     const chunks = extract(new Uint8Array(image));
     const tEXtChunks = chunks.filter(chunk => chunk.name === 'tEXt');
     // Remove existing tEXt chunks

  * @returns {string} Character data
  */
 export const read = (image) => {
     const chunks = extract(new Uint8Array(image));
     const textChunks = chunks.filter((chunk) => chunk.name === 'tEXt').map((chunk) => PNGtext.decode(chunk.data));

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

                 'anthropic-version': '2023-06-01',
                 'x-api-key': request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.CLAUDE),
             },
 -            timeout: 0,
         });
         if (!result.ok) {

             return response.status(result.status).send({ error: true });
+        }
 +        /** @type {any} */
         const generateResponseJson = await result.json();
         const caption = generateResponseJson.content[0].text;
         console.log('Claude response:', generateResponseJson);

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

                 'x-api-key': apiKey,
                 ...additionalHeaders,
             },
 -            timeout: 0,
         });
         if (request.body.stream) {

                 return response.status(generateResponse.status).send({ error: true });
+            }
 +            /** @type {any} */
             const generateResponseJson = await generateResponse.json();
             const responseText = generateResponseJson?.content?.[0]?.text || '';
             console.log('Claude response:', generateResponseJson);

                 'Content-Type': 'application/json',
                 'Authorization': `Basic ${apiKey}`,
             },
 -            timeout: 0,
         });
         if (!generateResponse.ok) {

             return response.status(500).send({ error: true });
+        }
 +        /** @type {any} */
         const generateResponseJson = await generateResponse.json();
         console.log('Scale response:', generateResponseJson);

                 'Content-Type': 'application/json',
             },
             signal: controller.signal,
 -            timeout: 0,
         });
         // have to do this because of their busted ass streaming endpoint
         if (stream) {

                 return response.status(generateResponse.status).send({ error: true });
+            }
 +            /** @type {any} */
             const generateResponseJson = await generateResponse.json();
             const candidates = generateResponseJson?.candidates;

         });
         if (response.ok) {
 +            /** @type {any} */
             const data = await response.json();
             response_getstatus_openai.send(data);

         },
         body: JSON.stringify(requestBody),
         signal: controller.signal,
 -        timeout: 0,
     };
     console.log(requestBody);

+            }
             if (fetchResponse.ok) {
 +                /** @type {any} */
                 let json = await fetchResponse.json();
                 response.send(json);
                 console.log(json);

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

     for (let i = 0; i < MAX_RETRIES; i++) {
         try {
             const url = request.body.streaming ? `${request.body.api_server}/extra/generate/stream` : `${request.body.api_server}/v1/generate`;
             const response = await fetch(url, { method: 'POST', timeout: 0, ...args });
             if (request.body.streaming) {
                 // Pipe remote SSE stream to Express response

     const result = {};
 +    /** @type {any} */
     const [koboldUnitedResponse, koboldExtraResponse, koboldModelResponse] = await Promise.all([
         // We catch errors both from the response not having a successful HTTP status and from JSON parsing failing

src/endpoints/backends/scale-alt.js+1 -1 Viewed

                 'Content-Type': 'application/json',
                 'cookie': `_jwt=${cookie}`,
             },
 -            timeout: 0,
             body: JSON.stringify(body),
         });

             return response.status(500).send({ error: { message: result.statusText } });
+        }
 +        /** @type {any} */
         const data = await result.json();
         const output = data?.result?.data?.json?.outputs?.[0] || '';

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

  */
 async function parseOllamaStream(jsonStream, request, response) {
     try {
 +        if (!jsonStream.body) {
 +            throw new Error('No body in the response');
 +        }
++
         let partialData = '';
         jsonStream.body.on('data', (data) => {
             const chunk = data.toString();

             return response.status(400);
+        }
 +        /** @type {any} */
         let data = await modelsReply.json();
         if (request.body.legacy_api) {

                 const modelInfoReply = await fetch(modelInfoUrl, args);
                 if (modelInfoReply.ok) {
 +                    /** @type {any} */
                     const modelInfo = await modelInfoReply.json();
                     console.log('Ooba model info:', modelInfo);

                 const modelInfoReply = await fetch(modelInfoUrl, args);
                 if (modelInfoReply.ok) {
 +                    /** @type {any} */
                     const modelInfo = await modelInfoReply.json();
                     console.log('Tabby model info:', modelInfo);

             const completionsReply = await fetch(url, args);
             if (completionsReply.ok) {
 +                /** @type {any} */
                 const data = await completionsReply.json();
                 console.log('Endpoint response:', data);

                 name: name,
                 stream: false,
             }),
 -            timeout: 0,
         });
         if (!fetchResponse.ok) {

                 images: [request.body.image],
                 stream: false,
             }),
 -            timeout: 0,
         });
         if (!fetchResponse.ok) {

             return response.status(500).send({ error: true });
+        }
 +        /** @type {any} */
         const data = await fetchResponse.json();
         console.log('Ollama caption response:', data);

         const fetchResponse = await fetch(`${baseUrl}/completion`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
 -            timeout: 0,
             body: JSON.stringify({
                 prompt: `USER:[img-1]${String(request.body.prompt).trim()}\nASSISTANT:`,
                 image_data: [{ data: request.body.image, id: 1 }],

             return response.status(500).send({ error: true });
+        }
 +        /** @type {any} */
         const data = await fetchResponse.json();
         console.log('LlamaCpp caption response:', data);

         const fetchResponse = await fetch(`${baseUrl}/props`, {
             method: 'GET',
 -            timeout: 0,
         });
         if (!fetchResponse.ok) {

         if (request.body.action === 'info') {
             fetchResponse = await fetch(`${baseUrl}/slots`, {
                 method: 'GET',
 -                timeout: 0,
             });
         } else {
             if (!/^\d+$/.test(request.body.id_slot)) {

             fetchResponse = await fetch(`${baseUrl}/slots/${request.body.id_slot}?action=${request.body.action}`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
 -                timeout: 0,
                 body: JSON.stringify({
                     filename: request.body.action !== 'erase' ? `${request.body.filename}` : undefined,
                 }),

         });
         if (permissionResponse.ok) {
 +            /** @type {any} */
             const permissionJson = await permissionResponse.json();
             if (permissionJson['permission'] !== 'admin') {

src/endpoints/content-manager.js+2 -0 Viewed

         throw new Error('Failed to download character');
+    }
 +    /** @type {any} */
     const jsonData = await result.json();
     const characterData = jsonData?.character;

     });
     if (result.ok) {
 +        /** @type {any} */
         const downloadResult = await result.json();
         if (downloadResult.status === 'ok') {
             const imageResult = await fetch(downloadResult.downloadUrl);

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

             headers: {
                 'Content-Type': 'application/json',
             },
 -            timeout: 0,
         });
         if (!result.ok) {

             return response.status(result.status).send({ error: true });
+        }
 +        /** @type {any} */
         const data = await result.json();
         console.log('Multimodal captioning response', data);

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

         ensureDirectoryExistence(pathToNewFile);
         const imageBuffer = Buffer.from(base64Data, 'base64');
         await fs.promises.writeFile(pathToNewFile, new Uint8Array(imageBuffer));
         response.send({ path: clientRelativePath(request.user.directories.root, pathToNewFile) });
     } catch (error) {
         console.log(error);

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

     try {
         const baseURL = (req.body.model.includes('kayra') || req.body.model.includes('erato')) ? TEXT_NOVELAI : API_NOVELAI;
         const url = req.body.streaming ? `${baseURL}/ai/generate-stream` : `${baseURL}/ai/generate`;
         const response = await fetch(url, { method: 'POST', timeout: 0, ...args });
         if (req.body.streaming) {
             // Pipe remote SSE stream to Express response

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

                 'Authorization': `Bearer ${token}`,
                 'Accept': 'audio/mpeg',
             },
 -            timeout: 0,
         });
         if (!result.ok) {

@@ -426,7 +426,7 @@ router.post('/generate-voice', jsonParser, async (request, response) => {
426	426	}
427	427
428	428	const chunks = await readAllChunks(result.body);
429	429	const buffer = Buffer.concat(chunks.map(chunk => new Uint8Array(chunk)));
430	430	response.setHeader('Content-Type', 'audio/mpeg');
431	431	return response.send(buffer);
432	432	}

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

                 ...headers,
             },
             body: JSON.stringify(body),
 -            timeout: 0,
         });
         if (!result.ok) {

             return response.status(500).send(text);
+        }
 +        /** @type {any} */
         const data = await result.json();
         console.log('Multimodal captioning response', data);
         const caption = data?.choices[0]?.message?.content;

                 Authorization: `Bearer ${key}`,
             },
             body: JSON.stringify(request.body),
 -            timeout: 0,
         });
         if (!result.ok) {

src/endpoints/stable-diffusion.js+20 -6 Viewed

                 throw new Error('SD WebUI returned an error.');
+            }
 +            /** @type {any} */
             const data = await result.json();
             const names = data.map(x => x.name);
             return names;

                 throw new Error('SD WebUI returned an error.');
+            }
 +            /** @type {any} */
             const data = await result.json();
             const names = data.map(x => x.name);
             return names;

             throw new Error('SD WebUI returned an error.');
+        }
 +        /** @type {any} */
         const data = await result.json();
         const names = data.map(x => x.model_name);
         return response.send(names);

             throw new Error('SD WebUI returned an error.');
+        }
 +        /** @type {any} */
         const data = await result.json();
         const names = data.map(x => x.name);
         return response.send(names);

             throw new Error('SD WebUI returned an error.');
+        }
 +        /** @type {any} */
         const data = await result.json();
         const names = data.map(x => x.name);
         return response.send(names);

             throw new Error('SD WebUI returned an error.');
+        }
 +        /** @type {any} */
         const data = await result.json();
         const models = data.map(x => ({ value: x.title, text: x.title }));
         return response.send(models);

                 'Authorization': getBasicAuthHeader(request.body.auth),
             },
         });
 +        /** @type {any} */
         const data = await result.json();
         return response.send(data['sd_model_checkpoint']);
     } catch (error) {

                 headers: {
                     'Authorization': getBasicAuthHeader(request.body.auth),
                 },
 -                timeout: 0,
             });
             const data = await result.json();
             return data;

                 'Content-Type': 'application/json',
                 'Authorization': getBasicAuthHeader(request.body.auth),
             },
 -            timeout: 0,
         });
         if (!result.ok) {

         const CHECK_INTERVAL = 2000;
         for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
 +            /** @type {any} */
             const progressState = await getProgress();
             const progress = progressState['progress'];

                 'Content-Type': 'application/json',
                 'Authorization': getBasicAuthHeader(request.body.auth),
             },
 -            timeout: 0,
 -            // @ts-ignore
             signal: controller.signal,
         });

         // Vlad doesn't provide Latent Upscalers in the API, so we have to hardcode them here
         const latentUpscalers = ['Latent', 'Latent (antialiased)', 'Latent (bicubic)', 'Latent (bicubic antialiased)', 'Latent (nearest)', 'Latent (nearest-exact)'];
 +        /** @type {any} */
         const data = await result.json();
         const names = data.map(x => x.name);

             throw new Error('ComfyUI returned an error.');
+        }
 +        /** @type {any} */
         const data = await result.json();
         return response.send(data.KSampler.input.required.sampler_name[0]);
     } catch (error) {

         if (!result.ok) {
             throw new Error('ComfyUI returned an error.');
+        }
 +        /** @type {any} */
         const data = await result.json();
         return response.send(data.CheckpointLoaderSimple.input.required.ckpt_name[0].map(it => ({ value: it, text: it })));
     } catch (error) {

             throw new Error('ComfyUI returned an error.');
+        }
 +        /** @type {any} */
         const data = await result.json();
         return response.send(data.KSampler.input.required.scheduler[0]);
     } catch (error) {

             throw new Error('ComfyUI returned an error.');
+        }
 +        /** @type {any} */
         const data = await result.json();
         return response.send(data.VAELoader.input.required.vae_name[0]);
     } catch (error) {

             throw new Error('ComfyUI returned an error.');
+        }
 +        /** @type {any} */
         const data = await promptResult.json();
         const id = data.prompt_id;
         let item;

             if (!result.ok) {
                 throw new Error('ComfyUI returned an error.');
+            }
 +            /** @type {any} */
             const history = await result.json();
             item = history[id];
             if (item) {

             return response.sendStatus(500);
+        }
 +        /** @type {any} */
         const data = await result.json();
         console.log('TogetherAI response:', data);

         const result = await fetch(url, {
             method: 'GET',
         });
++
 +        /** @type {any} */
         const data = await result.json();
         return response.send(data['model']);

         const result = await fetch(url, {
             method: 'GET',
         });
++
 +        /** @type {any} */
         const data = await result.json();
         return response.send(data['upscaler']);

                 'Content-Type': 'application/json',
                 'Authorization': auth,
             },
 -            timeout: 0,
         });
         if (!result.ok) {

                 'Accept': 'image/*',
             },
             body: formData,
 -            timeout: 0,
         });
         if (!result.ok) {

src/endpoints/translate.js+5 -4 Viewed

             return response.sendStatus(result.status);
+        }
 +        /** @type {any} */
         const json = await result.json();
         console.log('Translated text: ' + json.translatedText);

             headers: {
                 'Content-Type': 'application/x-www-form-urlencoded',
             },
 -            timeout: 0,
         });
         if (!result.ok) {

             return response.sendStatus(500);
+        }
 +        /** @type {any} */
         const json = await result.json();
         const translated = json.text.join();
         console.log('Translated text: ' + translated);

                 'Authorization': `DeepL-Auth-Key ${key}`,
                 'Content-Type': 'application/x-www-form-urlencoded',
             },
 -            timeout: 0,
         });
         if (!result.ok) {

             return response.sendStatus(result.status);
+        }
 +        /** @type {any} */
         const json = await result.json();
         console.log('Translated text: ' + json.translations[0].text);

         const result = await fetch(fetchUrl, {
             method: 'GET',
 -            timeout: 0,
         });
         if (!result.ok) {

             return response.sendStatus(result.status);
+        }
 +        /** @type {any} */
         const data = await result.json();
         console.log('Translated text: ' + data.result);

                 'Accept': 'application/json',
                 'Content-Type': 'application/json',
             },
 -            timeout: 0,
         });
         if (!result.ok) {

             return response.sendStatus(result.status);
+        }
 +        /** @type {any} */
         const json = await result.json();
         console.log('Translated text: ' + json.data);

src/transformers.mjs+3 -2 Viewed

 import process from 'node:process';
 import { Buffer } from 'node:buffer';
 import { pipeline, env, RawImage, Pipeline } from 'sillytavern-transformers';
 import { getConfigValue } from './util.js';
 configureTransformers();

  * Gets the transformers.js pipeline for a given task.
  * @param {import('sillytavern-transformers').PipelineType} task The task to get the pipeline for
  * @param {string} forceModel The model to use for the pipeline, if any
  * @returns {Promise<import('sillytavern-transformers').Pipeline>} Pipeline forThe thetransformers.js taskpipeline
  */
 export async function getPipeline(task, forceModel = '') {
     await migrateCacheToDataDir();

     const instance = await pipeline(task, model, { cache_dir: cacheDir, quantized: tasks[task].quantized ?? true, local_files_only: localOnly });
     tasks[task].pipeline = instance;
     tasks[task].currentModel = model;
 +    // @ts-ignore
     return instance;
+}

src/util.js+12 -8 Viewed

     to.statusCode = statusCode;
     to.statusMessage = statusText;
 -    from.body.pipe(to);
 +    if (from.body && to.socket) {
 +        from.body.pipe(to);
             to.socket.on('close', function () {
                     if (from.body instanceof Readable) from.body.destroy(); // Close the remote stream
                     to.end(); // End the Express response
             });
             from.body.on('end', function () {
                     console.log('Streaming request finished');
 +            to.end();
 +        });
 +    } else {
         to.end();
     });
+}
 /**

src/vectors/cohere-vectors.js+1 -0 Viewed

         throw new Error('API request failed');
+    }
 +    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.embeddings?.float)) {
         console.log('API response was not an array');

src/vectors/extras-vectors.js+1 -0 Viewed

         throw new Error('Extras request failed');
+    }
 +    /** @type {any} */
     const data = await response.json();
     const vector = data.embedding;  // `embedding`: number[] (one text item), or number[][] (multiple text items).

src/vectors/llamacpp-vectors.js+1 -0 Viewed

         throw new Error(`LlamaCpp: Failed to get vector for text: ${response.statusText} ${responseText}`);
+    }
 +    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.data)) {

src/vectors/makersuite-vectors.js+1 -0 Viewed

         throw new Error('Google AI Studio request failed');
+    }
 +    /** @type {any} */
     const data = await response.json();
     // noinspection JSValidateTypes
     return data['embedding']['values'];

src/vectors/nomicai-vectors.js+1 -0 Viewed

         throw new Error('API request failed');
+    }
 +    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.embeddings)) {
         console.log('API response was not an array');

src/vectors/ollama-vectors.js+1 -0 Viewed

         throw new Error(`Ollama: Failed to get vector for text: ${response.statusText} ${responseText}`);
+    }
 +    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.embedding)) {

src/vectors/openai-vectors.js+1 -0 Viewed

         throw new Error('API request failed');
+    }
 +    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.data)) {

src/vectors/vllm-vectors.js+1 -0 Viewed

         throw new Error(`VLLM: Failed to get vector for text: ${response.statusText} ${responseText}`);
+    }
 +    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.data)) {

[chore] Fix type errors