qwenproxy-cli 1.6.5 → 1.6.7

package/dist/clean-cache.js

@@ -3588,6 +3588,15 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
     await existingInit;
     return;
   }
+  let resolveInit;
+  let rejectInit;
+  const inFlightDeferred = new Promise((res, rej) => {
+    resolveInit = res;
+    rejectInit = rej;
+  });
+  inFlightDeferred.catch(() => {
+  });
+  inFlightAccountInits.set(account.id, inFlightDeferred);
   const initPromise = (async () => {
     const release = await acquireAccountMutex(
       account.id,
@@ -3872,9 +3881,12 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
       release();
     }
   })();
-  inFlightAccountInits.set(account.id, initPromise);
   try {
     await initPromise;
+    resolveInit();
+  } catch (error) {
+    rejectInit(error);
+    throw error;
   } finally {
     inFlightAccountInits.delete(account.id);
   }
@@ -5481,7 +5493,10 @@ function isPlaywrightAlreadyClosedMessage(message) {
   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;
+  if (!error) return true;
+  if (typeof error === "object" && Object.keys(error).length === 0 && !(error instanceof Error)) {
+    return true;
+  }
   const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
   return isPlaywrightAlreadyClosedMessage(message);
 }

package/dist/delete-chats.js

@@ -19,7 +19,10 @@ function isPlaywrightAlreadyClosedMessage(message) {
   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;
+  if (!error) return true;
+  if (typeof error === "object" && Object.keys(error).length === 0 && !(error instanceof Error)) {
+    return true;
+  }
   const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
   return isPlaywrightAlreadyClosedMessage(message);
 }
@@ -4447,6 +4450,15 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
     await existingInit;
     return;
   }
+  let resolveInit;
+  let rejectInit;
+  const inFlightDeferred = new Promise((res, rej) => {
+    resolveInit = res;
+    rejectInit = rej;
+  });
+  inFlightDeferred.catch(() => {
+  });
+  inFlightAccountInits.set(account.id, inFlightDeferred);
   const initPromise = (async () => {
     const release = await acquireAccountMutex(
       account.id,
@@ -4731,9 +4743,12 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
       release();
     }
   })();
-  inFlightAccountInits.set(account.id, initPromise);
   try {
     await initPromise;
+    resolveInit();
+  } catch (error) {
+    rejectInit(error);
+    throw error;
   } finally {
     inFlightAccountInits.delete(account.id);
   }
@@ -7370,6 +7385,10 @@ function stripThinkingSuffix(model) {
       reasoningMode: "thinking"
     };
   }
