Merge pull request #3099 from ceruleandeep/fix/connRefusedErrMsg Fix/conn refused err msg

0afbd95d09cc2240faa773dc5c3d14c730dcfcb9

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

Signed

Parents: f6d0f7587c21abee43bfa401ba753e4d2f51e9aa 01fdd4206cd1118a078e4b564cbcc04cdb8a94c4

public/script.js+30 -11 Viewed

             quietName: quietName,
         };
         originalResponseLength = responseLengthCustomized ? saveResponseLength(main_api, responseLength) : -1;
-        const generateFinished = await Generate('quiet', options);
+        return await Generate('quiet', options);
-        return generateFinished;
     } finally {
         if (responseLengthCustomized) {
             restoreResponseLength(main_api, originalResponseLength);

         let data = {};
-        if (api == 'koboldhorde') {
+        if (api === 'koboldhorde') {
             data = await generateHorde(prompt, generateData, abortController.signal, false);
-        } else if (api == 'openai') {
+        } else if (api === 'openai') {
             data = await sendOpenAIRequest('quiet', generateData, abortController.signal);
         } else {
             const generateUrl = getGenerateUrl(api);

@@ -3376,13 +3375,15 @@ export async function generateRaw(prompt, api, instructOverride, quietToLoud, sy
3376	});	3375	});
3377		3376
3378	if (!response.ok) {	3377	if (!response.ok) {
3379	const error = await response.json();	3378	throw await response.json();
3380	throw error;
3381	}	3379	}
3382		3380
3383	data = await response.json();	3381	data = await response.json();
3384	}	3382	}
3385		3383
		3384	// should only happen for text completions
		3385	// other frontend paths do not return data if calling the backend fails,
		3386	// they throw things instead
3386	if (data.error) {	3387	if (data.error) {
3387	throw new Error(data.response);	3388	throw new Error(data.response);
3388	}	3389	}

         return Promise.resolve();
