qwenproxy-cli 1.5.1 → 1.5.3

package/dist/clean-cache.js

@@ -965,6 +965,7 @@ var init_config = __esm({
       // own context while serving. Accounts in cooldown (rate-limited) sit idle,
       // drop out of the warm set and get evicted.
       PLAYWRIGHT_MAX_ACTIVE_CONTEXTS: z.string().default("2"),
+      PLAYWRIGHT_STARTUP_WARM_ACCOUNTS: z.string().default("4"),
       PLAYWRIGHT_PREPARE_ALL_ON_STARTUP: z.string().default("false"),
       CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
       CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
@@ -1113,6 +1114,7 @@ var init_config = __esm({
         jsHeapMb: Math.max(64, parseInt(env.PLAYWRIGHT_JS_HEAP_MB)),
         lowMemoryFlags: env.PLAYWRIGHT_LOW_MEMORY_FLAGS !== "false",
         maxActiveContexts: Math.max(0, parseInt(env.PLAYWRIGHT_MAX_ACTIVE_CONTEXTS)),
+        startupWarmAccounts: Math.max(1, parseInt(env.PLAYWRIGHT_STARTUP_WARM_ACCOUNTS)),
         prepareAllOnStartup: env.PLAYWRIGHT_PREPARE_ALL_ON_STARTUP !== "false"
       },
       captcha: {

package/dist/delete-chats.js

@@ -1020,6 +1020,7 @@ var init_config = __esm({
       // own context while serving. Accounts in cooldown (rate-limited) sit idle,
       // drop out of the warm set and get evicted.
       PLAYWRIGHT_MAX_ACTIVE_CONTEXTS: z.string().default("2"),
+      PLAYWRIGHT_STARTUP_WARM_ACCOUNTS: z.string().default("4"),
       PLAYWRIGHT_PREPARE_ALL_ON_STARTUP: z.string().default("false"),
       CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
       CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
@@ -1168,6 +1169,7 @@ var init_config = __esm({
         jsHeapMb: Math.max(64, parseInt(env.PLAYWRIGHT_JS_HEAP_MB)),
         lowMemoryFlags: env.PLAYWRIGHT_LOW_MEMORY_FLAGS !== "false",
         maxActiveContexts: Math.max(0, parseInt(env.PLAYWRIGHT_MAX_ACTIVE_CONTEXTS)),
+        startupWarmAccounts: Math.max(1, parseInt(env.PLAYWRIGHT_STARTUP_WARM_ACCOUNTS)),
         prepareAllOnStartup: env.PLAYWRIGHT_PREPARE_ALL_ON_STARTUP !== "false"
       },
       captcha: {
@@ -1901,6 +1903,14 @@ var init_mutex = __esm({
 });
 
 // src/core/account-priority.ts
+var account_priority_exports = {};
+__export(account_priority_exports, {
+  ensureAccountInPriority: () => ensureAccountInPriority,
+  getAccountsByPriority: () => getAccountsByPriority,
+  invalidatePriorityCache: () => invalidatePriorityCache,
+  markAccountFailed: () => markAccountFailed,
+  markAccountSuccessful: () => markAccountSuccessful
+});
 import {
   existsSync,
   mkdirSync,
@@ -1910,6 +1920,9 @@ import {
 function isPersistableAccount(accountId) {
   return accountId !== MOCK_ACCOUNT_ID;
 }
+function invalidatePriorityCache() {
+  priorityCache = null;
+}
 function loadPriority() {
   if (priorityCache) return priorityCache;
   try {
@@ -1930,6 +1943,41 @@ function loadPriority() {
   priorityCache = { accountOrder: [], lastUpdated: 0 };
   return priorityCache;
 }
+function savePriority(data) {
+  try {
+    mkdirSync(DATA_DIR3, { recursive: true });
+    writeFileSync(PRIORITY_FILE, JSON.stringify(data, null, 2), "utf-8");
+    priorityCache = data;
+  } catch (err) {
+    console.error("\u274C [AccountPriority] Failed to save priority file:", err.message);
+  }
+}
+function markAccountSuccessful(accountId) {
+  if (!isPersistableAccount(accountId)) return;
+  const data = loadPriority();
+  data.accountOrder = data.accountOrder.filter((id) => id !== accountId);
+  data.accountOrder.unshift(accountId);
+  data.lastUpdated = Date.now();
+  savePriority(data);
+}
+function markAccountFailed(accountId) {
+  if (!isPersistableAccount(accountId)) return;
+  const data = loadPriority();
+  data.accountOrder = data.accountOrder.filter((id) => id !== accountId);
+  data.accountOrder.push(accountId);
+  data.lastUpdated = Date.now();
+  savePriority(data);
+}
+function ensureAccountInPriority(accountId) {
+  if (!isPersistableAccount(accountId)) return;
+  const data = loadPriority();
+  if (data.accountOrder.includes(accountId)) {
+    return;
+  }
+  data.accountOrder.push(accountId);
+  data.lastUpdated = Date.now();
+  savePriority(data);
+}
 function getAccountsByPriority(accounts) {
   const data = loadPriority();
   if (data.accountOrder.length === 0) {
@@ -6583,6 +6631,11 @@ async function ensurePlaywrightInitialized(accountId) {
     });
   } catch {
   }
+  try {
+    const { ensureAccountInPriority: ensureAccountInPriority2 } = await Promise.resolve().then(() => (init_account_priority(), account_priority_exports));
+    ensureAccountInPriority2(accountId);
+  } catch {
+  }
 }
 async function getBasicHeaders2(accountId) {
   if (isAuthMockEnabled()) {
@@ -9514,9 +9567,13 @@ function parseQwenJsonError(raw, status, accountId) {
   }
   if (errorJson?.success === false) {
     const code = errorJson.data?.code || errorJson.code || "UpstreamError";
-    if (status === 401 || code === "Unauthorized" || typeof details === "string" && (details.includes("login") || details.includes("session"))) {
+    const detailsStr = typeof details === "string" ? details : "";
+    const codeStr = String(code).toLowerCase();
+    const detailsLower = detailsStr.toLowerCase();
+    const isAuthExpired = status === 401 || codeStr.includes("unauthorized") || detailsLower.includes("token has expired") || detailsLower.includes("log in") || detailsLower.includes("login") || detailsLower.includes("session") || detailsLower.includes("n\xE3o autorizado") || detailsLower.includes("unauthorized");
+    if (isAuthExpired) {
       return new QwenSessionExpiredError(
-        `Session expired: ${details}`,
+        `Session expired: ${detailsStr || codeStr}`,
         accountId || "global"
       );
     }
@@ -10055,8 +10112,24 @@ async function createQwenStreamInternal(prompt, enableThinking, modelId, forcedP
             )
           );
         }
+        const parsedJsonErr = parseQwenJsonError(errText, response.status, accountId);
+        if (parsedJsonErr instanceof QwenSessionExpiredError && accountId && !retriedNonSseResponse) {
+          retriedNonSseResponse = true;
+          logger.warn(
+            "[Qwen] Token expired on completion fetch (200 JSON); refreshing session and retrying",
+            { accountId, chatId: chatSessionId ?? "new" }
+          );
+          const { refreshAccountToken: refreshAccountToken2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
+          const refreshed = await refreshAccountToken2(accountId);
+          if (refreshed.success) {
+            const fresh = await getQwenHeaders(false, accountId);
+            activeHeaders = fresh.headers;
+            response = await fetchCompletion(activeHeaders);
+            continue;
+          }
+        }
         throw withCreatedChatMetadata(
-          parseQwenJsonError(errText, response.status, accountId) ?? new QwenUpstreamError(
+          parsedJsonErr ?? new QwenUpstreamError(
             `Qwen returned non-stream JSON response: ${errText.substring(0, 300)}`,
             "NonStreamJsonResponse",
             502
@@ -10107,6 +10180,31 @@ async function createQwenStreamInternal(prompt, enableThinking, modelId, forcedP
             response.status,
             accountId
           );
+          if (parsedError instanceof QwenSessionExpiredError && accountId && !retriedNonSseResponse) {
+            retriedNonSseResponse = true;
+            logger.warn(
+              "[Qwen] Token expired on completion fetch (!response.ok); refreshing session and retrying",
+              { accountId, chatId: chatSessionId ?? "new", status: response.status }
+            );
+            const { refreshAccountToken: refreshAccountToken2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
+            const refreshed = await refreshAccountToken2(accountId);
+            if (refreshed.success) {
+              const fresh = await getQwenHeaders(false, accountId);
+              activeHeaders = fresh.headers;
+              response = await fetchCompletion(activeHeaders);
+              if (response.ok && response.body) {
+                return {
+                  stream: wrapUpstreamStream(response.body, controller),
+                  headers: activeHeaders,
+                  uiSessionId: chatSessionId || "",
+                  controller,
+                  accountId: accountId ?? "global",
+                  createdNewChat,
+                  tokenEstimationContext
+                };
+              }
+            }
+          }
           if (parsedError) {
             throw withCreatedChatMetadata(parsedError);
           }

package/dist/index.js

@@ -263,6 +263,7 @@ var init_config = __esm({
       // own context while serving. Accounts in cooldown (rate-limited) sit idle,
       // drop out of the warm set and get evicted.
       PLAYWRIGHT_MAX_ACTIVE_CONTEXTS: z.string().default("2"),
+      PLAYWRIGHT_STARTUP_WARM_ACCOUNTS: z.string().default("4"),
       PLAYWRIGHT_PREPARE_ALL_ON_STARTUP: z.string().default("false"),
       CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
       CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
@@ -411,6 +412,7 @@ var init_config = __esm({
         jsHeapMb: Math.max(64, parseInt(env.PLAYWRIGHT_JS_HEAP_MB)),
         lowMemoryFlags: env.PLAYWRIGHT_LOW_MEMORY_FLAGS !== "false",
         maxActiveContexts: Math.max(0, parseInt(env.PLAYWRIGHT_MAX_ACTIVE_CONTEXTS)),
+        startupWarmAccounts: Math.max(1, parseInt(env.PLAYWRIGHT_STARTUP_WARM_ACCOUNTS)),
         prepareAllOnStartup: env.PLAYWRIGHT_PREPARE_ALL_ON_STARTUP !== "false"
       },
       captcha: {
@@ -8022,6 +8024,11 @@ async function ensurePlaywrightInitialized(accountId) {
     });
   } catch {
   }
+  try {
+    const { ensureAccountInPriority: ensureAccountInPriority2 } = await Promise.resolve().then(() => (init_account_priority(), account_priority_exports));
+    ensureAccountInPriority2(accountId);
+  } catch {
+  }
 }
 async function getBasicHeaders2(accountId) {
   if (isAuthMockEnabled()) {
@@ -12729,9 +12736,13 @@ function parseQwenJsonError(raw, status, accountId) {
   }
   if (errorJson?.success === false) {
     const code = errorJson.data?.code || errorJson.code || "UpstreamError";
-    if (status === 401 || code === "Unauthorized" || typeof details === "string" && (details.includes("login") || details.includes("session"))) {
+    const detailsStr = typeof details === "string" ? details : "";
+    const codeStr = String(code).toLowerCase();
+    const detailsLower = detailsStr.toLowerCase();
+    const isAuthExpired = status === 401 || codeStr.includes("unauthorized") || detailsLower.includes("token has expired") || detailsLower.includes("log in") || detailsLower.includes("login") || detailsLower.includes("session") || detailsLower.includes("n\xE3o autorizado") || detailsLower.includes("unauthorized");
+    if (isAuthExpired) {
       return new QwenSessionExpiredError(
-        `Session expired: ${details}`,
+        `Session expired: ${detailsStr || codeStr}`,
         accountId || "global"
       );
     }
@@ -13270,8 +13281,24 @@ async function createQwenStreamInternal(prompt, enableThinking, modelId, forcedP
             )
           );
         }
+        const parsedJsonErr = parseQwenJsonError(errText, response.status, accountId);
+        if (parsedJsonErr instanceof QwenSessionExpiredError && accountId && !retriedNonSseResponse) {
+          retriedNonSseResponse = true;
+          logger.warn(
+            "[Qwen] Token expired on completion fetch (200 JSON); refreshing session and retrying",
+            { accountId, chatId: chatSessionId ?? "new" }
+          );
+          const { refreshAccountToken: refreshAccountToken2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
+          const refreshed = await refreshAccountToken2(accountId);
+          if (refreshed.success) {
+            const fresh = await getQwenHeaders(false, accountId);
+            activeHeaders = fresh.headers;
+            response = await fetchCompletion(activeHeaders);
+            continue;
+          }
+        }
         throw withCreatedChatMetadata(
-          parseQwenJsonError(errText, response.status, accountId) ?? new QwenUpstreamError(
+          parsedJsonErr ?? new QwenUpstreamError(
             `Qwen returned non-stream JSON response: ${errText.substring(0, 300)}`,
             "NonStreamJsonResponse",
             502
@@ -13322,6 +13349,31 @@ async function createQwenStreamInternal(prompt, enableThinking, modelId, forcedP
             response.status,
             accountId
           );
+          if (parsedError instanceof QwenSessionExpiredError && accountId && !retriedNonSseResponse) {
+            retriedNonSseResponse = true;
+            logger.warn(
+              "[Qwen] Token expired on completion fetch (!response.ok); refreshing session and retrying",
+              { accountId, chatId: chatSessionId ?? "new", status: response.status }
+            );
+            const { refreshAccountToken: refreshAccountToken2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
+            const refreshed = await refreshAccountToken2(accountId);
+            if (refreshed.success) {
+              const fresh = await getQwenHeaders(false, accountId);
+              activeHeaders = fresh.headers;
+              response = await fetchCompletion(activeHeaders);
+              if (response.ok && response.body) {
+                return {
+                  stream: wrapUpstreamStream(response.body, controller),
+                  headers: activeHeaders,
+                  uiSessionId: chatSessionId || "",
+                  controller,
+                  accountId: accountId ?? "global",
+                  createdNewChat,
+                  tokenEstimationContext
+                };
+              }
+            }
+          }
           if (parsedError) {
             throw withCreatedChatMetadata(parsedError);
           }
@@ -17099,16 +17151,16 @@ ${loopReminder}` : truncation.prompt;
         error: new Error("Failed to create Qwen stream")
       };
     }
-    if (err instanceof QwenSessionExpiredError || err.name === "QwenSessionExpiredError") {
+    const isSessionExpired = err instanceof QwenSessionExpiredError || err?.name === "QwenSessionExpiredError" || err instanceof Error && (err.message.toLowerCase().includes("token has expired") || err.message.toLowerCase().includes("session expired") || err.message.toLowerCase().includes("401 n\xE3o autorizado") || err.message.toLowerCase().includes("unauthorized"));
+    if (isSessionExpired) {
       console.warn(
-        `\u{1F504} [Chat] Session expired for ${currentAccountEmail} (${currentAccountId}). Attempting re-login...`
+        `\u{1F504} [Chat] Session expired for ${currentAccountEmail} (${currentAccountId}). Attempting silent token refresh/re-login...`
       );
       const reLoginOk = await attemptRelogin(
         currentAccountId,
         currentAccountEmail
       );
       if (reLoginOk) continue;
-      return { success: false, error: err };
     }
     if (isAccountUnavailableError(err)) {
       const quotaMsg = err.message || "Unknown quota error";
@@ -25884,7 +25936,7 @@ function getAppVersion() {
     }
   } catch {
   }
-  cachedVersion = "v1.5.1";
+  cachedVersion = "v1.5.3";
   return cachedVersion;
 }
 var cachedVersion;
@@ -26288,17 +26340,16 @@ async function startServer(options) {
           );
         });
       } else if (remainingAccounts.length > 0) {
-        console.log(
-          `\u{1FAB6} [Server] ${remainingAccounts.length} standby account(s) will initialize on demand`
-        );
         void (async () => {
-          const { validateAccountLogin: validateAccountLogin2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));
           const { ensureAccountInPriority: ensureAccountInPriority2 } = await Promise.resolve().then(() => (init_account_priority(), account_priority_exports));
-          let accountsToValidate = remainingAccounts;
-          if (config.playwright.maxActiveContexts > 1 && remainingAccounts.length > 0) {
-            let reserveCandidateIdx = 0;
-            for (; reserveCandidateIdx < remainingAccounts.length; reserveCandidateIdx++) {
-              const reserveAccount = remainingAccounts[reserveCandidateIdx];
+          const targetWarmTotal = Math.min(
+            config.playwright.startupWarmAccounts,
+            totalAccounts
+          );
+          let currentReadyCount = readyAccountIds.size;
+          if (currentReadyCount < targetWarmTotal && remainingAccounts.length > 0) {
+            for (const reserveAccount of remainingAccounts) {
+              if (currentReadyCount >= targetWarmTotal) break;
               try {
                 const ok = await prepareAccountRuntime(
                   reserveAccount,
@@ -26308,12 +26359,12 @@ async function startServer(options) {
                   warmQwenChatPool2
                 );
                 if (ok) {
+                  readyAccountIds.add(reserveAccount.id);
                   ensureAccountInPriority2(reserveAccount.id);
+                  currentReadyCount++;
                   console.log(
-                    `\u2705 [Server] Reserve account ready (2/${totalAccounts}): ${maskEmail(reserveAccount.email)}`
+                    `\u2705 [Server] Reserve account ready (${currentReadyCount}/${totalAccounts}): ${maskEmail(reserveAccount.email)}`
                   );
-                  reserveCandidateIdx++;
-                  break;
                 }
               } catch (err) {
                 console.warn(
@@ -26321,51 +26372,16 @@ async function startServer(options) {
                 );
               }
             }
-            accountsToValidate = remainingAccounts.slice(reserveCandidateIdx);
-          }
-          let validated = 0;
-          let failed = 0;
-          for (const account of accountsToValidate) {
-            try {
-              const creds = getAccountCredentials2(account.id) ?? account;
-              const ok = await validateAccountLogin2(
-                creds,
-                config.playwright.headless,
-                config.playwright.browser
-              );
-              if (ok) {
-                ensureAccountInPriority2(account.id);
-                validated++;
-                console.log(
-                  `\u2705 [Server] Standby account validated: ${maskEmail(account.email)}`
-                );
-              } else {
-                failed++;
-                console.warn(
-                  `\u26A0\uFE0F  [Server] Standby account login failed: ${maskEmail(account.email)} (quarantined)`
-                );
-              }
-            } catch (error) {
-              failed++;
-              console.warn(
-                `\u26A0\uFE0F  [Server] Standby account validation error: ${maskEmail(account.email)}: ${getErrorMessage2(error)} (quarantined)`
-              );
-              const { markAccountRateLimited: markAccountRateLimited2 } = await Promise.resolve().then(() => (init_account_manager(), account_manager_exports));
-              markAccountRateLimited2(
-                account.id,
-                24 * 3600 * 1e3,
-                `StandbyValidationError: ${getErrorMessage2(error)}`
-              );
-            }
           }
-          if (validated > 0 || failed > 0) {
+          const standbyCount = totalAccounts - currentReadyCount;
+          if (standbyCount > 0) {
             console.log(
-              `\u2705 [Server] Standby validation complete: ${validated} account(s) ready${failed > 0 ? `, ${failed} failed` : ""}`
+              `\u{1FAB6} [Server] ${standbyCount} standby account(s) ready in pool (will initialize on demand when active accounts rotate)`
             );
           }
         })().catch((error) => {
           console.warn(
-            `\u274C [Server] Background standby validation failed: ${getErrorMessage2(error)}`
+            `\u274C [Server] Background account preparation failed: ${getErrorMessage2(error)}`
           );
         });
       }

package/dist/login.js

@@ -1200,6 +1200,7 @@ var init_config = __esm({
       // own context while serving. Accounts in cooldown (rate-limited) sit idle,
       // drop out of the warm set and get evicted.
       PLAYWRIGHT_MAX_ACTIVE_CONTEXTS: z.string().default("2"),
+      PLAYWRIGHT_STARTUP_WARM_ACCOUNTS: z.string().default("4"),
       PLAYWRIGHT_PREPARE_ALL_ON_STARTUP: z.string().default("false"),
       CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
       CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
@@ -1348,6 +1349,7 @@ var init_config = __esm({
         jsHeapMb: Math.max(64, parseInt(env.PLAYWRIGHT_JS_HEAP_MB)),
         lowMemoryFlags: env.PLAYWRIGHT_LOW_MEMORY_FLAGS !== "false",
         maxActiveContexts: Math.max(0, parseInt(env.PLAYWRIGHT_MAX_ACTIVE_CONTEXTS)),
+        startupWarmAccounts: Math.max(1, parseInt(env.PLAYWRIGHT_STARTUP_WARM_ACCOUNTS)),
         prepareAllOnStartup: env.PLAYWRIGHT_PREPARE_ALL_ON_STARTUP !== "false"
       },
       captcha: {

package/dist/reset-cooldowns.js

@@ -1302,6 +1302,7 @@ var init_config = __esm({
       // own context while serving. Accounts in cooldown (rate-limited) sit idle,
       // drop out of the warm set and get evicted.
       PLAYWRIGHT_MAX_ACTIVE_CONTEXTS: z.string().default("2"),
+      PLAYWRIGHT_STARTUP_WARM_ACCOUNTS: z.string().default("4"),
       PLAYWRIGHT_PREPARE_ALL_ON_STARTUP: z.string().default("false"),
       CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
       CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
@@ -1450,6 +1451,7 @@ var init_config = __esm({
         jsHeapMb: Math.max(64, parseInt(env.PLAYWRIGHT_JS_HEAP_MB)),
         lowMemoryFlags: env.PLAYWRIGHT_LOW_MEMORY_FLAGS !== "false",
         maxActiveContexts: Math.max(0, parseInt(env.PLAYWRIGHT_MAX_ACTIVE_CONTEXTS)),
+        startupWarmAccounts: Math.max(1, parseInt(env.PLAYWRIGHT_STARTUP_WARM_ACCOUNTS)),
         prepareAllOnStartup: env.PLAYWRIGHT_PREPARE_ALL_ON_STARTUP !== "false"
       },
       captcha: {

package/dist/sync-clients.js

@@ -157,6 +157,7 @@ var envSchema = z.object({
   // own context while serving. Accounts in cooldown (rate-limited) sit idle,
   // drop out of the warm set and get evicted.
   PLAYWRIGHT_MAX_ACTIVE_CONTEXTS: z.string().default("2"),
+  PLAYWRIGHT_STARTUP_WARM_ACCOUNTS: z.string().default("4"),
   PLAYWRIGHT_PREPARE_ALL_ON_STARTUP: z.string().default("false"),
   CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
   CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
@@ -305,6 +306,7 @@ var config = {
     jsHeapMb: Math.max(64, parseInt(env.PLAYWRIGHT_JS_HEAP_MB)),
     lowMemoryFlags: env.PLAYWRIGHT_LOW_MEMORY_FLAGS !== "false",
     maxActiveContexts: Math.max(0, parseInt(env.PLAYWRIGHT_MAX_ACTIVE_CONTEXTS)),
+    startupWarmAccounts: Math.max(1, parseInt(env.PLAYWRIGHT_STARTUP_WARM_ACCOUNTS)),
     prepareAllOnStartup: env.PLAYWRIGHT_PREPARE_ALL_ON_STARTUP !== "false"
   },
   captcha: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "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/api/server.ts

@@ -877,23 +877,20 @@ export async function startServer(options?: {
           );
         });
       } else if (remainingAccounts.length > 0) {
-        console.log(
-          `🪶 [Server] ${remainingAccounts.length} standby account(s) will initialize on demand`,
-        );
-
-        // In background: warm 1 reserve account (if maxActiveContexts > 1) and
-        // validate the rest of the standby accounts
+        // In background: warm reserve accounts up to a safe limit (default 4 total ready accounts)
+        // to prevent IP-level login flood / anti-bot challenge rate-limits on Alibaba.
         void (async () => {
-          const { validateAccountLogin } = await import("../services/playwright.ts");
           const { ensureAccountInPriority } = await import("../core/account-priority.ts");
 
-          let accountsToValidate = remainingAccounts;
+          const targetWarmTotal = Math.min(
+            config.playwright.startupWarmAccounts,
+            totalAccounts,
+          );
+          let currentReadyCount = readyAccountIds.size;
 
-          // Warm reserve account in background for fast failover without delaying startup
-          if (config.playwright.maxActiveContexts > 1 && remainingAccounts.length > 0) {
-            let reserveCandidateIdx = 0;
-            for (; reserveCandidateIdx < remainingAccounts.length; reserveCandidateIdx++) {
-              const reserveAccount = remainingAccounts[reserveCandidateIdx];
+          if (currentReadyCount < targetWarmTotal && remainingAccounts.length > 0) {
+            for (const reserveAccount of remainingAccounts) {
+              if (currentReadyCount >= targetWarmTotal) break;
               try {
                 const ok = await prepareAccountRuntime(
                   reserveAccount,
@@ -903,12 +900,12 @@ export async function startServer(options?: {
                   warmQwenChatPool,
                 );
                 if (ok) {
+                  readyAccountIds.add(reserveAccount.id);
                   ensureAccountInPriority(reserveAccount.id);
+                  currentReadyCount++;
                   console.log(
-                    `✅ [Server] Reserve account ready (2/${totalAccounts}): ${maskEmail(reserveAccount.email)}`,
+                    `✅ [Server] Reserve account ready (${currentReadyCount}/${totalAccounts}): ${maskEmail(reserveAccount.email)}`,
                   );
-                  reserveCandidateIdx++;
-                  break;
                 }
               } catch (err) {
                 console.warn(
@@ -916,56 +913,17 @@ export async function startServer(options?: {
                 );
               }
             }
-            accountsToValidate = remainingAccounts.slice(reserveCandidateIdx);
           }
 
-          let validated = 0;
-          let failed = 0;
-
-          for (const account of accountsToValidate) {
-            try {
-              const creds = getAccountCredentials(account.id) ?? account;
-              // Validate login in background with real unmasked credentials
-              const ok = await validateAccountLogin(
-                creds,
-                config.playwright.headless,
-                config.playwright.browser,
-              );
-              if (ok) {
-                // Add to priority list only once validated
-                ensureAccountInPriority(account.id);
-                validated++;
-                console.log(
-                  `✅ [Server] Standby account validated: ${maskEmail(account.email)}`,
-                );
-              } else {
-                failed++;
-                console.warn(
-                  `⚠️  [Server] Standby account login failed: ${maskEmail(account.email)} (quarantined)`,
-                );
-              }
-            } catch (error) {
-              failed++;
-              console.warn(
-                `⚠️  [Server] Standby account validation error: ${maskEmail(account.email)}: ${getErrorMessage(error)} (quarantined)`,
-              );
-              const { markAccountRateLimited } = await import("../core/account-manager.ts");
-              markAccountRateLimited(
-                account.id,
-                24 * 3600 * 1000,
-                `StandbyValidationError: ${getErrorMessage(error)}`,
-              );
-            }
-          }
-
-          if (validated > 0 || failed > 0) {
+          const standbyCount = totalAccounts - currentReadyCount;
+          if (standbyCount > 0) {
             console.log(
-              `✅ [Server] Standby validation complete: ${validated} account(s) ready${failed > 0 ? `, ${failed} failed` : ""}`,
+              `🪶 [Server] ${standbyCount} standby account(s) ready in pool (will initialize on demand when active accounts rotate)`,
             );
           }
         })().catch((error) => {
           console.warn(
-            `❌ [Server] Background standby validation failed: ${getErrorMessage(error)}`,
+            `❌ [Server] Background account preparation failed: ${getErrorMessage(error)}`,
           );
         });
       }

package/src/core/config.ts

@@ -76,6 +76,7 @@ const envSchema = z
     // own context while serving. Accounts in cooldown (rate-limited) sit idle,
     // drop out of the warm set and get evicted.
     PLAYWRIGHT_MAX_ACTIVE_CONTEXTS: z.string().default("2"),
+    PLAYWRIGHT_STARTUP_WARM_ACCOUNTS: z.string().default("4"),
     PLAYWRIGHT_PREPARE_ALL_ON_STARTUP: z.string().default("false"),
     CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
     CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
@@ -235,6 +236,7 @@ export const config = {
     jsHeapMb: Math.max(64, parseInt(env.PLAYWRIGHT_JS_HEAP_MB)),
     lowMemoryFlags: env.PLAYWRIGHT_LOW_MEMORY_FLAGS !== "false",
     maxActiveContexts: Math.max(0, parseInt(env.PLAYWRIGHT_MAX_ACTIVE_CONTEXTS)),
+    startupWarmAccounts: Math.max(1, parseInt(env.PLAYWRIGHT_STARTUP_WARM_ACCOUNTS)),
     prepareAllOnStartup: env.PLAYWRIGHT_PREPARE_ALL_ON_STARTUP !== "false",
   },
   captcha: {

package/src/core/version.ts

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

package/src/routes/chat/account.ts

@@ -1487,19 +1487,24 @@ async function tryCreateStreamWithRetry(
 			};
 		}
 
-		if (
+		const isSessionExpired =
 			err instanceof QwenSessionExpiredError ||
-			err.name === "QwenSessionExpiredError"
-		) {
+			err?.name === "QwenSessionExpiredError" ||
+			(err instanceof Error &&
+				(err.message.toLowerCase().includes("token has expired") ||
+					err.message.toLowerCase().includes("session expired") ||
+					err.message.toLowerCase().includes("401 não autorizado") ||
+					err.message.toLowerCase().includes("unauthorized")));
+
+		if (isSessionExpired) {
 			console.warn(
-				`🔄 [Chat] Session expired for ${currentAccountEmail} (${currentAccountId}). Attempting re-login...`,
+				`🔄 [Chat] Session expired for ${currentAccountEmail} (${currentAccountId}). Attempting silent token refresh/re-login...`,
 			);
 			const reLoginOk = await attemptRelogin(
 				currentAccountId,
 				currentAccountEmail,
 			);
 			if (reLoginOk) continue;
-			return { success: false, error: err };
 		}
 
 

package/src/services/auth-playwright.ts

@@ -56,6 +56,11 @@ async function ensurePlaywrightInitialized(accountId: string): Promise<void> {
   } catch {
     // Non-fatal: chat creation will still work with default account settings.
   }
+
+  try {
+    const { ensureAccountInPriority } = await import("../core/account-priority.ts");
+    ensureAccountInPriority(accountId);
+  } catch {}
 }
 
 export async function getBasicHeaders(accountId?: string): Promise<{

package/src/services/qwen.ts

@@ -2502,15 +2502,23 @@ function parseQwenJsonError(
 
   if (errorJson?.success === false) {
     const code = errorJson.data?.code || errorJson.code || "UpstreamError";
+    const detailsStr = typeof details === "string" ? details : "";
+    const codeStr = String(code).toLowerCase();
+    const detailsLower = detailsStr.toLowerCase();
 
-    if (
+    const isAuthExpired =
       status === 401 ||
-      code === "Unauthorized" ||
-      (typeof details === "string" &&
-        (details.includes("login") || details.includes("session")))
-    ) {
+      codeStr.includes("unauthorized") ||
+      detailsLower.includes("token has expired") ||
+      detailsLower.includes("log in") ||
+      detailsLower.includes("login") ||
+      detailsLower.includes("session") ||
+      detailsLower.includes("não autorizado") ||
+      detailsLower.includes("unauthorized");
+
+    if (isAuthExpired) {
       return new QwenSessionExpiredError(
-        `Session expired: ${details}`,
+        `Session expired: ${detailsStr || codeStr}`,
         accountId || "global",
       );
     }
@@ -3301,8 +3309,29 @@ async function createQwenStreamInternal(
           );
         }
 
+        const parsedJsonErr = parseQwenJsonError(errText, response.status, accountId);
+        if (
+          parsedJsonErr instanceof QwenSessionExpiredError &&
+          accountId &&
+          !retriedNonSseResponse
+        ) {
+          retriedNonSseResponse = true;
+          logger.warn(
+            "[Qwen] Token expired on completion fetch (200 JSON); refreshing session and retrying",
+            { accountId, chatId: chatSessionId ?? "new" },
+          );
+          const { refreshAccountToken } = await import("./playwright.ts");
+          const refreshed = await refreshAccountToken(accountId);
+          if (refreshed.success) {
+            const fresh = await getQwenHeaders(false, accountId);
+            activeHeaders = fresh.headers;
+            response = await fetchCompletion(activeHeaders);
+            continue;
+          }
+        }
+
         throw withCreatedChatMetadata(
-          parseQwenJsonError(errText, response.status, accountId) ??
+          parsedJsonErr ??
             new QwenUpstreamError(
               `Qwen returned non-stream JSON response: ${errText.substring(0, 300)}`,
               "NonStreamJsonResponse",
@@ -3378,6 +3407,35 @@ async function createQwenStreamInternal(
             response.status,
             accountId,
           );
+          if (
+            parsedError instanceof QwenSessionExpiredError &&
+            accountId &&
+            !retriedNonSseResponse
+          ) {
+            retriedNonSseResponse = true;
+            logger.warn(
+              "[Qwen] Token expired on completion fetch (!response.ok); refreshing session and retrying",
+              { accountId, chatId: chatSessionId ?? "new", status: response.status },
+            );
+            const { refreshAccountToken } = await import("./playwright.ts");
+            const refreshed = await refreshAccountToken(accountId);
+            if (refreshed.success) {
+              const fresh = await getQwenHeaders(false, accountId);
+              activeHeaders = fresh.headers;
+              response = await fetchCompletion(activeHeaders);
+              if (response.ok && response.body) {
+                return {
+                  stream: wrapUpstreamStream(response.body, controller),
+                  headers: activeHeaders,
+                  uiSessionId: chatSessionId || "",
+                  controller,
+                  accountId: accountId ?? "global",
+                  createdNewChat,
+                  tokenEstimationContext,
+                };
+              }
+            }
+          }
           if (parsedError) {
             throw withCreatedChatMetadata(parsedError);
           }