qwenproxy-cli 1.6.10 → 1.6.12

package/dist/sync-clients.js

@@ -119,7 +119,7 @@ var envSchema = z.object({
   // Version header on Qwen API requests = the deployed web bundle version
   // (fallback when dynamic DOM detection is not yet completed).
   // Override via env when Qwen ships a new bundle.
-  QWEN_WEB_VERSION: z.string().default("0.3.26"),
+  QWEN_WEB_VERSION: z.string().default("0.3.43"),
   // Controls bx-ua/bx-umidtoken injection on the GENERAL API paths
   // (chats/new, settings): those work without them (live-probed). The
   // completions path is the exception — the 0.2.86 HAR shows the real
@@ -162,6 +162,7 @@ var envSchema = z.object({
   CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
   CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
   CAPTCHA_SOLVER_TIMEOUT_MS: z.string().default("15000"),
+  CAPTCHA_SLIDER_TIMEOUT_MS: z.string().default("8000"),
   CAPTCHA_SOLVER_RETRY_DELAY_MS: z.string().default("1000"),
   CAPTCHA_SOLVER_SETTLE_MS: z.string().default("2000"),
   CAPTCHA_ACCOUNT_COOLDOWN_MS: z.string().default("120000"),
@@ -313,6 +314,8 @@ var config = {
     enabled: env.CAPTCHA_SOLVER_ENABLED === "true",
     maxAttempts: Math.max(1, Math.min(5, parseInt(env.CAPTCHA_SOLVER_MAX_ATTEMPTS))),
     timeoutMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_TIMEOUT_MS)),
+    /** Max wait for a challenge slider to become visible (slow WAF renders). */
+    sliderTimeoutMs: Math.max(500, parseInt(env.CAPTCHA_SLIDER_TIMEOUT_MS)),
     retryDelayMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_RETRY_DELAY_MS)),
     settleMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_SETTLE_MS)),
     /** Rest an account whose challenge could not be cleared before reusing it. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.6.10",
+  "version": "1.6.12",
   "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": {
@@ -58,7 +58,7 @@
   "bugs": {
     "url": "https://github.com/johngbl/qwenproxy/issues"
   },
-  "author": "johngbl <147551701+johngbl@users.noreply.github.com>",
+  "author": "johngbl",
   "license": "ISC",
   "dependencies": {
     "@hono/node-server": "^2.1.1",

package/src/api/server.ts

@@ -883,10 +883,14 @@ export async function startServer(options?: {
         void (async () => {
           const { ensureAccountInPriority } = await import("../core/account-priority.ts");
 
-          const targetWarmTotal = Math.min(
-            config.playwright.startupWarmAccounts,
-            totalAccounts,
-          );
+          const maxWarmCap =
+            config.playwright.maxActiveContexts > 0
+              ? Math.min(
+                  config.playwright.startupWarmAccounts,
+                  config.playwright.maxActiveContexts,
+                )
+              : config.playwright.startupWarmAccounts;
+          const targetWarmTotal = Math.min(maxWarmCap, totalAccounts);
           let currentReadyCount = readyAccountIds.size;
 
           if (currentReadyCount < targetWarmTotal && remainingAccounts.length > 0) {

package/src/core/config.ts

@@ -34,7 +34,7 @@ const envSchema = z
     // Version header on Qwen API requests = the deployed web bundle version
     // (fallback when dynamic DOM detection is not yet completed).
     // Override via env when Qwen ships a new bundle.
-    QWEN_WEB_VERSION: z.string().default("0.3.26"),
+    QWEN_WEB_VERSION: z.string().default("0.3.43"),
     // Controls bx-ua/bx-umidtoken injection on the GENERAL API paths
     // (chats/new, settings): those work without them (live-probed). The
     // completions path is the exception — the 0.2.86 HAR shows the real
@@ -81,6 +81,7 @@ const envSchema = z
     CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
     CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
     CAPTCHA_SOLVER_TIMEOUT_MS: z.string().default("15000"),
+    CAPTCHA_SLIDER_TIMEOUT_MS: z.string().default("8000"),
     CAPTCHA_SOLVER_RETRY_DELAY_MS: z.string().default("1000"),
     CAPTCHA_SOLVER_SETTLE_MS: z.string().default("2000"),
     CAPTCHA_ACCOUNT_COOLDOWN_MS: z.string().default("120000"),
@@ -243,6 +244,8 @@ export const config = {
     enabled: env.CAPTCHA_SOLVER_ENABLED === "true",
     maxAttempts: Math.max(1, Math.min(5, parseInt(env.CAPTCHA_SOLVER_MAX_ATTEMPTS))),
     timeoutMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_TIMEOUT_MS)),
+    /** Max wait for a challenge slider to become visible (slow WAF renders). */
+    sliderTimeoutMs: Math.max(500, parseInt(env.CAPTCHA_SLIDER_TIMEOUT_MS)),
     retryDelayMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_RETRY_DELAY_MS)),
     settleMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_SETTLE_MS)),
     /** Rest an account whose challenge could not be cleared before reusing it. */

