fix: improve streaming error propagation and forwarded response logging (#5317) * Fix: Improve streaming error handling and forwarded response logging * Fix: fix ESLint error Strings must use singlequote quotes * fix: preserve and log forwarded stream errors * chore: narrow forwarded stream error fix scope * fix: make forwardFetchResponse awaitable and forward upstream error text * Restore original happy path handling * Remove redundant checks in forwardFetchResponse function * Don't send anything on parsing error end --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

c9c652eece5f0329ace61319f87e896a65e2e68d

KKTsN <162718958+dz114879@users.noreply.github.com>

Signed

Parents: d96d1451ab468e82c1a6046bf4c6ea95c17ecdb8

src/endpoints/backends/chat-completions.js+12 -12 Viewed

         if (request.body.stream) {
             // Pipe remote SSE stream to Express response
-            forwardFetchResponse(generateResponse, response);
+            await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const generateResponseText = await generateResponse.text();

         if (stream) {
             try {
                 // Pipe remote SSE stream to Express response
-                forwardFetchResponse(generateResponse, response);
+                await forwardFetchResponse(generateResponse, response);
             } catch (error) {
                 console.error('Error forwarding streaming response:', error);
                 if (!response.headersSent) {

     try {
         const generateResponse = await fetch(API_AI21 + '/chat/completions', options);
         if (request.body.stream) {
-            forwardFetchResponse(generateResponse, response);
+            await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();

         const generateResponse = await fetch(apiUrl + '/chat/completions', config);
         if (request.body.stream) {
-            forwardFetchResponse(generateResponse, response);
+            await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();

         if (request.body.stream) {
             const stream = await fetch(apiUrl, config);
-            forwardFetchResponse(stream, response);
+            await forwardFetchResponse(stream, response);
         } else {
             const generateResponse = await fetch(apiUrl, config);
             if (!generateResponse.ok) {

         const generateResponse = await fetch(apiUrl + '/chat/completions', config);
         if (request.body.stream) {
-            forwardFetchResponse(generateResponse, response);
+            await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();

         const generateResponse = await fetch(apiUrl + '/chat/completions', config);
         if (request.body.stream) {
-            forwardFetchResponse(generateResponse, response);
+            await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();

         const generateResponse = await fetch(apiUrl + '/chat/completions', config);
         if (request.body.stream) {
-            forwardFetchResponse(generateResponse, response);
+            await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();

         const generateResponse = await fetch(apiUrl + '/chat/completions', config);
         if (request.body.stream) {
-            forwardFetchResponse(generateResponse, response);
+            await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();

         const generateResponse = await fetch(apiUrl + '/chat/completions', config);
         if (request.body.stream) {
-            forwardFetchResponse(generateResponse, response);
+            await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();

         const fetchResponse = await fetch(endpointUrl, config);
         if (request.body.stream) {
-            return forwardFetchResponse(fetchResponse, response);
+            return await forwardFetchResponse(fetchResponse, response);
+        }
         if (fetchResponse.ok) {

         if (request.body.stream) {
             console.info('Streaming request in progress');
-            return forwardFetchResponse(fetchResponse, response);
+            return await forwardFetchResponse(fetchResponse, response);
+        }
         if (fetchResponse.ok) {

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

             if (request.body.streaming) {
                 // Pipe remote SSE stream to Express response
-                forwardFetchResponse(response, response_generate);
+                await forwardFetchResponse(response, response_generate);
                 return;
             } else {
                 if (!response.ok) {

src/endpoints/backends/text-completions.js+1 -1 Viewed

         } else if (request.body.stream) {
             const completionsStream = await fetch(url, args);
             // Pipe remote SSE stream to Express response
-            forwardFetchResponse(completionsStream, response);
+            await forwardFetchResponse(completionsStream, response);
         } else {
             const completionsReply = await fetch(url, args);

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

         if (req.body.streaming) {
             // Pipe remote SSE stream to Express response
-            forwardFetchResponse(response, res);
+            await forwardFetchResponse(response, res);
         } else {
             if (!response.ok) {
                 const text = await response.text();

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

+        }
         res.set('Content-Type', 'audio/mpeg');
-        forwardFetchResponse(response, res);
+        await forwardFetchResponse(response, res);
     } catch (error) {
         console.error(error);
         return res.sendStatus(500);

+        }
         res.set('Content-Type', 'audio/mpeg');
-        forwardFetchResponse(response, res);
+        await forwardFetchResponse(response, res);
     } catch (error) {
         console.error(error);
         return res.sendStatus(500);

src/middleware/corsProxy.js+1 -1 Viewed

         });
         // Copy over relevant response params to the proxy response
-        forwardFetchResponse(response, res);
+        await forwardFetchResponse(response, res);
     } catch (error) {
         res.status(500).send('Error occurred while trying to proxy to: ' + url + ' ' + error);
+    }

src/util.js+17 -5 Viewed

  * Pipe a fetch() response to an Express.js Response, including status code.
  * @param {import('node-fetch').Response} from The Fetch API response to pipe from.
  * @param {import('express').Response} to The Express response to pipe to.
+ * @returns {Promise<void>}
  */
-export function forwardFetchResponse(from, to) {
+export async function forwardFetchResponse(from, to) {
     let statusCode = from.status;
     let statusText = from.statusText;
-    if (!from.ok) {
-        console.warn(`Streaming request failed with status ${statusCode} ${statusText}`);
-    }
     // Avoid sending 401 responses as they reset the client Basic auth.
     // This can produce an interesting artifact as "400 Unauthorized", but it's not out of spec.
     // https://www.rfc-editor.org/rfc/rfc9110.html#name-overview-of-status-codes

     to.statusCode = statusCode;
     to.statusMessage = statusText;
+    if (!from.ok) {
+        try {
+            const rawErrorText = await from.text();
+            const detail = rawErrorText || 'Unknown error occurred';
+            console.warn(`Streaming request failed with status ${from.status} ${statusText}: ${detail}`);
+            to.end(rawErrorText, 'utf-8');
+        } catch {
+            console.warn(`Streaming request failed with status ${from.status} ${statusText}: Unknown error occurred`);
+            to.end();
+        }
+        return;
+    }
     if (from.body && to.socket) {
         from.body.pipe(to);

tests/util.test.js+61 -2 Viewed

-import { describe, test, expect } from '@jest/globals';
+import { afterEach, describe, test, expect, jest } from '@jest/globals';
+import { once } from 'node:events';
+import { PassThrough } from 'node:stream';
+import { Response } from 'node-fetch';
 import { CHAT_COMPLETION_SOURCES } from '../src/constants';
-import { flattenSchema } from '../src/util';
+import { flattenSchema, forwardFetchResponse } from '../src/util';
+function createMockExpressResponse() {
+    const response = new PassThrough();
+    response.statusCode = 200;
+    response.statusMessage = '';
+    return response;
+}
+async function collectResponseBody(response) {
+    const chunks = [];
+    response.on('data', chunk => chunks.push(Buffer.from(chunk)));
+    await once(response, 'finish');
+    return Buffer.concat(chunks).toString('utf8');
+}
+afterEach(() => {
+    jest.restoreAllMocks();
+});
 describe('flattenSchema', () => {
     test('should return the schema if it is not an object', () => {

         expect(flattenSchema(schema, 'some-other-api')).toEqual(expected);
     });
 });
+describe('forwardFetchResponse', () => {
+    test('should log JSON error bodies and return the original body for non-2xx streaming responses', async () => {
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+        const body = JSON.stringify({ error: { message: 'Forbidden by upstream policy' }, detail: 'policy_denied' });
+        const response = createMockExpressResponse();
+        const bodyPromise = collectResponseBody(response);
+        await forwardFetchResponse(new Response(body, {
+            status: 403,
+            statusText: 'Forbidden',
+        }), response);
+        expect(await bodyPromise).toBe(body);
+        expect(response.statusCode).toBe(403);
+        expect(warnSpy).toHaveBeenCalledWith(`Streaming request failed with status 403 Forbidden: ${body}`);
+    });
+    test('should log plain text error bodies and return the original body for non-2xx streaming responses', async () => {
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+        const body = 'Plain text upstream failure';
+        const response = createMockExpressResponse();
+        const bodyPromise = collectResponseBody(response);
+        await forwardFetchResponse(new Response(body, {
+            status: 502,
+            statusText: 'Bad Gateway',
+        }), response);
+        expect(await bodyPromise).toBe(body);
+        expect(response.statusCode).toBe(502);
+        expect(warnSpy).toHaveBeenCalledWith(`Streaming request failed with status 502 Bad Gateway: ${body}`);
+    });
+});