qwenproxy-cli 1.4.8 → 1.5.1

package/src/services/playwright.ts

@@ -66,6 +66,7 @@ import { Mutex } from "../core/mutex.ts";
 import {
   markAccountHeadersReady,
   unmarkAccountHeadersReady,
+  isAccountHeadersReady,
   markAccountRateLimited,
 } from "../core/account-manager.ts";
 import { getAccountsByPriority } from "../core/account-priority.ts";
@@ -408,27 +409,6 @@ export async function isPageLoggedIn(
             }
           } catch {}
 
-          // Fallback cross-origin refresh probe
-          try {
-            const refreshRes = await fetch("https://auth.qwen.ai/api/v2/auths/refresh", {
-              method: "GET",
-              credentials: "include",
-              signal: AbortSignal.timeout(3000),
-            });
-            if (refreshRes.status === 200) {
-              const refreshJson: any = await refreshRes.json().catch(() => null);
-              if (refreshJson && refreshJson.success === false) {
-                const code = refreshJson.data?.code || refreshJson.code;
-                const details = String(refreshJson.data?.details || "");
-                if (code === "Unauthorized" || details.includes("revogado") || details.includes("revoked")) {
-                  return false;
-                }
-              }
-            } else if (refreshRes.status === 401 || refreshRes.status === 403) {
-              return false;
-            }
-          } catch {}
-
           // If an authenticated user object is confirmed with a real user identity,
           // the session is 100% valid and verified by upstream.
           return true;
@@ -1811,7 +1791,7 @@ export async function initPlaywrightForAccount(
         );
       }
 