package/src/core/model-alias.ts

@@ -9,6 +9,7 @@ export type ReasoningMode = "auto" | "thinking" | "fast";
 export const DEFAULT_FALLBACK_MODELS = [
   "qwen3.8-max",
   "qwen3.7-plus",
+  "qwen4.0-max-preview",
   "qwen3.8-omni-flash",
   "qwen3.7-max",
   "qwen3.6-plus",

package/src/core/version.ts

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

package/src/core/watchdog.ts

@@ -148,14 +148,15 @@ export class Watchdog extends EventEmitter {
     // (idle mutex, no active stream, preserves the max-active-context minimum)
     // so the next health check sees the freed RSS.
     try {
-      const { closeIdlePlaywrightAccounts } = await import(
+      const { closeIdlePlaywrightAccounts, evictIdlePlaywrightContextsToLimit } = await import(
         "../services/playwright.js"
       );
+      const evicted = await evictIdlePlaywrightContextsToLimit(1);
       const closed = await closeIdlePlaywrightAccounts(
         config.sessionKeeper.idleMs,
       );
-      if (closed > 0) {
-        this.emit("recovery:ram:contexts-closed", closed);
+      if (evicted + closed > 0) {
+        this.emit("recovery:ram:contexts-closed", evicted + closed);
       }
     } catch {
       // Playwright may not be initialized (mock mode / pre-start); RSS relief

package/src/routes/chat/account.ts

@@ -8,6 +8,7 @@ import {
 } from "../../core/account-manager.ts";
 import { markAccountSuccessful, markAccountFailed, getAccountsByPriority } from "../../core/account-priority.ts";
 import { recordWafHardBlock, noteWafRecovery } from "../../core/waf-isolation.ts";
+import { isCaptchaRecoveryInBackoff } from "../../services/captcha-coordinator.ts";
 import { loadAccounts, type QwenAccount } from "../../core/accounts.ts";
 import { config, type ChatMode } from "../../core/config.ts";
 import { ClientAbortedError, UpstreamRateLimit, ValidationError } from "../../core/errors.ts";
@@ -1615,6 +1616,17 @@ async function tryCreateStreamWithRetry(
 			invalidateLogicalThreadParent(params.sessionId);
 		}
 
+		// If captcha recovery on this account already failed and is in its 30s
+		// backoff window, same-account retries will only hit `recovery_skipped`
+		// and waste time/RAM re-sending large payloads. Exit immediately so the
+		// outer loop quarantines this account and switches to a fresh one.
+		if (
+			policy.reason === "anti_bot" &&
+			isCaptchaRecoveryInBackoff(currentAccountId)
+		) {
+			return { success: false, error: err };
+		}
+
 		// A generic invalid_input is often a stale/corrupted upstream chat rather
 		// than an account failure. Rebuild it once on the same account first. If the
 		// fresh chat fails again, the normal policy is allowed to rotate.

package/src/routes/chat/streaming.ts

@@ -1259,8 +1259,8 @@ export async function processStreamingResponse(
       };
 
       const emitAnswerText = async (textChunk: string) => {
-        if (textChunk) emittedModelOutput = true;
         if (!toolParser) {
+          if (textChunk) emittedModelOutput = true;
           finalContent += textChunk;
           writeDeltaEvent({ content: textChunk });
           return;
@@ -1777,6 +1777,23 @@ export async function processStreamingResponse(
               .replace(/\\\\/g, "\\");
 
             if (unescaped) {
+              if (!emittedModelOutput && isOverloadMessage(unescaped)) {
+                const overloadErr = toRetryableStreamError(
+                  "server_overloaded",
+                  unescaped,
+                  {
+                    switchAccount: true,
+                    forceNewChat: true,
+                    reason: "server_busy",
+                    accountCooldownMs: OVERLOAD_COOLDOWN_MS,
+                    accountCooldownReason: "ServerOverloaded",
+                  },
+                );
+                if (await recoverFromStreamError(overloadErr)) {
+                  break;
+                }
+                throw overloadErr;
+              }
               const result = getIncrementalDelta(
                 lastRawContent,
                 unescaped,
@@ -1942,7 +1959,6 @@ export async function processStreamingResponse(
               if (vStr === "FINISHED") continue;
 
               if (isThinkingChunk) {
-                emittedModelOutput = true;
                 reasoningBuffer += vStr;
                 writeDeltaEvent({ reasoning_content: vStr });
               } else {

package/src/services/auth-playwright.ts

@@ -1,6 +1,7 @@
 import { AuthError } from "../core/errors.ts";
 import { getAccountCredentials, loadAccounts } from "../core/accounts.ts";
 import { config } from "../core/config.ts";
+import { getQwenBxVersion, getQwenWebVersion } from "./qwen-headers.ts";
 import {
   getBasicHeaders as getPlaywrightBasicHeaders,
   initPlaywrightForAccount,
@@ -78,13 +79,13 @@ export async function getBasicHeaders(accountId?: string): Promise<{
     return {
       cookie: "token=mock",
       userAgent: "mock",
-      bxV: "2.5.37",
+      bxV: getQwenBxVersion(),
       bxUa: "mock-bx-ua",
       bxUmidtoken: "mock-bx-umidtoken",
       secChUa: "",
       secChUaMobile: "?0",
       secChUaPlatform: "",
-      version: "0.3.26",
+      version: getQwenWebVersion(),
     };
   }
 

package/src/services/captcha-coordinator.ts

@@ -7,7 +7,7 @@ import {
   extractBaxiaChallengeUrl,
   logBaxiaCaptcha,
   sanitizeCaptchaErrorDetail,
-  solveBaxiaCaptcha,
+  solveVisibleCaptcha,
 } from "./captcha-solver.ts";
 
 const CHALLENGE_NAVIGATION_TIMEOUT_MS = 8_000;
@@ -55,12 +55,13 @@ export async function solveChallengeOnPage(
     maxAttempts: config.captcha.maxAttempts,
     retryDelayMs: config.captcha.retryDelayMs,
     settleMs: config.captcha.settleMs,
+    sliderTimeoutMs: config.captcha.sliderTimeoutMs,
   };
 
   // Qwen's own Baxia SDK sometimes renders the dialog for the background
   // fetch. When it did, solve it in place: navigating away would discard the
   // challenge the SDK is waiting on.
-  if (await solveBaxiaCaptcha(page, { ...solverOptions, waitForMs: 0 })) {
+  if (await solveVisibleCaptcha(page, { ...solverOptions, waitForMs: 0 })) {
     return true;
   }
 
@@ -72,7 +73,7 @@ export async function solveChallengeOnPage(
   await gotoBestEffort(page, challengeUrl ?? qwenUrl("/"));
 
   try {
-    return await solveBaxiaCaptcha(page, { ...solverOptions, waitForMs });
+    return await solveVisibleCaptcha(page, { ...solverOptions, waitForMs });
   } finally {
     // Never leave the account page parked on the punish document: a stale
     // challenge page makes the next detection pass find itself.
@@ -92,6 +93,12 @@ export async function solveChallengeOnPage(
  * a punish document that is never rendered; opening that document in the page
  * is what gives the solver a slider to drive.
  */
+export function isCaptchaRecoveryInBackoff(accountId: string | undefined): boolean {
+  if (!accountId) return false;
+  const lastFailure = lastFailedRecoveryAt.get(accountId) ?? 0;
+  return Date.now() - lastFailure < FAILED_RECOVERY_BACKOFF_MS;
+}
+
 export async function recoverBaxiaCaptcha(
   accountId: string | undefined,
   label: string,
@@ -126,19 +133,42 @@ export async function recoverBaxiaCaptcha(
 
   activeCaptchaRecoveries.add(accountId);
   try {
-    const { abortActiveBrowserStreamsForAccount } = await import("./qwen.ts");
-    abortActiveBrowserStreamsForAccount(
-      accountId,
-      "Account stream interrupted by captcha challenge recovery",
-    );
-  } catch {}
-  try {
+    const { hasActiveBrowserStreamsForAccount } = await import("./qwen.ts");
+    const hasConcurrentStream = hasActiveBrowserStreamsForAccount(accountId);
+
     // recoverOnTimeout: false ensures that if the captcha solve times out,
     // withAccountPage does NOT destructively kill the browser context, which
     // previously caused "Target page, context or browser has been closed" mid-slider.
     const solved = await withAccountPage(
       accountId,
-      (page) => solveChallengeOnPage(page, challengeUrl),
+      async (page) => {
+        // If another stream is actively running on this account's primary page,
+        // NEVER navigate `page` away (which would unload its DOM and kill the stream).
+        // Instead, try in-place modal solve first, or open an ephemeral tab in the
+        // same BrowserContext so cookies/x5sec are solved without touching `page`.
+        if (hasConcurrentStream) {
+          const solverOptions = {
+            maxAttempts: config.captcha.maxAttempts,
+            retryDelayMs: config.captcha.retryDelayMs,
+            settleMs: config.captcha.settleMs,
+            sliderTimeoutMs: config.captcha.sliderTimeoutMs,
+          };
+          if (await solveVisibleCaptcha(page, { ...solverOptions, waitForMs: 0 })) {
+            return true;
+          }
+          const ctx = typeof page.context === "function" ? page.context() : null;
+          if (ctx && typeof ctx.newPage === "function") {
+            const tempPage = await ctx.newPage();
+            try {
+              return await solveChallengeOnPage(tempPage, challengeUrl);
+            } finally {
+              await tempPage.close({ runBeforeUnload: false }).catch(() => {});
+            }
+          }
+          return false;
+        }
+        return await solveChallengeOnPage(page, challengeUrl);
+      },
       solverOperationTimeoutMs,
       solverOperationTimeoutMs,
       false,