qwenproxy-cli 1.5.2 → 1.5.3

package/dist/delete-chats.js

@@ -9567,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"
       );
     }
@@ -10108,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
@@ -10160,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

@@ -12736,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"
       );
     }
@@ -13277,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
@@ -13329,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);
           }
@@ -17106,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";
@@ -25891,7 +25936,7 @@ function getAppVersion() {
     }
   } catch {
   }
-  cachedVersion = "v1.5.2";
+  cachedVersion = "v1.5.3";
   return cachedVersion;
 }
 var cachedVersion;

package/package.json

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

@@ -17,6 +17,6 @@ export function getAppVersion(): string {
       }
     }
   } catch {}
-  cachedVersion = "v1.5.2";
+  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/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);
           }