@miruzero/zgpt 0.1.3 → 0.1.5

package/src/transport/direct/http-client.js

@@ -1,4 +1,4 @@
-'use strict';
+'use strict';
 
 const https = require('node:https');
 const fs = require('node:fs');
@@ -6,6 +6,8 @@ const path = require('node:path');
 const paths = require('../../config/paths');
 
 const RETRY_AFTER_CAP_MS = 30000;
+const DEFAULT_HTTP_IDLE_TIMEOUT_MS = 30_000;
+const DEFAULT_HTTP_TOTAL_TIMEOUT_MS = 45_000;
 const DEFAULT_RATE_LIMIT_COOLDOWN_MS = 30000;
 const MAX_RATE_LIMIT_COOLDOWN_MS = 15 * 60 * 1000;
 
@@ -141,6 +143,14 @@ exports.parseRetryAfterMs = (headers = {}) => {
 };
 const safeParse = (text) => { try { return JSON.parse(text); } catch { return null; } };
 const rawRequest = (target, token, sessionHeaders, options, parseBody) => new Promise((resolve, reject) => {
+  let settled = false;
+  let deadlineTimer = null;
+  const finish = (next, value) => {
+    if (settled) return;
+    settled = true;
+    if (deadlineTimer) clearTimeout(deadlineTimer);
+    next(value);
+  };
   const payload = options.body === undefined ? null : Buffer.from(JSON.stringify(options.body));
   let headers = exports.buildHeaders(token, sessionHeaders, target, options.route);
   if (options.headers) headers = cleanHeaders({ ...headers, ...options.headers });
@@ -151,28 +161,47 @@ const rawRequest = (target, token, sessionHeaders, options, parseBody) => new Pr
     const aborted = () => {
       const error = new Error(`ChatGPT upstream stream aborted: ${target}`);
       error.code = 'UPSTREAM_ABORTED';
-      reject(error);
+      finish(reject, error);
     };
     res.on('data', (chunk) => { options.onChunk?.(chunk); chunks.push(chunk); });
     res.on('end', () => {
       ended = true;
       const text = Buffer.concat(chunks).toString('utf8');
       const response = { status: res.statusCode, ...(parseBody ? { json: safeParse(text) } : { text }), contentType: res.headers['content-type'] || null, headers: { ...res.headers } };
-      exports.persistResponseHeaders(sessionHeaders, response.headers, options);
-      resolve(response);
+      try {
+        exports.persistResponseHeaders(sessionHeaders, response.headers, options);
+        finish(resolve, response);
+      } catch (error) { finish(reject, error); }
     });
     res.on('aborted', aborted);
-    res.on('error', reject);
+    res.on('error', error => finish(reject, error));
     res.on('close', () => { if (!ended) aborted(); });
   });
-  req.on('error', reject);
-  if (Number.isFinite(options.idleTimeoutMs) && options.idleTimeoutMs > 0 && typeof req.setTimeout === 'function') {
-    req.setTimeout(options.idleTimeoutMs, () => {
-      const error = new Error(`ChatGPT upstream stream idle timeout: ${target}`);
+  req.on('error', error => finish(reject, error));
+  const idleTimeoutMs = options.idleTimeoutMs === 0 ? 0
+    : Number.isFinite(options.idleTimeoutMs) && options.idleTimeoutMs > 0
+      ? options.idleTimeoutMs : DEFAULT_HTTP_IDLE_TIMEOUT_MS;
+  if (idleTimeoutMs && typeof req.setTimeout === 'function') {
+    req.setTimeout(idleTimeoutMs, () => {
+      const error = new Error(`ChatGPT upstream idle timeout: ${target}`);
       error.code = 'UPSTREAM_IDLE_TIMEOUT';
-      req.destroy(error);
+      if (typeof req.destroy === 'function') req.destroy(error);
+      finish(reject, error);
     });
   }
+  // Active SSE streams may run longer than a fixed total deadline; they still
+  // have an idle timeout. Ordinary HTTP gets both an idle and a total budget.
+  const streaming = typeof options.onChunk === 'function' ||
+    /text\/event-stream/i.test(String(options.headers?.accept || ''));
+  const totalTimeoutMs = options.totalTimeoutMs === 0 ? 0
+    : Number.isFinite(options.totalTimeoutMs) && options.totalTimeoutMs > 0
+      ? options.totalTimeoutMs : streaming ? 0 : DEFAULT_HTTP_TOTAL_TIMEOUT_MS;
+  if (totalTimeoutMs) deadlineTimer = setTimeout(() => {
+    const error = new Error(`ChatGPT upstream request deadline exceeded: ${target}`);
+    error.code = 'UPSTREAM_TIMEOUT';
+    if (typeof req.destroy === 'function') req.destroy(error);
+    finish(reject, error);
+  }, totalTimeoutMs);
   if (payload) req.write(payload);
   req.end();
 });
@@ -187,5 +216,4 @@ const guardedRequest = async (target, token, sessionHeaders, options, parseBody)
 exports.requestJson = (target, token, sessionHeaders = {}, options = {}) =>
   guardedRequest(target, token, sessionHeaders, options, true);
 exports.requestText = (target, token, sessionHeaders = {}, options = {}) =>
-  guardedRequest(target, token, sessionHeaders, options, false);
-
+  guardedRequest(target, token, sessionHeaders, options, false);