+  const lower = normalizedModel.toLowerCase();
+  if (lower.includes("omni-flash") || lower.includes("turbo")) {
+    return { baseModel: normalizedModel, enableThinking: false, reasoningMode: "fast" };
+  }
   return { baseModel: normalizedModel, enableThinking: true, reasoningMode: "auto" };
 }
 function mapKnownModelAlias(model) {
@@ -7737,6 +7756,14 @@ async function recoverBaxiaCaptcha(accountId, label, options = {}) {
   );
   const challengeUrl = options.challengeBody ? extractBaxiaChallengeUrl(options.challengeBody, config.qwen.baseUrl) : null;
   activeCaptchaRecoveries.add(accountId);
+  try {
+    const { abortActiveBrowserStreamsForAccount: abortActiveBrowserStreamsForAccount2 } = await Promise.resolve().then(() => (init_qwen(), qwen_exports));
+    abortActiveBrowserStreamsForAccount2(
+      accountId,
+      "Account stream interrupted by captcha challenge recovery"
+    );
+  } catch {
+  }
   try {
     const solved = await withAccountPage(
       accountId,
@@ -8513,6 +8540,7 @@ __export(qwen_exports, {
   QwenUpstreamUnavailableError: () => QwenUpstreamUnavailableError,
   RetryableQwenStreamError: () => RetryableQwenStreamError,
   STREAM_SLOT_MAX_HOLD_MS: () => STREAM_SLOT_MAX_HOLD_MS,
+  abortActiveBrowserStreamsForAccount: () => abortActiveBrowserStreamsForAccount,
   acquireAccountStreamLock: () => acquireAccountStreamLock,
   acquireNewQwenChatSession: () => acquireNewQwenChatSession,
   buildCapturedQwenHeaders: () => buildCapturedQwenHeaders,
@@ -8559,6 +8587,27 @@ __export(qwen_exports, {
 });
 import crypto5 from "crypto";
 import { v4 as uuidv43 } from "uuid";
+function abortActiveBrowserStreamsForAccount(accountId, reason = "Account browser stream interrupted (page context unloaded)") {
+  let count = 0;
+  for (const [requestId, state] of browserStreamStates) {
+    if (state.accountId === accountId && !state.done) {
+      count++;
+      handleBrowserStreamEvent(requestId, {
+        type: "error",
+        message: reason,
+        errorName: "AbortError"
+      });
+    }
+  }
+  if (count > 0) {
+    logger.debug("[Qwen] Aborted active browser streams for account", {
+      accountId,
+      count,
+      reason
+    });
+  }
+  return count;
+}
 async function registerBrowserContextStreamBinding(context) {
   if (browserStreamBindingContexts.has(context)) return;
   browserStreamBindingContexts.add(context);
@@ -9253,6 +9302,7 @@ async function createQwenBrowserResponse(accountId, url, method, headers, body,
   }
   const requestId = uuidv43();
   const state = {
+    accountId,
     chunks: [],
     done: false,
     error: null,
@@ -9269,10 +9319,15 @@ async function createQwenBrowserResponse(accountId, url, method, headers, body,
   let settled = false;
   let abortListener;
   let cancelPromise;
+  let pageCleanup;
   const cleanup = () => {
     if (settled) return;
     settled = true;
     if (abortListener) signal.removeEventListener("abort", abortListener);
+    try {
+      pageCleanup?.();
+    } catch {
+    }
     browserStreamStates.delete(requestId);
   };
   const cancel = () => {
@@ -9306,6 +9361,35 @@ async function createQwenBrowserResponse(accountId, url, method, headers, body,
       accountId,
       async (page) => {
         await ensureBrowserStreamBinding(page);
+        if (typeof page.on === "function") {
+          const onFrameNavigated = (frame) => {
+            if (!settled && typeof page.mainFrame === "function" && frame === page.mainFrame()) {
+              handleBrowserStreamEvent(requestId, {
+                type: "error",
+                message: "Qwen browser page navigated during stream (session interrupted)",
+                errorName: "AbortError"
+              });
+            }
+          };
+          const onPageClosed = () => {
+            if (!settled) {
+              handleBrowserStreamEvent(requestId, {
+                type: "error",
+                message: "Qwen browser page closed during stream",
+                errorName: "AbortError"
+              });
+            }
+          };
+          page.on("framenavigated", onFrameNavigated);
+          page.on("close", onPageClosed);
+          pageCleanup = () => {
+            try {
+              page.off?.("framenavigated", onFrameNavigated);
+              page.off?.("close", onPageClosed);
+            } catch {
+            }
+          };
+        }
         if (config.captcha.enabled) {
           captchaWatcher = startBaxiaCaptchaWatcher(
             page,
@@ -10490,7 +10574,7 @@ async function createQwenStreamInternal(prompt, enableThinking, modelId, forcedP
         }
       });
     }
-    const baseTimeoutMs = enableThinking ? config.timeouts.reasoningModelTimeout : config.timeouts.idleStreamTimeout;
+    const baseTimeoutMs = config.timeouts.idleStreamTimeout;
     const dynamicIdleTimeoutMs = computeDynamicIdleTimeout({
       enableThinking,
       parallelEscape: options?.parallelEscape,
@@ -10506,9 +10590,10 @@ async function createQwenStreamInternal(prompt, enableThinking, modelId, forcedP
       dynamicTimeout: dynamicIdleTimeoutMs
     });
     const firstChunkDeadlineMs = enableThinking ? Math.max(
+      config.timeouts.reasoningModelTimeout,
       config.timeouts.firstChunkTimeout,
       config.timeouts.timeToFirstByte
-    ) : void 0;
+    ) : Math.max(config.timeouts.firstChunkTimeout, config.timeouts.timeToFirstByte);
     return addIdleTimeoutToStream(
       stream,
       controller2,

package/dist/index.js

@@ -156,7 +156,10 @@ function isPlaywrightAlreadyClosedMessage(message) {
   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;
+  if (!error) return true;
+  if (typeof error === "object" && Object.keys(error).length === 0 && !(error instanceof Error)) {
+    return true;
+  }
   const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
   return isPlaywrightAlreadyClosedMessage(message);
 }
@@ -5557,6 +5560,15 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
     await existingInit;
     return;
   }
+  let resolveInit;
+  let rejectInit;
+  const inFlightDeferred = new Promise((res, rej) => {
+    resolveInit = res;
+    rejectInit = rej;
+  });
+  inFlightDeferred.catch(() => {
+  });
+  inFlightAccountInits.set(account.id, inFlightDeferred);
   const initPromise = (async () => {
     const release = await acquireAccountMutex(
       account.id,
@@ -5841,9 +5853,12 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
       release();
     }
   })();
-  inFlightAccountInits.set(account.id, initPromise);
   try {
     await initPromise;
+    resolveInit();
+  } catch (error) {
+    rejectInit(error);
+    throw error;
   } finally {
     inFlightAccountInits.delete(account.id);
   }
@@ -8718,6 +8733,10 @@ function stripThinkingSuffix(model) {
       reasoningMode: "thinking"
     };
   }
+  const lower = normalizedModel.toLowerCase();
+  if (lower.includes("omni-flash") || lower.includes("turbo")) {
+    return { baseModel: normalizedModel, enableThinking: false, reasoningMode: "fast" };
+  }
   return { baseModel: normalizedModel, enableThinking: true, reasoningMode: "auto" };
 }
 function mapKnownModelAlias(model) {
@@ -9127,6 +9146,14 @@ async function recoverBaxiaCaptcha(accountId, label, options = {}) {
   );
   const challengeUrl = options.challengeBody ? extractBaxiaChallengeUrl(options.challengeBody, config.qwen.baseUrl) : null;
   activeCaptchaRecoveries.add(accountId);
+  try {
+    const { abortActiveBrowserStreamsForAccount: abortActiveBrowserStreamsForAccount2 } = await Promise.resolve().then(() => (init_qwen(), qwen_exports));
+    abortActiveBrowserStreamsForAccount2(
+      accountId,
+      "Account stream interrupted by captcha challenge recovery"
+    );
+  } catch {
+  }
   try {
     const solved = await withAccountPage(
       accountId,
@@ -11703,6 +11730,7 @@ __export(qwen_exports, {
   QwenUpstreamUnavailableError: () => QwenUpstreamUnavailableError,
   RetryableQwenStreamError: () => RetryableQwenStreamError,
   STREAM_SLOT_MAX_HOLD_MS: () => STREAM_SLOT_MAX_HOLD_MS,
+  abortActiveBrowserStreamsForAccount: () => abortActiveBrowserStreamsForAccount,
   acquireAccountStreamLock: () => acquireAccountStreamLock,
   acquireNewQwenChatSession: () => acquireNewQwenChatSession,
   buildCapturedQwenHeaders: () => buildCapturedQwenHeaders,
@@ -11749,6 +11777,27 @@ __export(qwen_exports, {
 });
 import crypto7 from "crypto";
 import { v4 as uuidv43 } from "uuid";
+function abortActiveBrowserStreamsForAccount(accountId, reason = "Account browser stream interrupted (page context unloaded)") {
+  let count = 0;
+  for (const [requestId, state] of browserStreamStates) {
+    if (state.accountId === accountId && !state.done) {
+      count++;
+      handleBrowserStreamEvent(requestId, {
+        type: "error",
+        message: reason,
+        errorName: "AbortError"
+      });
+    }
+  }
+  if (count > 0) {
+    logger.debug("[Qwen] Aborted active browser streams for account", {
+      accountId,
+      count,
+      reason
+    });
+  }
+  return count;
+}
 async function registerBrowserContextStreamBinding(context) {
   if (browserStreamBindingContexts.has(context)) return;
   browserStreamBindingContexts.add(context);
@@ -12443,6 +12492,7 @@ async function createQwenBrowserResponse(accountId, url, method, headers, body,
   }
   const requestId = uuidv43();
   const state = {
+    accountId,
     chunks: [],
     done: false,
     error: null,
@@ -12459,10 +12509,15 @@ async function createQwenBrowserResponse(accountId, url, method, headers, body,
   let settled = false;
   let abortListener;
   let cancelPromise;
+  let pageCleanup;
   const cleanup = () => {
     if (settled) return;
     settled = true;
     if (abortListener) signal.removeEventListener("abort", abortListener);
+    try {
+      pageCleanup?.();
+    } catch {
+    }
     browserStreamStates.delete(requestId);
   };
   const cancel = () => {
@@ -12496,6 +12551,35 @@ async function createQwenBrowserResponse(accountId, url, method, headers, body,
       accountId,
       async (page) => {
         await ensureBrowserStreamBinding(page);
+        if (typeof page.on === "function") {
+          const onFrameNavigated = (frame) => {
+            if (!settled && typeof page.mainFrame === "function" && frame === page.mainFrame()) {
+              handleBrowserStreamEvent(requestId, {
+                type: "error",
+                message: "Qwen browser page navigated during stream (session interrupted)",
+                errorName: "AbortError"
+              });
+            }
+          };
+          const onPageClosed = () => {
+            if (!settled) {
+              handleBrowserStreamEvent(requestId, {
+                type: "error",
+                message: "Qwen browser page closed during stream",
+                errorName: "AbortError"
+              });
+            }
+          };
+          page.on("framenavigated", onFrameNavigated);
+          page.on("close", onPageClosed);
+          pageCleanup = () => {
+            try {
+              page.off?.("framenavigated", onFrameNavigated);
+              page.off?.("close", onPageClosed);
+            } catch {
+            }
+          };
+        }
         if (config.captcha.enabled) {
           captchaWatcher = startBaxiaCaptchaWatcher(
             page,
@@ -13680,7 +13764,7 @@ async function createQwenStreamInternal(prompt, enableThinking, modelId, forcedP
         }
       });
     }
-    const baseTimeoutMs = enableThinking ? config.timeouts.reasoningModelTimeout : config.timeouts.idleStreamTimeout;
+    const baseTimeoutMs = config.timeouts.idleStreamTimeout;
     const dynamicIdleTimeoutMs = computeDynamicIdleTimeout({
       enableThinking,
       parallelEscape: options?.parallelEscape,
@@ -13696,9 +13780,10 @@ async function createQwenStreamInternal(prompt, enableThinking, modelId, forcedP
       dynamicTimeout: dynamicIdleTimeoutMs
     });
     const firstChunkDeadlineMs = enableThinking ? Math.max(
+      config.timeouts.reasoningModelTimeout,
       config.timeouts.firstChunkTimeout,
       config.timeouts.timeToFirstByte
-    ) : void 0;
+    ) : Math.max(config.timeouts.firstChunkTimeout, config.timeouts.timeToFirstByte);
     return addIdleTimeoutToStream(
       stream,
       controller2,
@@ -21513,7 +21598,7 @@ async function processStreamingResponse(params) {
     let chatInProgressSameAccountRetries = 0;
     let antiBotSameAccountRetries = 0;
     const totalConfiguredAccounts = loadAccounts().length;
-    let quotaRotationsLeft = Math.min(Math.max(1, totalConfiguredAccounts - 1), 6);
+    let quotaRotationsLeft = Math.max(1, totalConfiguredAccounts - 1);
     let streamCompletedOk = false;
     let stoppedByToolCap = false;
     const runDisconnectTeardown = () => {
@@ -22938,7 +23023,7 @@ Please retry your tool call(s) with correct JSON and valid tool names from the a
       stack: err.stack?.split("\n").slice(0, 3).join(" | "),
       completionId
     };
-    if (retryable) {
+    if (retryable || isNetworkLikeError(err) || isAbortError(err)) {
       if (activeAccountId && isNetworkLikeError(err)) {
         noteMidStreamNetworkFailure(activeAccountId);
       }
@@ -22950,28 +23035,32 @@ Please retry your tool call(s) with correct JSON and valid tool names from the a
       logger.error("[Chat] Stream callback error", errorDetails);
     }
     try {
-      const userFriendlyNotice = `
+      const isNetwork = isNetworkLikeError(err);
+      const isModeration = normalizedErrorCode === "data_inspection_failed" || normalizedErrorCode === "fail_sys_user_validate" || err.message?.toLowerCase().includes("content moderation") || err.message?.toLowerCase().includes("security verification");
+      if (!isNetwork && isModeration) {
+        const userFriendlyNotice = `
 
-\u26A0\uFE0F **[Qwen Security / Erro]** ${err.message || "A resposta foi interrompida pelo Qwen."}
+\u26A0\uFE0F **[Qwen Modera\xE7\xE3o / Seguran\xE7a]** ${err.message || "A resposta foi interrompida pelas pol\xEDticas de seguran\xE7a do Qwen."}
 
 `;
-      const errorDelta = {
-        id: completionId,
-        object: "chat.completion.chunk",
-        created: Math.floor(Date.now() / 1e3),
-        model: body.model,
-        choices: [
-          {
-            index: 0,
-            delta: { content: userFriendlyNotice },
-            logprobs: null,
-            finish_reason: "stop"
-          }
-        ]
-      };
-      await errorStream.write(`data: ${JSON.stringify(errorDelta)}
+        const errorDelta = {
+          id: completionId,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1e3),
+          model: body.model,
+          choices: [
+            {
+              index: 0,
+              delta: { content: userFriendlyNotice },
+              logprobs: null,
+              finish_reason: "content_filter"
+            }
+          ]
+        };
+        await errorStream.write(`data: ${JSON.stringify(errorDelta)}
 
 `);
+      }
       await errorStream.write(
         `data: ${JSON.stringify({
           error: {
@@ -27004,7 +27093,7 @@ function getAppVersion() {
     }
   } catch {
   }
-  cachedVersion = "v1.6.5";
+  cachedVersion = "v1.6.7";
   return cachedVersion;
 }
 var cachedVersion;

package/dist/login.js

@@ -1108,7 +1108,10 @@ function isPlaywrightAlreadyClosedMessage(message) {
   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;
+  if (!error) return true;
+  if (typeof error === "object" && Object.keys(error).length === 0 && !(error instanceof Error)) {
+    return true;
+  }
   const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
   return isPlaywrightAlreadyClosedMessage(message);
 }
@@ -4420,6 +4423,15 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
     await existingInit;
     return;
   }
+  let resolveInit;
+  let rejectInit;
+  const inFlightDeferred = new Promise((res, rej) => {
+    resolveInit = res;
+    rejectInit = rej;
+  });
+  inFlightDeferred.catch(() => {
+  });
+  inFlightAccountInits.set(account.id, inFlightDeferred);
   const initPromise = (async () => {
     const release = await acquireAccountMutex(
       account.id,
@@ -4704,9 +4716,12 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
       release();
     }
   })();
-  inFlightAccountInits.set(account.id, initPromise);
   try {
     await initPromise;
+    resolveInit();
+  } catch (error) {
+    rejectInit(error);
+    throw error;
   } finally {
     inFlightAccountInits.delete(account.id);
   }

package/dist/reset-cooldowns.js

@@ -2825,7 +2825,10 @@ function isPlaywrightAlreadyClosedMessage(message) {
   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;
+  if (!error) return true;
+  if (typeof error === "object" && Object.keys(error).length === 0 && !(error instanceof Error)) {
+    return true;
+  }
   const message = error instanceof Error ? error.message : typeof error === "object" && "message" in error ? String(error.message) : String(error);
   return isPlaywrightAlreadyClosedMessage(message);
 }
@@ -3851,6 +3854,15 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
     await existingInit;
     return;
   }
+  let resolveInit;
+  let rejectInit;
+  const inFlightDeferred = new Promise((res, rej) => {
+    resolveInit = res;
+    rejectInit = rej;
+  });
+  inFlightDeferred.catch(() => {
+  });
+  inFlightAccountInits.set(account.id, inFlightDeferred);
   const initPromise = (async () => {
     const release = await acquireAccountMutex(
       account.id,
@@ -4135,9 +4147,12 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
       release();
     }
   })();
-  inFlightAccountInits.set(account.id, initPromise);
   try {
     await initPromise;
+    resolveInit();
+  } catch (error) {
+    rejectInit(error);
+    throw error;
   } finally {
     inFlightAccountInits.delete(account.id);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.6.5",
+  "version": "1.6.7",
   "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/core/model-alias.ts

@@ -76,6 +76,12 @@ export function stripThinkingSuffix(model: string): {
     };
   }
 
+  // Default for non-thinking models (omni-flash, turbo)
+  const lower = normalizedModel.toLowerCase();
+  if (lower.includes("omni-flash") || lower.includes("turbo")) {
+    return { baseModel: normalizedModel, enableThinking: false, reasoningMode: "fast" };
+  }
+
   // Default: auto thinking (Qwen decides)
   return { baseModel: normalizedModel, enableThinking: true, reasoningMode: "auto" };
 }

package/src/core/process-guard.ts

@@ -27,7 +27,14 @@ export function isPlaywrightAlreadyClosedMessage(message: string): boolean {
 }
 
 export function isBenignTeardownError(error: unknown): boolean {
-  if (!error) return false;
+  if (!error) return true;
+  if (
+    typeof error === "object" &&
+    Object.keys(error).length === 0 &&
+    !(error instanceof Error)
+  ) {
+    return true;
+  }
   const message =
     error instanceof Error
       ? error.message

package/src/core/version.ts

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

package/src/routes/chat/streaming.ts

@@ -937,7 +937,7 @@ export async function processStreamingResponse(
     let chatInProgressSameAccountRetries = 0;
     let antiBotSameAccountRetries = 0;
     const totalConfiguredAccounts = loadAccounts().length;
-    let quotaRotationsLeft = Math.min(Math.max(1, totalConfiguredAccounts - 1), 6);
+    let quotaRotationsLeft = Math.max(1, totalConfiguredAccounts - 1);
     // Set when the terminal [DONE] reached the client. The `| recovered`
     // suffix on Stream done must only appear for attempts that COMPLETED after
     // a mid-stream retry, not for failed attempts that consumed retries.
@@ -2819,7 +2819,7 @@ export async function processStreamingResponse(
       completionId,
     };
 
-    if (retryable) {
+    if (retryable || isNetworkLikeError(err) || isAbortError(err)) {
       if (activeAccountId && isNetworkLikeError(err)) {
         noteMidStreamNetworkFailure(activeAccountId);
       }
@@ -2831,28 +2831,41 @@ export async function processStreamingResponse(
       logger.error("[Chat] Stream callback error", errorDetails);
     }
     // The HTTP response is already committed at this point.
-    // 1. Emit an explicit assistant message delta so CLI/TUI clients that only
-    //    listen for choices[].delta.content (e.g. OpenCode, Claude Code, etc.)
-    //    render the error visibly in the chat instead of appearing blank/frozen.
-    // 2. Emit a terminal OpenAI-compatible SSE error event + [DONE].
+    // 1. Emit an explicit assistant message delta ONLY if this was an upstream content moderation /
+    //    policy violation (with finish_reason: "content_filter"), so the user understands why the
+    //    prompt was blocked.
+    // 2. For network/transient/quota errors, NEVER emit fake assistant content with finish_reason: "stop".
+    //    Doing so masks network failures as successful AI answers, preventing client agent retries and
+    //    poisoning chat history with error banners.
+    // 3. Emit a terminal OpenAI-compatible SSE error event + [DONE].
     try {
-      const userFriendlyNotice = `\n\n⚠️ **[Qwen Security / Erro]** ${err.message || "A resposta foi interrompida pelo Qwen."}\n\n`;
-      const errorDelta = {
-        id: completionId,
-        object: "chat.completion.chunk",
-        created: Math.floor(Date.now() / 1000),
-        model: body.model,
-        choices: [
-          {
-            index: 0,
-            delta: { content: userFriendlyNotice },
-            logprobs: null,
-            finish_reason: "stop",
-          },
-        ],
-      };
+      const isNetwork = isNetworkLikeError(err);
+      const isModeration =
+        normalizedErrorCode === "data_inspection_failed" ||
+        normalizedErrorCode === "fail_sys_user_validate" ||
+        err.message?.toLowerCase().includes("content moderation") ||
+        err.message?.toLowerCase().includes("security verification");
+
+      if (!isNetwork && isModeration) {
+        const userFriendlyNotice = `\n\n⚠️ **[Qwen Moderação / Segurança]** ${err.message || "A resposta foi interrompida pelas políticas de segurança do Qwen."}\n\n`;
+        const errorDelta = {
+          id: completionId,
+          object: "chat.completion.chunk",
+          created: Math.floor(Date.now() / 1000),
+          model: body.model,
+          choices: [
+            {
+              index: 0,
+              delta: { content: userFriendlyNotice },
+              logprobs: null,
+              finish_reason: "content_filter",
+            },
+          ],
+        };
+
+        await errorStream.write(`data: ${JSON.stringify(errorDelta)}\n\n`);
+      }
 
-      await errorStream.write(`data: ${JSON.stringify(errorDelta)}\n\n`);
       await errorStream.write(
         `data: ${JSON.stringify({
           error: {

package/src/services/captcha-coordinator.ts

@@ -125,6 +125,13 @@ export async function recoverBaxiaCaptcha(
     : null;
 
   activeCaptchaRecoveries.add(accountId);
+  try {
+    const { abortActiveBrowserStreamsForAccount } = await import("./qwen.ts");
+    abortActiveBrowserStreamsForAccount(
+      accountId,
+      "Account stream interrupted by captcha challenge recovery",
+    );
+  } catch {}
   try {
     // recoverOnTimeout: false ensures that if the captcha solve times out,
     // withAccountPage does NOT destructively kill the browser context, which

package/src/services/playwright.ts

@@ -1529,6 +1529,16 @@ export async function initPlaywrightForAccount(
     return;
   }
 
+  let resolveInit!: () => void;
+  let rejectInit!: (err: any) => void;
+  const inFlightDeferred = new Promise<void>((res, rej) => {
+    resolveInit = res;
+    rejectInit = rej;
+  });
+  // Prevent UnhandledRejection if rejectInit is called when no concurrent callers are awaiting
+  inFlightDeferred.catch(() => {});
+  inFlightAccountInits.set(account.id, inFlightDeferred);
+
   const initPromise = (async () => {
     const release = await acquireAccountMutex(
       account.id,
@@ -1536,10 +1546,10 @@ export async function initPlaywrightForAccount(
       Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, 120_000),
     );
     try {
-    // Double-check after acquiring lock
-    if (accountPages.has(account.id)) {
-      return;
-    }
+      // Double-check after acquiring lock
+      if (accountPages.has(account.id)) {
+        return;
+      }
 
     // If a context limit is configured, make room by closing idle contexts.
     await evictIdlePlaywrightContextsToLimit().catch(() => {});
@@ -1866,9 +1876,12 @@ export async function initPlaywrightForAccount(
     }
   })();
 
-  inFlightAccountInits.set(account.id, initPromise);
   try {
     await initPromise;
+    resolveInit();
+  } catch (error) {
+    rejectInit(error);
+    throw error;
   } finally {
     inFlightAccountInits.delete(account.id);
   }

package/src/services/qwen.ts

@@ -117,6 +117,7 @@ interface BrowserStreamMetadata {
 }
 
 interface BrowserStreamState {
+  accountId?: string;
   chunks: Uint8Array[];
   done: boolean;
   error: Error | null;
@@ -128,6 +129,36 @@ const browserStreamStates = new Map<string, BrowserStreamState>();
 const browserStreamBindingPages = new WeakSet<object>();
 const browserStreamBindingContexts = new WeakSet<object>();
 
+/**
+ * Abort all active browser streams for an account immediately.
+ * Called when an account page is navigated by captcha recovery, closed, or reset,
+ * so in-flight streams fail fast (retryable) instead of stalling for minutes.
+ */
+export function abortActiveBrowserStreamsForAccount(
+  accountId: string,
+  reason = "Account browser stream interrupted (page context unloaded)",
+): number {
+  let count = 0;
+  for (const [requestId, state] of browserStreamStates) {
+    if (state.accountId === accountId && !state.done) {
+      count++;
+      handleBrowserStreamEvent(requestId, {
+        type: "error",
+        message: reason,
+        errorName: "AbortError",
+      });
+    }
+  }
+  if (count > 0) {
+    logger.debug("[Qwen] Aborted active browser streams for account", {
+      accountId,
+      count,
+      reason,
+    });
+  }
+  return count;
+}
+
 export async function registerBrowserContextStreamBinding(
   context: BrowserContext,
 ): Promise<void> {
@@ -1263,6 +1294,7 @@ async function createQwenBrowserResponse(
 
   const requestId = uuidv4();
   const state: BrowserStreamState = {
+    accountId,
     chunks: [],
     done: false,
     error: null,
@@ -1283,10 +1315,14 @@ async function createQwenBrowserResponse(
   let settled = false;
   let abortListener: (() => void) | undefined;
   let cancelPromise: Promise<void> | undefined;
+  let pageCleanup: (() => void) | undefined;
   const cleanup = () => {
     if (settled) return;
     settled = true;
     if (abortListener) signal.removeEventListener("abort", abortListener);
+    try {
+      pageCleanup?.();
+    } catch {}
     browserStreamStates.delete(requestId);
   };
   const cancel = () => {
@@ -1327,6 +1363,34 @@ async function createQwenBrowserResponse(
       accountId,
       async (page) => {
         await ensureBrowserStreamBinding(page);
+        if (typeof (page as any).on === "function") {
+          const onFrameNavigated = (frame: any) => {
+            if (!settled && typeof (page as any).mainFrame === "function" && frame === (page as any).mainFrame()) {
+              handleBrowserStreamEvent(requestId, {
+                type: "error",
+                message: "Qwen browser page navigated during stream (session interrupted)",
+                errorName: "AbortError",
+              });
+            }
+          };
+          const onPageClosed = () => {
+            if (!settled) {
+              handleBrowserStreamEvent(requestId, {
+                type: "error",
+                message: "Qwen browser page closed during stream",
+                errorName: "AbortError",
+              });
+            }
+          };
+          (page as any).on("framenavigated", onFrameNavigated);
+          (page as any).on("close", onPageClosed);
+          pageCleanup = () => {
+            try {
+              (page as any).off?.("framenavigated", onFrameNavigated);
+              (page as any).off?.("close", onPageClosed);
+            } catch {}
+          };
+        }
         if (config.captcha.enabled) {
           captchaWatcher = startBaxiaCaptchaWatcher(
             page,
@@ -3011,13 +3075,9 @@ async function createQwenStreamInternal(
     }
 
     // Dynamic idle timeout based on model type and payload size
-    // Reasoning models (thinking enabled): use REASONING_MODEL_TIMEOUT as base
-    // Non-reasoning models: use IDLE_STREAM_TIMEOUT as base
-    // Both add 30s per MB of payload. Parallel-escape streams get a tight cap
-    // ONLY when non-thinking (see computeDynamicIdleTimeout).
-    const baseTimeoutMs = enableThinking
-      ? config.timeouts.reasoningModelTimeout
-      : config.timeouts.idleStreamTimeout;
+    // Base timeout for gaps between chunks is governed by IDLE_STREAM_TIMEOUT (default 60s)
+    // plus dynamic payload scaling (30s per MB).
+    const baseTimeoutMs = config.timeouts.idleStreamTimeout;
     const dynamicIdleTimeoutMs = computeDynamicIdleTimeout({
       enableThinking,
       parallelEscape: options?.parallelEscape,
@@ -3034,15 +3094,15 @@ async function createQwenStreamInternal(
       dynamicTimeout: dynamicIdleTimeoutMs,
     });
 
-    // Thinking models idle at 600s — fine for gaps AFTER data flows, but a
-    // stream that produced NOTHING in the first-chunk window is dead. Fail
-    // fast (retryable) so the account slot is not held for 10 minutes.
+    // Thinking models legitimately pause before first chunk (up to reasoningModelTimeout).
+    // After the first chunk, the normal dynamicIdleTimeoutMs (60s+) governs chunk gaps.
     const firstChunkDeadlineMs = enableThinking
       ? Math.max(
+          config.timeouts.reasoningModelTimeout,
           config.timeouts.firstChunkTimeout,
           config.timeouts.timeToFirstByte,
         )
-      : undefined;
+      : Math.max(config.timeouts.firstChunkTimeout, config.timeouts.timeToFirstByte);
 
     return addIdleTimeoutToStream(
       stream,