+    }
+    /**
+     * Saves itemized prompt bits and calls streaming or non-streaming generation API.
+     * @returns {Promise<void|*|Awaited<*>|String|{fromStream}|string|undefined|Object>}
+     * @throws {Error|object} Error with message text, or Error with response JSON (OAI/Horde), or the actual response JSON (novel|textgenerationwebui|kobold)
+     */
     async function finishGenerating() {
         if (power_user.console_log_prompts) {
             console.log(generate_data.prompt);

     return finishGenerating().then(onSuccess, onError);
+    /**
+     * Handles the successful response from the generation API.
+     * @param data
+     * @returns {Promise<String|{fromStream}|*|string|string|void|Awaited<*>|undefined>}
+     * @throws {Error} Throws an error if the response data contains an error message
+     */
     async function onSuccess(data) {
         if (!data) return;

         let messageChunk = '';
+        // if an error was returned in data (textgenwebui), show it and throw it
         if (data.error) {
             unblockGeneration(type);
             generatedPromptCache = '';

         return Object.defineProperty(new String(getMessage), 'messageChunk', { value: messageChunk });
+    }
+    /**
+     * Exception handler for finishGenerating
+     * @param {Error|object} exception Error or response JSON
+     * @throws {Error|object} Re-throws the exception
+     */
     function onError(exception) {
+        // if the response JSON was thrown (novel|textgenerationwebui|kobold), show the error message
         if (typeof exception?.error?.message === 'string') {
-            toastr.error(exception.error.message, t`Error`, { timeOut: 10000, extendedTimeOut: 20000 });
+            toastr.error(exception.error.message, t`Text generation error`, { timeOut: 10000, extendedTimeOut: 20000 });
+        }
         generatedPromptCache = '';

  * @param {string} type Generation type
  * @param {object} data Generation data
  * @returns {Promise<object>} Response data from the API
+ * @throws {Error|object}
  */
 export async function sendGenerationRequest(type, data) {
     if (main_api === 'openai') {

@@ -5357,12 +5377,10 @@ export async function sendGenerationRequest(type, data) {
5357	});	5377	});
5358		5378
5359	if (!response.ok) {	5379	if (!response.ok) {
5360	const error = await response.json();	5380	throw await response.json();
5361	throw error;
5362	}	5381	}
5363		5382
5364	const responseData = await response.json();	5383	return await response.json();
5365	return responseData;
5366	}	5384	}
5367		5385
5368	/**	5386	/**

  * Gets the generation endpoint URL for the specified API.
  * @param {string} api API name
  * @returns {string} Generation URL
+ * @throws {Error} If the API is unknown
  */
 function getGenerateUrl(api) {
     switch (api) {

public/scripts/extensions/stable-diffusion/index.js+13 -5 Viewed

  * @param {string} [message] Chat message
  * @param {function} [callback] Callback function
  * @returns {Promise<string|undefined>} Image path
+ * @throws {Error} If the prompt or image generation fails
  */
 async function generatePicture(initiator, args, trigger, message, callback) {
     if (!trigger || trigger.trim().length === 0) {

     trigger = trigger.trim();
     const generationType = getGenerationType(trigger);
     const generationTypeKey = Object.keys(generationMode).find(key => generationMode[key] === generationType);
-    console.log(`Generation mode ${generationTypeKey} triggered with "${trigger}"`);
+    console.log(`Image generation mode ${generationTypeKey} triggered with "${trigger}"`);
     const quietPrompt = getQuietPrompt(generationType, trigger);
     const context = getContext();

     try {
         const combineNegatives = (prefix) => { negativePromptPrefix = combinePrefixes(negativePromptPrefix, prefix); };
+        // generate the text prompt for the image
         const prompt = await getPrompt(generationType, message, trigger, quietPrompt, combineNegatives);
         console.log('Processed image prompt:', prompt);

             args._abortController.addEventListener('abort', stopListener);
+        }
+        // generate the image
         imagePath = await sendGenerationRequest(generationType, prompt, negativePromptPrefix, characterName, callback, initiator, abortController.signal);
     } catch (err) {
         console.trace(err);
-        toastr.error('SD prompt text generation failed. Reason: ' + err, 'Image Generation');
+        // errors here are most likely due to text generation failure
-        throw new Error('SD prompt text generation failed. Reason: ' + err);
+        // sendGenerationRequest mostly deals with its own errors
+        const reason = err.error?.message || err.message || 'Unknown error';
+        const errorText = 'SD prompt text generation failed. ' + reason;
+        toastr.error(errorText, 'Image Generation');
+        throw new Error(errorText);
+    }
     finally {
         $(stopButton).hide();

  */
 async function getPrompt(generationType, message, trigger, quietPrompt, combineNegatives) {
     let prompt;
+    console.log('getPrompt: Generation mode', generationType, 'triggered with', trigger);
     switch (generationType) {
         case generationMode.RAW_LAST:
             prompt = message || getRawLastMessage();

@@ -2729,7 +2737,7 @@ async function sendGenerationRequest(generationType, prompt, additionalNegativeP
2729	throw new Error('Endpoint did not return image data.');	2737	throw new Error('Endpoint did not return image data.');
2730	}	2738	}
2731	} catch (err) {	2739	} catch (err) {
2732	console.error(err);	2740	console.error('Image generation request error: ', err);
2733	toastr.error('Image generation failed. Please try again.' + '\n\n' + String(err), 'Image Generation');	2741	toastr.error('Image generation failed. Please try again.' + '\n\n' + String(err), 'Image Generation');
2734	return;	2742	return;
2735	}	2743	}

public/scripts/horde.js+8 -0 Viewed

+    }
+}
+/** Generates text using the Horde API.
+ * @param {string} prompt
+ * @param params
+ * @param signal
+ * @param reportProgress
+ * @returns {Promise<{text: *, workerName: string}>}
+ * @throws {Error}
+ */
 async function generateHorde(prompt, params, signal, reportProgress) {
     validateHordeModel();
     delete params.prompt;

public/scripts/openai.js+32 -7 Viewed

     return [chat, promptManager.tokenHandler.counts];
+}
+/**
+ * Handles errors during streaming requests.
+ * @param {Response} response
+ * @param {string} decoded - response text or decoded stream data
+ */
 function tryParseStreamingError(response, decoded) {
     try {
         const data = JSON.parse(decoded);

         checkQuotaError(data);
         checkModerationError(data);
+        // these do not throw correctly (equiv to Error("[object Object]"))
+        // if trying to fix "[object Object]" displayed to users, start here
         if (data.error) {
             toastr.error(data.error.message || response.statusText, 'Chat Completion API');
             throw new Error(data);

@@ -1339,15 +1347,22 @@ function tryParseStreamingError(response, decoded) {
1339	}	1347	}
1340	}	1348	}
1341		1349
1342	async function checkQuotaError(data) {	1350	/**
1343	const errorText = await renderTemplateAsync('quotaError');	1351	* Checks if the response contains a quota error and displays a popup if it does.
1344		1352	* @param data
		1353	* @returns {void}
		1354	* @throws {object} - response JSON
		1355	*/
		1356	function checkQuotaError(data) {
1345	if (!data) {	1357	if (!data) {
1346	return;	1358	return;
1347	}	1359	}
1348		1360
1349	if (data.quota_error) {	1361	if (data.quota_error) {
1350	callPopup(errorText, 'text');	1362	renderTemplateAsync('quotaError').then((html) => Popup.show.text('Quota Error', html));
		1363
		1364	// this does not throw correctly (equiv to Error("[object Object]"))
		1365	// if trying to fix "[object Object]" displayed to users, start here
1351	throw new Error(data);	1366	throw new Error(data);
1352	}	1367	}
1353	}	1368	}

     return data.output;
+}
+/**
+ * Send a chat completion request to backend
+ * @param {string} type (impersonate, quiet, continue, etc)
+ * @param {Array} messages
+ * @param {AbortSignal?} signal
+ * @returns {Promise<unknown>}
+ * @throws {Error}
+ */
 async function sendOpenAIRequest(type, messages, signal) {
     // Provide default abort signal
     if (!signal) {

     else {
         const data = await response.json();
-        await checkQuotaError(data);
+        checkQuotaError(data);
         checkModerationError(data);
         if (data.error) {
-            toastr.error(data.error.message || response.statusText, t`API returned an error`);
+            const message = data.error.message || response.statusText || t`Unknown error`;
-            throw new Error(data);
+            toastr.error(message, t`API returned an error`);
+            throw new Error(message);
+        }
         if (type !== 'quiet') {

public/scripts/slash-commands/SlashCommandBrowser.js+6 -7 Viewed

 import { escapeRegex } from '../utils.js';
-import { SlashCommand } from './SlashCommand.js';
 import { SlashCommandParser } from './SlashCommandParser.js';
 export class SlashCommandBrowser {

                                 this.details?.remove();
                                 this.details = null;
                                 let query = inp.value.trim();
-                                if (query.slice(-1) == '"' && !/(?:^|\s+)"/.test(query)) {
+                                if (query.slice(-1) === '"' && !/(?:^|\s+)"/.test(query)) {
                                     query = `"${query}`;
+                                }
                                 let fuzzyList = [];

                                         cmd.helpString,
                                     ];
                                     const find = ()=>targets.find(t=>(fuzzyList.find(f=>f.test(t)) ?? quotedList.find(q=>t.includes(q))) !== undefined) !== undefined;
-                                    if (fuzzyList.length + quotedList.length == 0 || find()) {
+                                    if (fuzzyList.length + quotedList.length === 0 || find()) {
                                         this.itemMap[cmd.name].classList.remove('isFiltered');
                                     } else {
                                         this.itemMap[cmd.name].classList.add('isFiltered');

                         list.classList.add('autoComplete');
                         this.cmdList = Object
                             .keys(SlashCommandParser.commands)
-                            .filter(key => SlashCommandParser.commands[key].name == key) // exclude aliases
+                            .filter(key => SlashCommandParser.commands[key].name === key) // exclude aliases
                             .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
                             .map(key => SlashCommandParser.commands[key])
+                        ;

@@ -97,7 +96,7 @@ export class SlashCommandBrowser {
97	}	96	}
98	}	97	}
99	}	98	}
100	if (this.details != details) {	99	if (this.details !== details) {
101	Array.from(list.querySelectorAll('.selected')).forEach(it=>it.classList.remove('selected'));	100	Array.from(list.querySelectorAll('.selected')).forEach(it=>it.classList.remove('selected'));
102	item.classList.add('selected');	101	item.classList.add('selected');
103	this.details?.remove();	102	this.details?.remove();

         parent.append(this.dom);
         this.mo = new MutationObserver(muts=>{
-            if (muts.find(mut=>Array.from(mut.removedNodes).find(it=>it == this.dom || it.contains(this.dom)))) {
+            if (muts.find(mut=>Array.from(mut.removedNodes).find(it=>it === this.dom || it.contains(this.dom)))) {
                 this.mo.disconnect();
                 window.removeEventListener('keydown', boundHandler);
+            }

+    }
     handleKeyDown(evt) {
-        if (!evt.shiftKey && !evt.altKey && evt.ctrlKey && evt.key.toLowerCase() == 'f') {
+        if (!evt.shiftKey && !evt.altKey && evt.ctrlKey && evt.key.toLowerCase() === 'f') {
             if (!this.dom.closest('body')) return;
             if (this.dom.closest('.mes') && !this.dom.closest('.last_mes')) return;
             evt.preventDefault();

public/scripts/textgen-settings.js+8 -0 Viewed

+    }
+}
+/**
+ * Sends a streaming request for textgenerationwebui.
+ * @param generate_data
+ * @param signal
+ * @returns {Promise<(function(): AsyncGenerator<{swipes: [], text: string, toolCalls: [], logprobs: {token: string, topLogprobs: Candidate[]}|null}, void, *>)|*>}
+ * @throws {Error} - If the response status is not OK, or from within the generator
+ */
 async function generateTextGenWithStreaming(generate_data, signal) {
     generate_data.stream = true;

  * @param {Response} response - Response from the server.
  * @param {string} decoded - Decoded response body.
  * @returns {void} Nothing.
+ * @throws {Error} If the response contains an error message, throws Error with the message.
  */
 function tryParseStreamingError(response, decoded) {
     let data = {};

src/endpoints/backends/chat-completions.js+6 -2 Viewed

+            }
         } catch (error) {
             console.log('Generation failed', error);
+            const message = error.code === 'ECONNREFUSED'
+                ? `Connection refused: ${error.message}`
+                : error.message || 'Unknown error occurred';
             if (!response.headersSent) {
-                response.send({ error: true });
+                response.status(502).send({ error: { message, ...error } });
             } else {
                 response.end();
+            }

         const message = errorResponse.statusText || 'Unknown error occurred';
         const quota_error = errorResponse.status === 429 && errorData?.error?.type === 'insufficient_quota';
-        console.log(message, responseText);
+        console.log('Chat completion request error: ', message, responseText);
         if (!response.headersSent) {
             response.send({ error: { message }, quota_error: quota_error });