fix: 修复node中的stream支持，使用chatgpt-api中的fetchSSE实现SSE

fetchSSE code by
https://github.com/transitive-bullshit/chatgpt-api/blob/600b35eaec985bbbfcb6c77776dc30d4614bd085/src/fetch-sse.ts#L7

Author: magicds

cjs/fetchSSE.js

@@ -0,0 +1,78 @@
+const { createParser } = require('eventsource-parser');
+
+module.exports = async function fetchSSE(url, options, fetch) {
+    const { onmessage, onError, ...fetchOptions } = options;
+    const res = await fetch(url, fetchOptions);
+    if (!res.ok) {
+        let reason;
+
+        try {
+            reason = await res.text();
+        } catch (err) {
+            reason = res.statusText;
+        }
+
+        const msg = `ChatGPT error ${res.status}: ${reason}`;
+        const error = new Error(msg, { cause: res });
+        error.statusCode = res.status;
+        error.statusText = res.statusText;
+        throw error;
+    }
+
+    const parser = createParser((event) => {
+        if (event.type === 'event') {
+            onmessage(event.data);
+        }
+    });
+
+    // handle special response errors
+    const feed = (chunk) => {
+        let response = null;
+
+        try {
+            response = JSON.parse(chunk);
+        } catch {
+            // ignore
+        }
+
+        if (response?.detail?.type === 'invalid_request_error') {
+            const msg = `ChatGPT error ${response.detail.message}: ${response.detail.code} (${response.detail.type})`;
+            const error = new Error(msg, { cause: response });
+            error.statusCode = response.detail.code;
+            error.statusText = response.detail.message;
+
+            if (onError) {
+                onError(error);
+            } else {
+                console.error(error);
+            }
+
+            // don't feed to the event parser
+            return;
+        }
+
+        parser.feed(chunk);
+    };
+
+    if (!res.body.getReader) {
+        // Vercel polyfills `fetch` with `node-fetch`, which doesn't conform to
+        // web standards, so this is a workaround...
+        const body = res.body;
+
+        if (!body.on || !body.read) {
+            throw new Error('unsupported "fetch" implementation');
+        }
+
+        body.on('readable', () => {
+            let chunk;
+            while (null !== (chunk = body.read())) {
+                feed(chunk.toString());
+            }
+        });
+    } else {
+        for await (const chunk of streamAsyncIterable(res.body)) {
+            const str = new TextDecoder().decode(chunk);
+            feed(str);
+        }
+    }
+};

cjs/index.js

@@ -1,4 +1,4 @@
-const fetchEventSource = require('@microsoft/fetch-event-source');
+const fetchSSE = require('./fetchSSE.js');
 const fetch = require('node-fetch');
 
 module.exports = class Api2d {
@@ -53,27 +53,28 @@ module.exports = class Api2d {
                         // throw new Error( "Timeout "+ this.timeout );
                         reject(new Error(`[408]:Timeout by ${this.timeout} ms`));
                     }, this.timeout);
-                    const response = await fetchEventSource(url, {
+                    const response = await fetchSSE(url, {
                         signal: this.controller.signal,
                         method: 'POST',
+                        openWhenHidden: true,
+                        fetch: fetch,
                         headers: { ...headers, Accept: 'text/event-stream' },
                         body: JSON.stringify({ ...restOptions, model: model || 'gpt-3.5-turbo' }),
                         async onopen(response) {
                             if (response.status != 200) {
                                 throw new Error(`[${response.status}]:${response.statusText}`);
                             }
                         },
-                        onmessage: (e) => {
+                        onmessage: (data) => {
                             if (timeout_handle) {
                                 clearTimeout(timeout_handle);
                             }
-                            if (e.data == '[DONE]') {
+                            if (data == '[DONE]') {
                                 // console.log( 'DONE' );
                                 if (onEnd) onEnd(chars);
                                 resolve(chars);
                             } else {
-                                // console.log( e.data );
-                                const event = JSON.parse(e.data);
+                                const event = JSON.parse(data);
                                 if (event.choices[0].delta.content) chars += event.choices[0].delta.content;
                                 if (onMessage) onMessage(chars);
                             }
@@ -82,7 +83,7 @@ module.exports = class Api2d {
                             console.log(error);
                             throw new Error(String(error)?.match(/\[(\d+)\]/)?.[1] ? error : `[500]:${error}`);
                         }
-                    });
+                    }, global.fetch || fetch);
 
                     // const ret = await response.json();
                 } catch (error) {

package.json

@@ -11,6 +11,7 @@
   "private": false,
   "dependencies": {
     "@microsoft/fetch-event-source": "^2.0.1",
+    "eventsource-parser": "^1.0.0",
     "node-fetch": "^2.6.9"
   }
 }