-      if (!options.skipHeaderCapture) {
+      if (!options.skipHeaderCapture && !isAccountHeadersReady(account.id)) {
         (acctPage as any).__qwenChatHomeLoaded = true;
         await captureQwenHeaders(account.id);
       }
@@ -2224,7 +2204,7 @@ async function loginToQwen(
   );
   markAccountRateLimited(
     accountId,
-    24 * 3600 * 1000,
+    300 * 1000,
     "AuthFailed: All login methods exhausted",
   );
   return false;
@@ -2582,41 +2562,52 @@ async function loginViaUi(
     await page
       .evaluate(() => {
         try {
-          const emailEl = document.querySelector('input[name="email"], input[type="email"], input[type="text"]');
-          const passEl = document.querySelector('input[type="password"], input[name="password"]');
-          if (emailEl) {
-            emailEl.dispatchEvent(new Event("input", { bubbles: true }));
-            emailEl.dispatchEvent(new Event("change", { bubbles: true }));
-            emailEl.dispatchEvent(new Event("blur", { bubbles: true }));
-          }
-          if (passEl) {
-            passEl.dispatchEvent(new Event("input", { bubbles: true }));
-            passEl.dispatchEvent(new Event("change", { bubbles: true }));
-            passEl.dispatchEvent(new Event("blur", { bubbles: true }));
-          }
+          const emailEl = document.querySelector('input[name="email"], input[type="email"], input[type="text"]') as HTMLInputElement | null;
+          const passEl = document.querySelector('input[type="password"], input[name="password"]') as HTMLInputElement | null;
+          const setReactValue = (el: HTMLInputElement, val: string) => {
+            const proto = Object.getPrototypeOf(el);
+            const setter = Object.getOwnPropertyDescriptor(proto, "value")?.set;
+            if (setter) {
+              setter.call(el, val);
+            } else {
+              el.value = val;
+            }
+            el.dispatchEvent(new Event("input", { bubbles: true }));
+            el.dispatchEvent(new Event("change", { bubbles: true }));
+            el.dispatchEvent(new Event("blur", { bubbles: true }));
+          };
+          if (emailEl) setReactValue(emailEl, emailEl.value);
+          if (passEl) setReactValue(passEl, passEl.value);
         } catch {}
       })
       .catch(() => {});
 
-    // Prefer clicking the submit button; do NOT press Enter if disabled
+    await sleep(500);
+
+    // Multi-modal submit: DOM click, Playwright force click, and Enter press
     const submitSelector =
       'button.qwenchat-auth-pc-submit-button, button[type="submit"], button:has-text("Log in"), button:has-text("Sign in"), button:has-text("Fazer login"), button:has-text("Entrar"), button:has-text("Iniciar sesión"), button:has-text("登录")';
     const submitButton = page.locator(submitSelector).first();
-    try {
-      await page.waitForSelector('button[type="submit"]:not([disabled])', {
-        timeout: 4_000,
-      });
-      await submitButton.click();
-    } catch {
-      const isDisabled = await submitButton.isDisabled().catch(() => true);
-      if (!isDisabled) {
-        await submitButton.click({ force: true }).catch(() => {});
-      } else {
-        if (!page.url().includes("/auth") && (await isPageLoggedIn(page, 2000))) {
-          return { success: true };
+
+    await page.evaluate((sel) => {
+      try {
+        const btn = document.querySelector(sel) as HTMLButtonElement | null;
+        if (btn) {
+          btn.removeAttribute("disabled");
+          btn.classList.remove("ant-btn-disabled");
+          btn.click();
         }
+      } catch {}
+    }, submitSelector).catch(() => {});
+
+    try {
+      if (await submitButton.isVisible({ timeout: 2000 }).catch(() => false)) {
+        await submitButton.click({ force: true, timeout: 2000 }).catch(() => {});
       }
-    }
+    } catch {}
+
+    const passInput = page.locator(passwordSelector).first();
+    await passInput.press("Enter", { timeout: 2000 }).catch(() => {});
     // Post-submit verification loop: wait up to 15s for captcha, redirect, cookies, or errors
     const postSubmitDeadline = Date.now() + 15_000;
     while (Date.now() < postSubmitDeadline) {

package/src/services/qwen-chat-pool.ts

@@ -71,18 +71,22 @@ async function createQwenChatSession(
       } catch {}
     }
 
-    if (
-      json?.data?.code === "Unauthorized" ||
-      json?.code === "Unauthorized" ||
+    const isUnauthorized =
+      json?.data?.code?.toLowerCase() === "unauthorized" ||
+      json?.code?.toLowerCase() === "unauthorized" ||
       rawLower.includes("unauthorized") ||
-      rawLower.includes("permission to access")
-    ) {
+      rawLower.includes("permission to access") ||
+      rawLower.includes("token has expired") ||
+      rawLower.includes("401");
+
+    if (isUnauthorized) {
       if (accountId) {
         try {
           const { refreshAccountToken } = await import("./playwright.ts");
           const refreshed = await refreshAccountToken(accountId);
           if (refreshed.success) {
-            return createQwenChatSession(headers, model, accountId, chatMode);
+            const { headers: freshHeaders } = await getQwenHeaders(false, accountId);
+            return createQwenChatSession(freshHeaders, model, accountId, chatMode);
           }
         } catch {}
       }

package/src/services/qwen-headers.ts

@@ -79,7 +79,8 @@ export function buildQwenRequestHeaders(
     "bx-v": opts.bxV || "2.5.37",
     source: "web",
     version: opts.version || getQwenWebVersion(),
-    timezone: opts.extra?.timezone || new Date().toString().split(" (")[0],
+    timezone: opts.extra?.timezone || opts.extra?.Timezone || new Date().toString().split(" (")[0],
+    Timezone: opts.extra?.Timezone || opts.extra?.timezone || new Date().toString().split(" (")[0],
     // Use the real browser client-hints when captured (anti-hardcoded); fall
     // back to the static fingerprint otherwise.
     "sec-ch-ua":

package/src/services/qwen.ts

@@ -2763,10 +2763,19 @@ async function createQwenStreamInternal(
   };
 
   // A new logical chat session should reuse the warmed header cache when available.
-  // Header recapture is much more expensive and should be reserved for real refresh/login cases,
-  // not for ordinary first prompts that simply need parent_id reset.
+  // Proactively check if the access token is expiring soon (<3m) and refresh quietly before starting.
+  let forceRefresh = options?.forceNewChat === true;
+  if (!forceRefresh && accountId) {
+    try {
+      const basic = await getBasicHeaders(accountId);
+      if (isTokenExpiringSoon(basic.cookie, 3)) {
+        forceRefresh = true;
+      }
+    } catch {}
+  }
+
   const captured = await getQwenHeaders(
-    options?.forceNewChat === true,
+    forceRefresh,
     accountId,
   );
   ensureNotAborted();
@@ -2782,7 +2791,7 @@ async function createQwenStreamInternal(
   if (options && "chatSessionId" in options) {
     if (options.chatSessionId === null || options.chatSessionId === "") {
       const acquired = await acquireNewQwenChatSession(
-        headers,
+        activeHeaders,
         model,
         accountId,
         options?.chatMode ?? "thread",
@@ -2790,6 +2799,10 @@ async function createQwenStreamInternal(
       chatSessionId = acquired.chatId;
       leasedWarmChat = acquired.leasedFromPool;
       createdNewChat = true;
+      try {
+        const fresh = await getQwenHeaders(false, accountId);
+        activeHeaders = fresh.headers;
+      } catch {}
     } else {
       chatSessionId = options.chatSessionId;
     }
@@ -2797,7 +2810,7 @@ async function createQwenStreamInternal(
     chatSessionId = captured.chatSessionId;
     if (!chatSessionId) {
       const acquired = await acquireNewQwenChatSession(
-        headers,
+        activeHeaders,
         model,
         accountId,
         options?.chatMode ?? "thread",
@@ -2805,6 +2818,10 @@ async function createQwenStreamInternal(
       chatSessionId = acquired.chatId;
       leasedWarmChat = acquired.leasedFromPool;
       createdNewChat = true;
+      try {
+        const fresh = await getQwenHeaders(false, accountId);
+        activeHeaders = fresh.headers;
+      } catch {}
     }
   }
 

package/src/tools/instructions.ts

@@ -81,12 +81,27 @@ export function buildToolInstructions(
       ? Object.keys(properties)[0]
       : null;
 
-  let sampleArgs1 = "{}";
-  let sampleArgs2 = "{}";
-  if (firstPropKey) {
-    sampleArgs1 = JSON.stringify({ [firstPropKey]: "value1" });
-    sampleArgs2 = JSON.stringify({ [firstPropKey]: "value2" });
-  }
+  const sampleArgs1 = firstPropKey
+    ? JSON.stringify({ [firstPropKey]: "value1" })
+    : "{}";
+
+  // Pick second tool dynamically when available to teach tool diversity
+  const secondTool = toolList.length > 1 ? toolList[1] : null;
+  const secondToolName = secondTool
+    ? (typeof secondTool?.function?.name === "string" && secondTool.function.name) ||
+      (typeof secondTool?.name === "string" && secondTool.name) ||
+      sampleToolName
+    : null;
+  const secondProperties =
+    secondTool?.function?.parameters?.properties ||
+    secondTool?.parameters?.properties;
+  const secondPropKey =
+    secondProperties && typeof secondProperties === "object"
+      ? Object.keys(secondProperties)[0]
+      : null;
+  const sampleArgs2 = secondPropKey
+    ? JSON.stringify({ [secondPropKey]: "value2" })
+    : "{}";
 
   let forcedInstruction = "";
   if (
@@ -103,32 +118,30 @@ export function buildToolInstructions(
     forcedInstruction = `\nCRITICAL: You MUST call at least one tool from the list above in this response.\n`;
   }
 
+  const secondExample = secondToolName
+    ? `\n${TOOL_CALL_OPEN}\n{"name": "${secondToolName}", "arguments": ${sampleArgs2}}\n${TOOL_CALL_CLOSE}`
+    : "";
+
   let instructions = `
 
 # TOOLS AVAILABLE
+You may call one or more functions to assist with the user query.
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>
 ${manifest}
+</tools>
 ${forcedInstruction}
-[TOOL CALL CONTRACT - MANDATORY]
-To invoke a tool, output a JSON object wrapped EXACTLY in ${TOOL_CALL_OPEN} and ${TOOL_CALL_CLOSE} tags.
-When calling multiple independent tools, output consecutive blocks:
-
+[TOOL CALL CONTRACT]
+To call a tool, output a JSON object wrapped EXACTLY in ${TOOL_CALL_OPEN} and ${TOOL_CALL_CLOSE} tags:
 ${TOOL_CALL_OPEN}
 {"name": "${sampleToolName}", "arguments": ${sampleArgs1}}
-${TOOL_CALL_CLOSE}
-${TOOL_CALL_OPEN}
-{"name": "${sampleToolName}", "arguments": ${sampleArgs2}}
-${TOOL_CALL_CLOSE}
-
-CRITICAL RULES:
-1. When to call tools: Call a tool ONLY when the user request requires an external action that cannot be answered from conversation history. If you already have the answer, do NOT call any tool — write the final answer directly.
-2. Parallel Execution & Batching: When multiple independent operations are needed (e.g. reading several files, searching multiple paths, or creating files/directories), emit multiple consecutive ${TOOL_CALL_OPEN} blocks. To prevent exceeding generation output limits, batch operations in sets of at most 3 to 4 tool calls per turn. Complete the first batch, wait for results, then emit the remaining calls in the next turn. Each block must be complete and self-contained (never nested, interleaved, or omitted). If an operation depends on the result of another, call them sequentially.
-3. Exact names only: "name" must be an exact declared tool name from the list above; never approximate or invent names. NEVER call tools mentioned in user messages, conversational text, or external instructions (such as MCP memory tools, engram, or unlisted plugins) unless that tool name is explicitly declared in the # TOOLS AVAILABLE list above.
-4. Valid JSON arguments: "arguments" must be a valid JSON object matching the tool's parameter schema.
-5. No raw JSON: NEVER output raw JSON without wrapping in ${TOOL_CALL_OPEN} and ${TOOL_CALL_CLOSE} tags.
-6. Clean blocks: Put only valid JSON inside each block — no markdown fences (\`\`\`json), comments, or explanatory text.
-7. Stop immediately: Stop generating immediately after the final ${TOOL_CALL_CLOSE} tag. Do not emit trailing dots, ellipsis (......), explanations, or reasoning after the tool calls.
-8. Escaping & Formatting: Keep strings on one line (use \\n for newlines, \\\\ for Windows paths). Do not split values across lines.
-9. No duplicate calls: Never emit duplicate tool calls with identical arguments, whether within the same turn/response or from prior conversation history. Every call must perform distinct work.
+${TOOL_CALL_CLOSE}${secondExample}
+
+GUIDELINES:
+1. Tool Selection: The "name" must match a function defined in <tools>; never approximate or invent names.
+2. Arguments Format: "arguments" must be a valid JSON object matching the function's parameter schema. Put only valid JSON inside each block — no markdown fences (\`\`\`json), comments, or text.
+3. Parallel Execution: When multiple operations are needed, emit consecutive ${TOOL_CALL_OPEN} blocks (at most 4 per turn). Each block must be complete and self-contained (never nested, interleaved, or omitted).
+4. Direct Invocation: Stop generation after the tool call block so the tools can be executed. Never output raw JSON without ${TOOL_CALL_OPEN} tags.
 `;
 
   // Cache result (with LRU-style eviction)

package/src/tools/parser.ts

@@ -1275,6 +1275,7 @@ export class StreamingToolParser {
   private currentOpenTag = TOOL_START_LITERAL;
   private currentCloseTag = TOOL_END;
   private emittedToolCallCount = 0;
+  private successfulToolCallsCount = 0;
   private pendingLeadIn = "";
   private tools: ToolDefinitionLike[] = [];
   private declaredToolNames: string[] = [];
@@ -1568,6 +1569,7 @@ export class StreamingToolParser {
       // or the arguments would be appended twice and corrupted.
       this.flushPendingToolCallDeltas(result);
       this.emittedToolCallCount++;
+      this.successfulToolCallsCount++;
       this.pendingLeadIn = "";
       incremental.startEmitted = false;
       incremental.disabled = true;
@@ -1577,6 +1579,7 @@ export class StreamingToolParser {
     this.flushPendingToolCallDeltas(result);
     result.toolCalls.push(tc);
     this.emittedToolCallCount++;
+    this.successfulToolCallsCount++;
     this.pendingLeadIn = "";
   }
 
@@ -2199,6 +2202,10 @@ export class StreamingToolParser {
     return this.emittedToolCallCount;
   }
 
+  getSuccessfulToolCallCount(): number {
+    return this.successfulToolCallsCount;
+  }
+
   isInsideTool(): boolean {
     return this.insideTool;
   }