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
             await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const generateResponseText = await generateResponse.text();

         if (stream) {
             try {
                 // Pipe remote SSE stream to Express 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) {
             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) {
             await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();

         if (request.body.stream) {
             const stream = await fetch(apiUrl, config);
             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) {
             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) {
             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) {
             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) {
             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) {
             await forwardFetchResponse(generateResponse, response);
         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();

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

         if (request.body.stream) {
             console.info('Streaming request in progress');
             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
                 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
             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
             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');
         await forwardFetchResponse(response, res);
     } catch (error) {
         console.error(error);
         return res.sendStatus(500);

+        }
         res.set('Content-Type', 'audio/mpeg');
         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
         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 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 { 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, 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}`);
 +    });
 +});