qwenproxy-cli 1.6.0 → 1.6.1

package/dist/clean-cache.js

@@ -1016,11 +1016,11 @@ var init_config = __esm({
       // nothing in this window is dead and should fail fast, retryable).
       QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("60000"),
       TOTAL_REQUEST_TIMEOUT: z.string().default("600000"),
-      // Mid-stream silence window for thinking models: 3 min with ZERO upstream
+      // Mid-stream silence window for thinking models: 5 min with ZERO upstream
       // bytes is a dead stream (WAF swallow / dropped connection) — fail fast and
       // let the retry policy rotate accounts. Flowing reasoning chunks RESET this
       // timer, so legitimate slow thinking is never cut; only total silence is.
-      REASONING_MODEL_TIMEOUT: z.string().default("180000"),
+      REASONING_MODEL_TIMEOUT: z.string().default("300000"),
       CACHE_TTL: z.string().default("3600"),
       RESPONSE_TTL: z.string().default("1800"),
       CACHE_COMPRESSION_ENABLED: z.string().default("true"),
@@ -2848,15 +2848,18 @@ function loadStorageState(accountId) {
     return void 0;
   }
 }
-async function saveStorageState(context, accountId, timeoutMs = 5e3) {
+async function saveStorageState(context, accountId, timeoutMs = 1e4) {
   try {
     const stateFile = getStorageStatePath(accountId);
     const dir = path4.dirname(stateFile);
     if (!fs7.existsSync(dir)) {
       fs7.mkdirSync(dir, { recursive: true });
     }
+    const rawPromise = context.storageState({ path: stateFile }).catch(() => {
+      return void 0;
+    });
     await withTimeout(
-      context.storageState({ path: stateFile }),
+      rawPromise,
       timeoutMs,
       `storageState timed out after ${timeoutMs}ms`
     );
@@ -5336,6 +5339,44 @@ var init_playwright = __esm({
   }
 });
 
+// src/core/process-guard.ts
+function isPlaywrightAlreadyClosedMessage(message) {
+  if (!message) return false;
+  return message.includes("Target page, context or browser has been closed") || message.includes("Browser has been closed") || message.includes("Target closed") || message.includes("Target crashed") || message.includes("Page crashed") || message.includes("Assertion error") || message.includes("Cannot find parent object") || message.includes("Connection closed") || message.includes("session closed") || message.includes("Session closed") || message.includes("Network.setCacheDisabled") || message.includes("Protocol error") || message.includes("storageState timed out");
+}
+function isBenignTeardownError(error) {
+  if (!error) return false;
+  const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
+  return isPlaywrightAlreadyClosedMessage(message);
+}
+function installProcessTeardownGuards(label = "Process") {
+  if (guardsInstalled) return;
+  guardsInstalled = true;
+  process.on("uncaughtException", (error) => {
+    if (isBenignTeardownError(error)) {
+      const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown exception: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Uncaught Exception:`, error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isBenignTeardownError(reason)) {
+      const msg = reason instanceof Error ? reason.message : typeof reason === "object" && reason !== null && "message" in reason ? String(reason.message) : String(reason);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown rejection: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Unhandled Rejection:`, reason);
+  });
+}
+var guardsInstalled;
+var init_process_guard = __esm({
+  "src/core/process-guard.ts"() {
+    "use strict";
+    guardsInstalled = false;
+  }
+});
+
 // src/clean-cache.ts
 var clean_cache_exports = {};
 __export(clean_cache_exports, {
@@ -5503,6 +5544,8 @@ var isDirectRun;
 var init_clean_cache = __esm({
   "src/clean-cache.ts"() {
     init_playwright();
+    init_process_guard();
+    installProcessTeardownGuards("CleanCache");
     isDirectRun = process.argv[1] && (process.argv[1].endsWith("clean-cache.ts") || process.argv[1].endsWith("clean-cache.js"));
     if (isDirectRun) {
       main().catch((err) => {

package/dist/delete-chats.js

@@ -13,6 +13,44 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/core/process-guard.ts
+function isPlaywrightAlreadyClosedMessage(message) {
+  if (!message) return false;
+  return message.includes("Target page, context or browser has been closed") || message.includes("Browser has been closed") || message.includes("Target closed") || message.includes("Target crashed") || message.includes("Page crashed") || message.includes("Assertion error") || message.includes("Cannot find parent object") || message.includes("Connection closed") || message.includes("session closed") || message.includes("Session closed") || message.includes("Network.setCacheDisabled") || message.includes("Protocol error") || message.includes("storageState timed out");
+}
+function isBenignTeardownError(error) {
+  if (!error) return false;
+  const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
+  return isPlaywrightAlreadyClosedMessage(message);
+}
+function installProcessTeardownGuards(label = "Process") {
+  if (guardsInstalled) return;
+  guardsInstalled = true;
+  process.on("uncaughtException", (error) => {
+    if (isBenignTeardownError(error)) {
+      const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown exception: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Uncaught Exception:`, error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isBenignTeardownError(reason)) {
+      const msg = reason instanceof Error ? reason.message : typeof reason === "object" && reason !== null && "message" in reason ? String(reason.message) : String(reason);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown rejection: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Unhandled Rejection:`, reason);
+  });
+}
+var guardsInstalled;
+var init_process_guard = __esm({
+  "src/core/process-guard.ts"() {
+    "use strict";
+    guardsInstalled = false;
+  }
+});
+
 // src/core/paths.ts
 import fs from "node:fs";
 import path from "node:path";
@@ -1071,11 +1109,11 @@ var init_config = __esm({
       // nothing in this window is dead and should fail fast, retryable).
       QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("60000"),
       TOTAL_REQUEST_TIMEOUT: z.string().default("600000"),
-      // Mid-stream silence window for thinking models: 3 min with ZERO upstream
+      // Mid-stream silence window for thinking models: 5 min with ZERO upstream
       // bytes is a dead stream (WAF swallow / dropped connection) — fail fast and
       // let the retry policy rotate accounts. Flowing reasoning chunks RESET this
       // timer, so legitimate slow thinking is never cut; only total silence is.
-      REASONING_MODEL_TIMEOUT: z.string().default("180000"),
+      REASONING_MODEL_TIMEOUT: z.string().default("300000"),
       CACHE_TTL: z.string().default("3600"),
       RESPONSE_TTL: z.string().default("1800"),
       CACHE_COMPRESSION_ENABLED: z.string().default("true"),
@@ -3105,6 +3143,8 @@ var init_clean_cache = __esm({
   "src/clean-cache.ts"() {
     "use strict";
     init_playwright();
+    init_process_guard();
+    installProcessTeardownGuards("CleanCache");
     isDirectRun = process.argv[1] && (process.argv[1].endsWith("clean-cache.ts") || process.argv[1].endsWith("clean-cache.js"));
     if (isDirectRun) {
       main().catch((err) => {
@@ -3329,15 +3369,18 @@ function loadStorageState(accountId) {
     return void 0;
   }
 }
-async function saveStorageState(context, accountId, timeoutMs = 5e3) {
+async function saveStorageState(context, accountId, timeoutMs = 1e4) {
   try {
     const stateFile = getStorageStatePath(accountId);
     const dir = path5.dirname(stateFile);
     if (!fs8.existsSync(dir)) {
       fs8.mkdirSync(dir, { recursive: true });
     }
+    const rawPromise = context.storageState({ path: stateFile }).catch(() => {
+      return void 0;
+    });
     await withTimeout(
-      context.storageState({ path: stateFile }),
+      rawPromise,
       timeoutMs,
       `storageState timed out after ${timeoutMs}ms`
     );
@@ -10454,6 +10497,7 @@ var init_qwen = __esm({
 });
 
 // src/delete-chats.ts
+init_process_guard();
 import "dotenv/config";
 
 // src/services/chat-cleanup.ts
@@ -10517,6 +10561,12 @@ async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false) {
           `\u274C [DeleteChats] [${currentIdx}/${totalCount}] Falha ao apagar conversas de ${maskEmail(account.email)}:`,
           error instanceof Error ? error.message : String(error)
         );
+      } finally {
+        if (!keepBrowserOpen) {
+          const { closePlaywrightForAccount: closePlaywrightForAccount2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
+          await closePlaywrightForAccount2(account.id).catch(() => {
+          });
+        }
       }
     }
   } finally {
@@ -10537,6 +10587,7 @@ async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false) {
 }
 
 // src/delete-chats.ts
+installProcessTeardownGuards("DeleteChats");
 async function run() {
   console.log("\u{1F5D1}\uFE0F  [DeleteChats] Using Playwright sessions");
   const result = await deleteChatsForConfiguredAccounts();

package/dist/index.js

@@ -150,6 +150,44 @@ var init_paths = __esm({
   }
 });
 
+// src/core/process-guard.ts
+function isPlaywrightAlreadyClosedMessage(message) {
+  if (!message) return false;
+  return message.includes("Target page, context or browser has been closed") || message.includes("Browser has been closed") || message.includes("Target closed") || message.includes("Target crashed") || message.includes("Page crashed") || message.includes("Assertion error") || message.includes("Cannot find parent object") || message.includes("Connection closed") || message.includes("session closed") || message.includes("Session closed") || message.includes("Network.setCacheDisabled") || message.includes("Protocol error") || message.includes("storageState timed out");
+}
+function isBenignTeardownError(error) {
+  if (!error) return false;
+  const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
+  return isPlaywrightAlreadyClosedMessage(message);
+}
+function installProcessTeardownGuards(label = "Process") {
+  if (guardsInstalled) return;
+  guardsInstalled = true;
+  process.on("uncaughtException", (error) => {
+    if (isBenignTeardownError(error)) {
+      const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown exception: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Uncaught Exception:`, error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isBenignTeardownError(reason)) {
+      const msg = reason instanceof Error ? reason.message : typeof reason === "object" && reason !== null && "message" in reason ? String(reason.message) : String(reason);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown rejection: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Unhandled Rejection:`, reason);
+  });
+}
+var guardsInstalled;
+var init_process_guard = __esm({
+  "src/core/process-guard.ts"() {
+    "use strict";
+    guardsInstalled = false;
+  }
+});
+
 // src/core/config.ts
 import fs2 from "node:fs";
 import dotenv from "dotenv";
@@ -289,11 +327,11 @@ var init_config = __esm({
       // nothing in this window is dead and should fail fast, retryable).
       QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("60000"),
       TOTAL_REQUEST_TIMEOUT: z.string().default("600000"),
-      // Mid-stream silence window for thinking models: 3 min with ZERO upstream
+      // Mid-stream silence window for thinking models: 5 min with ZERO upstream
       // bytes is a dead stream (WAF swallow / dropped connection) — fail fast and
       // let the retry policy rotate accounts. Flowing reasoning chunks RESET this
       // timer, so legitimate slow thinking is never cut; only total silence is.
-      REASONING_MODEL_TIMEOUT: z.string().default("180000"),
+      REASONING_MODEL_TIMEOUT: z.string().default("300000"),
       CACHE_TTL: z.string().default("3600"),
       RESPONSE_TTL: z.string().default("1800"),
       CACHE_COMPRESSION_ENABLED: z.string().default("true"),
@@ -4260,6 +4298,8 @@ var init_clean_cache = __esm({
   "src/clean-cache.ts"() {
     "use strict";
     init_playwright();
+    init_process_guard();
+    installProcessTeardownGuards("CleanCache");
     isDirectRun = process.argv[1] && (process.argv[1].endsWith("clean-cache.ts") || process.argv[1].endsWith("clean-cache.js"));
     if (isDirectRun) {
       main().catch((err) => {
@@ -4484,15 +4524,18 @@ function loadStorageState(accountId) {
     return void 0;
   }
 }
-async function saveStorageState(context, accountId, timeoutMs = 5e3) {
+async function saveStorageState(context, accountId, timeoutMs = 1e4) {
   try {
     const stateFile = getStorageStatePath(accountId);
     const dir = path6.dirname(stateFile);
     if (!fs9.existsSync(dir)) {
       fs9.mkdirSync(dir, { recursive: true });
     }
+    const rawPromise = context.storageState({ path: stateFile }).catch(() => {
+      return void 0;
+    });
     await withTimeout(
-      context.storageState({ path: stateFile }),
+      rawPromise,
       timeoutMs,
       `storageState timed out after ${timeoutMs}ms`
     );
@@ -9415,6 +9458,11 @@ function isCorruptedChatHistoryError(err) {
   const message = errMessage(err).toLowerCase();
   return message.includes("first message must not") || message.includes("first message must be") || message.includes("must not assistant message") || message.includes("must not be assistant");
 }
+function isInternalServerError(err) {
+  const code = errCode(err).toLowerCase();
+  const message = errMessage(err).toLowerCase();
+  return code === "internal_error" || code === "internal_server_error" || code === "server_error" || code === "server_busy" || code === "busy" || message.includes("internal_error") || message.includes("ocorreu um erro inesperado") || message.includes("unexpected error") || message.includes("internal server error");
+}
 function makeRetryAction(reason, overrides = {}) {
   return {
     retryable: true,
@@ -9521,6 +9569,15 @@ function classifyRetryAction(err, options) {
       accountCooldownReason: quota.accountCooldownReason
     });
   }
+  if (isInternalServerError(err) && !(err instanceof QwenUpstreamError)) {
+    const typed = err;
+    return makeRetryAction("upstream_internal_error", {
+      switchAccount: typed.switchAccount !== false,
+      forceNewChat: true,
+      retryWithFullPrompt: true,
+      retryAfterMs: typed.retryAfterMs ?? Math.min(baseDelayMs * 2, 3e3)
+    });
+  }
   if (isNetworkLikeError(err) || err instanceof QwenUpstreamUnavailableError || err instanceof QwenUpstreamError || isAbortError(err)) {
     const typed = err;
     return makeRetryAction(
@@ -16063,6 +16120,12 @@ async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false) {
           `\u274C [DeleteChats] [${currentIdx}/${totalCount}] Falha ao apagar conversas de ${maskEmail(account.email)}:`,
           error instanceof Error ? error.message : String(error)
         );
+      } finally {
+        if (!keepBrowserOpen) {
+          const { closePlaywrightForAccount: closePlaywrightForAccount2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
+          await closePlaywrightForAccount2(account.id).catch(() => {
+          });
+        }
       }
     }
   } finally {
@@ -20853,6 +20916,7 @@ async function processStreamingResponse(params) {
     let activeReader = null;
     let invalidInputSameAccountRetries = 0;
     let chatInProgressSameAccountRetries = 0;
+    let antiBotSameAccountRetries = 0;
     const totalConfiguredAccounts = loadAccounts().length;
     let quotaRotationsLeft = Math.min(Math.max(1, totalConfiguredAccounts - 1), 6);
     let streamCompletedOk = false;
@@ -21260,7 +21324,16 @@ async function processStreamingResponse(params) {
           );
           return false;
         }
-        const switchAccount = policy.switchAccount && !retryInvalidInputOnSameAccount;
+        let switchAccount = policy.switchAccount && !retryInvalidInputOnSameAccount;
+        if (policy.reason === "anti_bot") {
+          if (antiBotSameAccountRetries === 0) {
+            antiBotSameAccountRetries++;
+            switchAccount = false;
+          } else {
+            switchAccount = true;
+            markAccountRateLimited(currentAccountId, 6e4, "AntiBotWafChallenge");
+          }
+        }
         if (switchAccount && (policy.accountCooldownMs ?? 0) > 0) {
           markAccountRateLimited(
             currentAccountId,
@@ -21272,6 +21345,33 @@ async function processStreamingResponse(params) {
           Promise.resolve().then(() => (init_playwright(), playwright_exports)).then(({ refreshAccountToken: refreshAccountToken2 }) => refreshAccountToken2(currentAccountId)).catch(() => {
           });
         }
+        if (currentUiSessionId && targetResponseId) {
+          const streamData = getStream(completionId);
+          const stopHeaders = streamData?.headers;
+          if (stopHeaders?.cookie && stopHeaders["user-agent"]) {
+            void requestQwenTextInBrowser(
+              currentAccountId,
+              "POST",
+              `/api/v2/chat/completions/stop?chat_id=${encodeURIComponent(currentUiSessionId)}`,
+              buildQwenRequestHeaders({
+                cookie: stopHeaders.cookie,
+                userAgent: stopHeaders["user-agent"],
+                bxUa: stopHeaders["bx-ua"],
+                bxUmidtoken: stopHeaders["bx-umidtoken"],
+                bxV: stopHeaders["bx-v"],
+                chatSessionId: currentUiSessionId
+              }),
+              JSON.stringify({
+                chat_id: currentUiSessionId,
+                response_id: targetResponseId
+              }),
+              {
+                referrer: qwenUrl(`/c/${encodeURIComponent(currentUiSessionId)}`),
+                noMutexRecovery: true
+              }
+            ).catch(() => void 0);
+          }
+        }
         retryContext.releaseAccountLease?.();
         retryContext.releaseAccountLease = null;
         await reader.cancel().catch(() => void 0);
@@ -26285,7 +26385,7 @@ function getAppVersion() {
     }
   } catch {
   }
-  cachedVersion = "v1.6.0";
+  cachedVersion = "v1.6.1";
   return cachedVersion;
 }
 var cachedVersion;
@@ -34808,6 +34908,7 @@ var init_app = __esm({
 
 // src/index.ts
 init_paths();
+init_process_guard();
 init_server();
 import dotenv2 from "dotenv";
 import fs26 from "node:fs";
@@ -34823,24 +34924,7 @@ if (fs26.existsSync(envPath)) {
 } else {
   dotenv2.config({ quiet: true });
 }
-process.on("uncaughtException", async (error) => {
-  const { isPlaywrightAlreadyClosedError: isPlaywrightAlreadyClosedError2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
-  if (isPlaywrightAlreadyClosedError2(error)) {
-    const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
-    console.warn(`\u26A0\uFE0F  [Playwright] Handled benign driver teardown exception: ${msg}`);
-    return;
-  }
-  console.error("\u274C [Process] Uncaught Exception:", error);
-});
-process.on("unhandledRejection", async (reason) => {
-  const { isPlaywrightAlreadyClosedError: isPlaywrightAlreadyClosedError2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
-  if (isPlaywrightAlreadyClosedError2(reason)) {
-    const msg = reason instanceof Error ? reason.message : typeof reason === "object" && reason !== null && "message" in reason ? String(reason.message) : String(reason);
-    console.warn(`\u26A0\uFE0F  [Playwright] Handled benign driver teardown rejection: ${msg}`);
-    return;
-  }
-  console.error("\u274C [Process] Unhandled Rejection:", reason);
-});
+installProcessTeardownGuards("Playwright");
 var isTui = process.argv.includes("--tui") || process.env.QWEN_TUI === "true";
 if (isTui) {
   const { TuiApp: TuiApp2 } = await Promise.resolve().then(() => (init_app(), app_exports));

package/dist/login.js

@@ -1102,6 +1102,44 @@ var init_logger = __esm({
   }
 });
 
+// src/core/process-guard.ts
+function isPlaywrightAlreadyClosedMessage(message) {
+  if (!message) return false;
+  return message.includes("Target page, context or browser has been closed") || message.includes("Browser has been closed") || message.includes("Target closed") || message.includes("Target crashed") || message.includes("Page crashed") || message.includes("Assertion error") || message.includes("Cannot find parent object") || message.includes("Connection closed") || message.includes("session closed") || message.includes("Session closed") || message.includes("Network.setCacheDisabled") || message.includes("Protocol error") || message.includes("storageState timed out");
+}
+function isBenignTeardownError(error) {
+  if (!error) return false;
+  const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
+  return isPlaywrightAlreadyClosedMessage(message);
+}
+function installProcessTeardownGuards(label = "Process") {
+  if (guardsInstalled) return;
+  guardsInstalled = true;
+  process.on("uncaughtException", (error) => {
+    if (isBenignTeardownError(error)) {
+      const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown exception: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Uncaught Exception:`, error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isBenignTeardownError(reason)) {
+      const msg = reason instanceof Error ? reason.message : typeof reason === "object" && reason !== null && "message" in reason ? String(reason.message) : String(reason);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown rejection: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Unhandled Rejection:`, reason);
+  });
+}
+var guardsInstalled;
+var init_process_guard = __esm({
+  "src/core/process-guard.ts"() {
+    "use strict";
+    guardsInstalled = false;
+  }
+});
+
 // src/core/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -1251,11 +1289,11 @@ var init_config = __esm({
       // nothing in this window is dead and should fail fast, retryable).
       QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("60000"),
       TOTAL_REQUEST_TIMEOUT: z.string().default("600000"),
-      // Mid-stream silence window for thinking models: 3 min with ZERO upstream
+      // Mid-stream silence window for thinking models: 5 min with ZERO upstream
       // bytes is a dead stream (WAF swallow / dropped connection) — fail fast and
       // let the retry policy rotate accounts. Flowing reasoning chunks RESET this
       // timer, so legitimate slow thinking is never cut; only total silence is.
-      REASONING_MODEL_TIMEOUT: z.string().default("180000"),
+      REASONING_MODEL_TIMEOUT: z.string().default("300000"),
       CACHE_TTL: z.string().default("3600"),
       RESPONSE_TTL: z.string().default("1800"),
       CACHE_COMPRESSION_ENABLED: z.string().default("true"),
@@ -3127,6 +3165,8 @@ var init_clean_cache = __esm({
   "src/clean-cache.ts"() {
     "use strict";
     init_playwright();
+    init_process_guard();
+    installProcessTeardownGuards("CleanCache");
     isDirectRun = process.argv[1] && (process.argv[1].endsWith("clean-cache.ts") || process.argv[1].endsWith("clean-cache.js"));
     if (isDirectRun) {
       main().catch((err) => {
@@ -3351,15 +3391,18 @@ function loadStorageState(accountId) {
     return void 0;
   }
 }
-async function saveStorageState(context, accountId, timeoutMs = 5e3) {
+async function saveStorageState(context, accountId, timeoutMs = 1e4) {
   try {
     const stateFile = getStorageStatePath(accountId);
     const dir = path5.dirname(stateFile);
     if (!fs8.existsSync(dir)) {
       fs8.mkdirSync(dir, { recursive: true });
     }
+    const rawPromise = context.storageState({ path: stateFile }).catch(() => {
+      return void 0;
+    });
     await withTimeout(
-      context.storageState({ path: stateFile }),
+      rawPromise,
       timeoutMs,
       `storageState timed out after ${timeoutMs}ms`
     );
@@ -6698,10 +6741,12 @@ var init_playwright = __esm({
 // src/login.ts
 init_accounts();
 init_logger();
+init_process_guard();
 import crypto4 from "crypto";
 import * as readline from "readline";
 import * as dotenv2 from "dotenv";
 dotenv2.config();
+installProcessTeardownGuards("Login");
 var rl = readline.createInterface({
   input: process.stdin,
   output: process.stdout

package/dist/reset-cooldowns.js

@@ -1353,11 +1353,11 @@ var init_config = __esm({
       // nothing in this window is dead and should fail fast, retryable).
       QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("60000"),
       TOTAL_REQUEST_TIMEOUT: z.string().default("600000"),
-      // Mid-stream silence window for thinking models: 3 min with ZERO upstream
+      // Mid-stream silence window for thinking models: 5 min with ZERO upstream
       // bytes is a dead stream (WAF swallow / dropped connection) — fail fast and
       // let the retry policy rotate accounts. Flowing reasoning chunks RESET this
       // timer, so legitimate slow thinking is never cut; only total silence is.
-      REASONING_MODEL_TIMEOUT: z.string().default("180000"),
+      REASONING_MODEL_TIMEOUT: z.string().default("300000"),
       CACHE_TTL: z.string().default("3600"),
       RESPONSE_TTL: z.string().default("1800"),
       CACHE_COMPRESSION_ENABLED: z.string().default("true"),
@@ -2730,6 +2730,44 @@ var init_jwt = __esm({
   }
 });
 
+// src/core/process-guard.ts
+function isPlaywrightAlreadyClosedMessage(message) {
+  if (!message) return false;
+  return message.includes("Target page, context or browser has been closed") || message.includes("Browser has been closed") || message.includes("Target closed") || message.includes("Target crashed") || message.includes("Page crashed") || message.includes("Assertion error") || message.includes("Cannot find parent object") || message.includes("Connection closed") || message.includes("session closed") || message.includes("Session closed") || message.includes("Network.setCacheDisabled") || message.includes("Protocol error") || message.includes("storageState timed out");
+}
+function isBenignTeardownError(error) {
+  if (!error) return false;
+  const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
+  return isPlaywrightAlreadyClosedMessage(message);
+}
+function installProcessTeardownGuards(label = "Process") {
+  if (guardsInstalled) return;
+  guardsInstalled = true;
+  process.on("uncaughtException", (error) => {
+    if (isBenignTeardownError(error)) {
+      const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown exception: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Uncaught Exception:`, error);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isBenignTeardownError(reason)) {
+      const msg = reason instanceof Error ? reason.message : typeof reason === "object" && reason !== null && "message" in reason ? String(reason.message) : String(reason);
+      console.warn(`\u26A0\uFE0F  [${label}] Handled benign driver teardown rejection: ${msg}`);
+      return;
+    }
+    console.error(`\u274C [${label}] Unhandled Rejection:`, reason);
+  });
+}
+var guardsInstalled;
+var init_process_guard = __esm({
+  "src/core/process-guard.ts"() {
+    "use strict";
+    guardsInstalled = false;
+  }
+});
+
 // src/clean-cache.ts
 var clean_cache_exports = {};
 __export(clean_cache_exports, {
@@ -2898,6 +2936,8 @@ var init_clean_cache = __esm({
   "src/clean-cache.ts"() {
     "use strict";
     init_playwright();
+    init_process_guard();
+    installProcessTeardownGuards("CleanCache");
     isDirectRun = process.argv[1] && (process.argv[1].endsWith("clean-cache.ts") || process.argv[1].endsWith("clean-cache.js"));
     if (isDirectRun) {
       main().catch((err) => {
@@ -3071,15 +3111,18 @@ function loadStorageState(accountId) {
     return void 0;
   }
 }
-async function saveStorageState(context, accountId, timeoutMs = 5e3) {
+async function saveStorageState(context, accountId, timeoutMs = 1e4) {
   try {
     const stateFile = getStorageStatePath(accountId);
     const dir = path5.dirname(stateFile);
     if (!fs8.existsSync(dir)) {
       fs8.mkdirSync(dir, { recursive: true });
     }
+    const rawPromise = context.storageState({ path: stateFile }).catch(() => {
+      return void 0;
+    });
     await withTimeout(
-      context.storageState({ path: stateFile }),
+      rawPromise,
       timeoutMs,
       `storageState timed out after ${timeoutMs}ms`
     );

package/dist/sync-clients.js

@@ -183,11 +183,11 @@ var envSchema = z.object({
   // nothing in this window is dead and should fail fast, retryable).
   QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("60000"),
   TOTAL_REQUEST_TIMEOUT: z.string().default("600000"),
-  // Mid-stream silence window for thinking models: 3 min with ZERO upstream
+  // Mid-stream silence window for thinking models: 5 min with ZERO upstream
   // bytes is a dead stream (WAF swallow / dropped connection) — fail fast and
   // let the retry policy rotate accounts. Flowing reasoning chunks RESET this
   // timer, so legitimate slow thinking is never cut; only total silence is.
-  REASONING_MODEL_TIMEOUT: z.string().default("180000"),
+  REASONING_MODEL_TIMEOUT: z.string().default("300000"),
   CACHE_TTL: z.string().default("3600"),
   RESPONSE_TTL: z.string().default("1800"),
   CACHE_COMPRESSION_ENABLED: z.string().default("true"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "High-performance OpenAI & Anthropic compatible API gateway for Qwen with multi-account rotation, interactive TUI, and resilient tool calling.",
   "main": "src/index.ts",
   "bin": {

package/src/clean-cache.ts

@@ -4,6 +4,9 @@ import path from "node:path";
 import os from "node:os";
 import { chromium } from "patchright";
 import { pruneAllPlaywrightProfiles, cleanupOrphanProfiles } from "./services/playwright.ts";
+import { installProcessTeardownGuards } from "./core/process-guard.ts";
+
+installProcessTeardownGuards("CleanCache");
 
 export function formatBytes(bytes: number): string {
   if (bytes < 1024) return `${bytes} B`;

package/src/core/config.ts

@@ -102,11 +102,11 @@ const envSchema = z
     // nothing in this window is dead and should fail fast, retryable).
     QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("60000"),
     TOTAL_REQUEST_TIMEOUT: z.string().default("600000"),
-    // Mid-stream silence window for thinking models: 3 min with ZERO upstream
+    // Mid-stream silence window for thinking models: 5 min with ZERO upstream
     // bytes is a dead stream (WAF swallow / dropped connection) — fail fast and
     // let the retry policy rotate accounts. Flowing reasoning chunks RESET this
     // timer, so legitimate slow thinking is never cut; only total silence is.
-    REASONING_MODEL_TIMEOUT: z.string().default("180000"),
+    REASONING_MODEL_TIMEOUT: z.string().default("300000"),
     CACHE_TTL: z.string().default("3600"),
     RESPONSE_TTL: z.string().default("1800"),
     CACHE_COMPRESSION_ENABLED: z.string().default("true"),

package/src/core/process-guard.ts

@@ -0,0 +1,77 @@
+/**
+ * Process teardown error guard.
+ *
+ * Catches unhandled rejections and uncaught exceptions that arise from
+ * benign browser/CDP connection closures (e.g. ProtocolError: session closed,
+ * Network.setCacheDisabled, target crashed during shutdown) and prevents
+ * them from terminating the Node.js process.
+ */
+
+export function isPlaywrightAlreadyClosedMessage(message: string): boolean {
+  if (!message) return false;
+  return (
+    message.includes("Target page, context or browser has been closed") ||
+    message.includes("Browser has been closed") ||
+    message.includes("Target closed") ||
+    message.includes("Target crashed") ||
+    message.includes("Page crashed") ||
+    message.includes("Assertion error") ||
+    message.includes("Cannot find parent object") ||
+    message.includes("Connection closed") ||
+    message.includes("session closed") ||
+    message.includes("Session closed") ||
+    message.includes("Network.setCacheDisabled") ||
+    message.includes("Protocol error") ||
+    message.includes("storageState timed out")
+  );
+}
+
+export function isBenignTeardownError(error: unknown): boolean {
+  if (!error) return false;
+  const message =
+    error instanceof Error
+      ? error.message
+      : typeof error === "object" && "message" in error
+        ? String((error as any).message)
+        : String(error);
+  return isPlaywrightAlreadyClosedMessage(message);
+}
+
+let guardsInstalled = false;
+
+/**
+ * Installs process-wide handlers for uncaughtException and unhandledRejection
+ * to guard against asynchronous Playwright/CDP driver teardown crashes.
+ */
+export function installProcessTeardownGuards(label = "Process"): void {
+  if (guardsInstalled) return;
+  guardsInstalled = true;
+
+  process.on("uncaughtException", (error: unknown) => {
+    if (isBenignTeardownError(error)) {
+      const msg =
+        error instanceof Error
+          ? error.message
+          : typeof error === "object" && error !== null && "message" in error
+            ? String((error as any).message)
+            : String(error);
+      console.warn(`⚠️  [${label}] Handled benign driver teardown exception: ${msg}`);
+      return;
+    }
+    console.error(`❌ [${label}] Uncaught Exception:`, error);
+  });
+
+  process.on("unhandledRejection", (reason: unknown) => {
+    if (isBenignTeardownError(reason)) {
+      const msg =
+        reason instanceof Error
+          ? reason.message
+          : typeof reason === "object" && reason !== null && "message" in reason
+            ? String((reason as any).message)
+            : String(reason);
+      console.warn(`⚠️  [${label}] Handled benign driver teardown rejection: ${msg}`);
+      return;
+    }
+    console.error(`❌ [${label}] Unhandled Rejection:`, reason);
+  });
+}

package/src/core/version.ts

@@ -17,6 +17,6 @@ export function getAppVersion(): string {
       }
     }
   } catch {}
-  cachedVersion = "v1.6.0";
+  cachedVersion = "v1.6.1";
   return cachedVersion;
 }

package/src/delete-chats.ts

@@ -1,6 +1,9 @@
 import "dotenv/config";
+import { installProcessTeardownGuards } from "./core/process-guard.ts";
 import { deleteChatsForConfiguredAccounts } from "./services/chat-cleanup.ts";
 
+installProcessTeardownGuards("DeleteChats");
+
 async function run(): Promise<void> {
   console.log("🗑️  [DeleteChats] Using Playwright sessions");
 

package/src/index.ts

@@ -16,36 +16,10 @@ if (fs.existsSync(envPath)) {
 } else {
   dotenv.config({ quiet: true })
 }
-// Prevent benign asynchronous driver/browser teardown exceptions from crashing the server
-process.on('uncaughtException', async (error: unknown) => {
-  const { isPlaywrightAlreadyClosedError } = await import('./services/playwright.ts');
-  if (isPlaywrightAlreadyClosedError(error)) {
-    const msg =
-      error instanceof Error
-        ? error.message
-        : typeof error === 'object' && error !== null && 'message' in error
-          ? String((error as any).message)
-          : String(error);
-    console.warn(`⚠️  [Playwright] Handled benign driver teardown exception: ${msg}`);
-    return;
-  }
-  console.error('❌ [Process] Uncaught Exception:', error);
-});
+import { installProcessTeardownGuards } from './core/process-guard.ts'
 
-process.on('unhandledRejection', async (reason: unknown) => {
-  const { isPlaywrightAlreadyClosedError } = await import('./services/playwright.ts');
-  if (isPlaywrightAlreadyClosedError(reason)) {
-    const msg =
-      reason instanceof Error
-        ? reason.message
-        : typeof reason === 'object' && reason !== null && 'message' in reason
-          ? String((reason as any).message)
-          : String(reason);
-    console.warn(`⚠️  [Playwright] Handled benign driver teardown rejection: ${msg}`);
-    return;
-  }
-  console.error('❌ [Process] Unhandled Rejection:', reason);
-});
+// Prevent benign asynchronous driver/browser teardown exceptions from crashing the server
+installProcessTeardownGuards("Playwright");
 import { startServer } from './api/server.js'
 const isTui = process.argv.includes('--tui') || process.env.QWEN_TUI === 'true'
 

package/src/login.ts

@@ -9,8 +9,10 @@ import {
 import { maskEmail } from "./core/logger.ts";
 import * as readline from "readline";
 import * as dotenv from "dotenv";
+import { installProcessTeardownGuards } from "./core/process-guard.ts";
 
 dotenv.config();
+installProcessTeardownGuards("Login");
 
 const rl = readline.createInterface({
   input: process.stdin,

package/src/routes/chat/retry-policy.ts

@@ -404,6 +404,26 @@ export function isCorruptedChatHistoryError(err: unknown): boolean {
   );
 }
 
+/**
+ * Qwen upstream internal or server-busy errors.
+ * Transient server-side failures requiring a fresh chat and account switch.
+ */
+export function isInternalServerError(err: unknown): boolean {
+  const code = errCode(err).toLowerCase();
+  const message = errMessage(err).toLowerCase();
+  return (
+    code === "internal_error" ||
+    code === "internal_server_error" ||
+    code === "server_error" ||
+    code === "server_busy" ||
+    code === "busy" ||
+    message.includes("internal_error") ||
+    message.includes("ocorreu um erro inesperado") ||
+    message.includes("unexpected error") ||
+    message.includes("internal server error")
+  );
+}
+
 /**
  * Build a RetryAction with sane defaults so each classification branch only
  * spells out the fields it actually changes. Defaults: retryable, no account
@@ -590,6 +610,16 @@ export function classifyRetryAction(
       });
     }
 
+    if (isInternalServerError(err) && !(err instanceof QwenUpstreamError)) {
+      const typed = err as RetryableStreamError;
+      return makeRetryAction("upstream_internal_error", {
+        switchAccount: typed.switchAccount !== false,
+        forceNewChat: true,
+        retryWithFullPrompt: true,
+        retryAfterMs: typed.retryAfterMs ?? Math.min(baseDelayMs * 2, 3000),
+      });
+    }
+
     if (
         isNetworkLikeError(err) ||
         err instanceof QwenUpstreamUnavailableError ||

package/src/routes/chat/streaming.ts

@@ -906,6 +906,7 @@ export async function processStreamingResponse(
     let activeReader: ReadableStreamDefaultReader<Uint8Array> | null = null;
     let invalidInputSameAccountRetries = 0;
     let chatInProgressSameAccountRetries = 0;
+    let antiBotSameAccountRetries = 0;
     const totalConfiguredAccounts = loadAccounts().length;
     let quotaRotationsLeft = Math.min(Math.max(1, totalConfiguredAccounts - 1), 6);
     // Set when the terminal [DONE] reached the client. The `| recovered`
@@ -1456,9 +1457,19 @@ export async function processStreamingResponse(
           );
           return false;
         }
-        const switchAccount =
+        let switchAccount =
           policy.switchAccount && !retryInvalidInputOnSameAccount;
 
+        if (policy.reason === "anti_bot") {
+          if (antiBotSameAccountRetries === 0) {
+            antiBotSameAccountRetries++;
+            switchAccount = false;
+          } else {
+            switchAccount = true;
+            markAccountRateLimited(currentAccountId, 60_000, "AntiBotWafChallenge");
+          }
+        }
+
         if (
           switchAccount &&
           (policy.accountCooldownMs ?? 0) > 0
@@ -1476,6 +1487,35 @@ export async function processStreamingResponse(
             .catch(() => {});
         }
 
+        // Preventative stop: signal Qwen to stop generating on the backend before switching
+        if (currentUiSessionId && targetResponseId) {
+          const streamData = getStream(completionId);
+          const stopHeaders = streamData?.headers;
+          if (stopHeaders?.cookie && stopHeaders["user-agent"]) {
+            void requestQwenTextInBrowser(
+              currentAccountId,
+              "POST",
+              `/api/v2/chat/completions/stop?chat_id=${encodeURIComponent(currentUiSessionId)}`,
+              buildQwenRequestHeaders({
+                cookie: stopHeaders.cookie,
+                userAgent: stopHeaders["user-agent"],
+                bxUa: stopHeaders["bx-ua"],
+                bxUmidtoken: stopHeaders["bx-umidtoken"],
+                bxV: stopHeaders["bx-v"],
+                chatSessionId: currentUiSessionId,
+              }),
+              JSON.stringify({
+                chat_id: currentUiSessionId,
+                response_id: targetResponseId,
+              }),
+              {
+                referrer: qwenUrl(`/c/${encodeURIComponent(currentUiSessionId)}`),
+                noMutexRecovery: true,
+              },
+            ).catch(() => undefined);
+          }
+        }
+
         retryContext.releaseAccountLease?.();
         retryContext.releaseAccountLease = null;
         await reader.cancel().catch(() => undefined);

package/src/services/chat-cleanup.ts

@@ -108,6 +108,11 @@ export async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false):
           `❌ [DeleteChats] [${currentIdx}/${totalCount}] Falha ao apagar conversas de ${maskEmail(account.email)}:`,
           error instanceof Error ? error.message : String(error),
         );
+      } finally {
+        if (!keepBrowserOpen) {
+          const { closePlaywrightForAccount } = await import("./playwright.ts");
+          await closePlaywrightForAccount(account.id).catch(() => {});
+        }
       }
     }
   } finally {

package/src/services/playwright.ts

@@ -287,7 +287,7 @@ export function loadStorageState(accountId: string): string | undefined {
 export async function saveStorageState(
   context: BrowserContext,
   accountId: string,
-  timeoutMs = 5_000,
+  timeoutMs = 10_000,
 ): Promise<void> {
   try {
     const stateFile = getStorageStatePath(accountId);
@@ -295,8 +295,12 @@ export async function saveStorageState(
     if (!fs.existsSync(dir)) {
       fs.mkdirSync(dir, { recursive: true });
     }
+    const rawPromise = context.storageState({ path: stateFile }).catch(() => {
+      // Swallowed on context teardown to avoid unhandled rejection if withTimeout already fired
+      return undefined as any;
+    });
     await withTimeout(
-      context.storageState({ path: stateFile }),
+      rawPromise,
       timeoutMs,
       `storageState timed out after ${timeoutMs}ms`,
     );