qwenproxy-cli 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "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

@@ -653,16 +653,12 @@ export async function startServer(options?: {
       const totalAccounts = accounts.length;
 
       // Warm accounts in priority order (recently successful accounts first),
-      // skipping accounts still on cooldown. Warm up to maxActiveContexts
-      // accounts (default 2: main + reserve) so an immediate failover has a
-      // live browser ready instead of incurring a cold start.
+      // skipping accounts still on cooldown. Warm the primary account first so
+      // the server binds the port and goes online immediately (~15-20s).
+      // Reserve account(s) and standby validations run seamlessly in background.
       const warmOrder = getAccountsByPriority(accounts).filter(
         (account) => !getAccountCooldownInfo(account.id),
       );
-      const targetWarmCount = Math.min(
-        warmOrder.length,
-        Math.max(1, config.playwright.maxActiveContexts),
-      );
       const readyAccountIds = new Set<string>();
 
       for (let i = 0; i < warmOrder.length; i++) {
@@ -676,11 +672,9 @@ export async function startServer(options?: {
         if (ok) {
           readyAccountIds.add(warmOrder[i].id);
           console.log(
-            `✅ [Server] Account ready (${readyAccountIds.size}/${totalAccounts}): ${maskEmail(warmOrder[i].email)}`,
+            `✅ [Server] Account ready (1/${totalAccounts}): ${maskEmail(warmOrder[i].email)}`,
           );
-          if (readyAccountIds.size >= targetWarmCount) {
-            break;
-          }
+          break;
         }
       }
 
@@ -717,16 +711,43 @@ export async function startServer(options?: {
           `🪶 [Server] ${remainingAccounts.length} standby account(s) will initialize on demand`,
         );
 
-        // Validate standby accounts in background: check login, add to priority,
-        // but keep browser closed until actually needed
+        // In background: warm 1 reserve account (if maxActiveContexts > 1) and
+        // validate the rest of the standby accounts
         void (async () => {
           const { validateAccountLogin } = await import("../services/playwright.ts");
           const { ensureAccountInPriority } = await import("../core/account-priority.ts");
 
+          let accountsToValidate = remainingAccounts;
+
+          // Warm reserve account in background for fast failover without delaying startup
+          if (config.playwright.maxActiveContexts > 1 && remainingAccounts.length > 0) {
+            const reserveAccount = remainingAccounts[0];
+            accountsToValidate = remainingAccounts.slice(1);
+            try {
+              const ok = await prepareAccountRuntime(
+                reserveAccount,
+                getAccountCredentials,
+                initPlaywrightForAccount,
+                disableNativeTools,
+                warmQwenChatPool,
+              );
+              if (ok) {
+                ensureAccountInPriority(reserveAccount.id);
+                console.log(
+                  `✅ [Server] Reserve account ready (2/${totalAccounts}): ${maskEmail(reserveAccount.email)}`,
+                );
+              }
+            } catch (err) {
+              console.warn(
+                `⚠️  [Server] Failed to warm reserve account ${maskEmail(reserveAccount.email)}: ${getErrorMessage(err)}`,
+              );
+            }
+          }
+
           let validated = 0;
           let failed = 0;
 
-          for (const account of remainingAccounts) {
+          for (const account of accountsToValidate) {
             try {
               const creds = getAccountCredentials(account.id) ?? account;
               // Validate login in background with real unmasked credentials
@@ -757,17 +778,14 @@ export async function startServer(options?: {
               markAccountRateLimited(
                 account.id,
                 24 * 3600 * 1000,
-                `AuthFailed: ${getErrorMessage(error)}`,
+                `StandbyValidationError: ${getErrorMessage(error)}`,
               );
             }
           }
-          if (failed > 0) {
-            console.warn(
-              `⚠️  [Server] Standby validation finished: ${validated} ok, ${failed} failed`,
-            );
-          } else if (validated > 0) {
+
+          if (validated > 0 || failed > 0) {
             console.log(
-              `✅ [Server] Standby validation complete: all ${validated} account(s) ready`,
+              `✅ [Server] Standby validation complete: ${validated} account(s) ready${failed > 0 ? `, ${failed} failed` : ""}`,
             );
           }
         })().catch((error) => {

package/src/routes/chat/retry-policy.ts

@@ -216,7 +216,10 @@ export function shouldRetryChatInProgressOnSameAccount(
 
 export function isAccountInitializationError(err: unknown): boolean {
   const message = errMessage(err).toLowerCase();
+  const code = errCode(err).toLowerCase();
   return (
+    code === "acquire_deadline" ||
+    message.includes("acquire deadline") ||
     message.includes("header capture returned incomplete anti-fraud headers") ||
     message.includes("required qwen anti-fraud headers are unavailable") ||
     message.includes("playwright not initialized for account") ||

package/src/routes/chat/validation.ts

@@ -18,6 +18,7 @@ import {
 } from "../../core/reasoning-effort.ts";
 
 import { TOOL_CALL_OPEN, TOOL_CALL_CLOSE } from "../../tools/toolcall-tags.ts";
+import { robustParseJSON } from "../../utils/json.ts";
 
 export interface ParsedRequest {
   body: OpenAIRequest;
@@ -224,15 +225,19 @@ async function buildPromptFromMessages(
           if (typeof args === "string") {
             try {
               parsedArgs = JSON.parse(args);
-            } catch (parseErr) {
-              // Malformed JSON: preserve raw string for model visibility
-              logger.warn("[chat] Failed to parse tool_call arguments", {
-                toolCallId: tc.id,
-                toolName: tc.function?.name,
-                error: parseErr instanceof Error ? parseErr.message : "Unknown",
-                rawArgs: args.substring(0, 200),
-              });
-              parsedArgs = { _raw: args };
+            } catch {
+              try {
+                parsedArgs = robustParseJSON(args);
+              } catch (parseErr) {
+                // Malformed JSON: preserve raw string for model visibility
+                logger.warn("[chat] Failed to parse tool_call arguments", {
+                  toolCallId: tc.id,
+                  toolName: tc.function?.name,
+                  error: parseErr instanceof Error ? parseErr.message : "Unknown",
+                  rawArgs: args.substring(0, 200),
+                });
+                parsedArgs = { _raw: args };
+              }
             }
           } else if (args && typeof args === "object") {
             parsedArgs = args;

package/src/services/playwright.ts

@@ -265,6 +265,7 @@ export function loadStorageState(accountId: string): string | undefined {
 export async function saveStorageState(
   context: BrowserContext,
   accountId: string,
+  timeoutMs = 5_000,
 ): Promise<void> {
   try {
     const stateFile = getStorageStatePath(accountId);
@@ -272,7 +273,11 @@ export async function saveStorageState(
     if (!fs.existsSync(dir)) {
       fs.mkdirSync(dir, { recursive: true });
     }
-    await context.storageState({ path: stateFile });
+    await withTimeout(
+      context.storageState({ path: stateFile }),
+      timeoutMs,
+      `storageState timed out after ${timeoutMs}ms`,
+    );
   } catch (error) {
     console.warn(
       `[Playwright] Failed to save storage state for ${accountId}: ${getErrorMessage(error)}`,
@@ -280,9 +285,13 @@ export async function saveStorageState(
   }
 }
 
-async function hasValidAuthCookie(context: BrowserContext): Promise<boolean> {
+async function hasValidAuthCookie(context: BrowserContext, timeoutMs = 3_000): Promise<boolean> {
   try {
-    const cookies = await context.cookies();
+    const cookies = await withTimeout(
+      context.cookies(),
+      timeoutMs,
+      `cookies check timed out after ${timeoutMs}ms`,
+    );
     return cookies.some(
       (c) =>
         (c.name.toLowerCase().includes("token") || c.name.toLowerCase().includes("session")) &&

package/src/tools/parser.ts

@@ -9,6 +9,7 @@ import {
   getOpenNames,
   getCloseNames,
   matchToolCloseAt,
+  stripTrailingStrayCloses,
 } from "./toolcall-tags.ts";
 
 export interface ToolCallDelta {
@@ -190,6 +191,45 @@ function closeTagContentIsParseable(buffer: string, endIdx: number): boolean {
   return tryParseJsonToolPayload(content);
 }
 
+function balanceClosingBrackets(content: string): string {
+  let inString = false;
+  let escaped = false;
+  const stack: string[] = [];
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{" || ch === "[") stack.push(ch);
+    else if (ch === "}" || ch === "]") {
+      const top = stack[stack.length - 1];
+      if ((top === "{" && ch === "}") || (top === "[" && ch === "]")) {
+        stack.pop();
+      }
+    }
+  }
+  if (inString) return content;
+  let out = content;
+  while (stack.length > 0) {
+    const open = stack.pop();
+    out += open === "{" ? "}" : "]";
+  }
+  return out;
+}
+
 /**
  * Plain-JSON.parse based candidate checks, in increasing tolerance order:
  * raw payload -> narrow typo repairs -> doubled trailing brace/bracket ->
@@ -214,9 +254,13 @@ function tryParseJsonToolPayload(content: string): boolean {
 
   const candidates = [repaired, stripped];
   if (repaired !== content) candidates.push(strippedRepaired);
-  candidates.push(`{\"${content}`, `{${content}`);
-  if (repaired !== content) candidates.push(`{\"${repaired}`, `{${repaired}`);
+  candidates.push(`{"${content}`, `{${content}`);
+  if (repaired !== content) candidates.push(`{"${repaired}`, `{${repaired}`);
 
+  const balanced = balanceClosingBrackets(content);
+  if (balanced !== content) candidates.push(balanced);
+  const balancedRepaired = balanceClosingBrackets(repaired);
+  if (balancedRepaired !== content) candidates.push(balancedRepaired);
   return candidates.some((candidate) => tryParse(candidate));
 }
 
@@ -999,6 +1043,10 @@ function isJsonPayloadTruncated(content: string): boolean {
   if (content.includes('\\"')) {
     alt.push(content.replace(/\\"/g, '"'));
   }
+  const balanced = balanceClosingBrackets(trimmed);
+  if (balanced !== trimmed) {
+    alt.push(balanced);
+  }
   for (const candidate of alt) {
     if (!scanJsonStructureIncomplete(candidate)) return false;
   }
@@ -1864,7 +1912,7 @@ export class StreamingToolParser {
       // argument values (e.g. `{"a": "1</tool_call>"}`). Genuine unclosed
       // streams (cut mid-payload) have no trailing tag, so this is a no-op
       // for them.
-      const trimmed = rawTrimmed.replace(/<\/tool_calls?>$/i, "");
+      const trimmed = stripTrailingStrayCloses(rawTrimmed).trim();
       if (trimmed.length > 0) {
         if (isToolcallDebugEnabled()) {
           logger.debug(
@@ -2570,10 +2618,13 @@ export class StreamingToolParser {
     // malformed tracking fires and the model re-emits cleanly.
     if (isJsonPayloadTruncated(block)) return null;
     const variants = [block];
+    const balanced = balanceClosingBrackets(block);
+    if (balanced !== block) {
+      variants.push(balanced);
+    }
     if (block.includes('\\"')) {
       variants.push(block.replace(/\\"/g, '"'));
     }
-
     for (const variant of variants) {
       try {
         const parsed = robustParseJSON(variant);

package/src/utils/json.ts

@@ -191,6 +191,13 @@ export function robustParseJSON(str: string): any {
     jsonPart = jsonPart.replace(/\\\\"/g, '\\"');
   }
 
+  // Heal stray backslashes escaping quotes on property keys or values
+  // e.g. "key\": \"val\" or "key\": "val" -> "key": "val"
+  jsonPart = jsonPart
+    .replace(/([{,]\s*)"([a-zA-Z0-9_-]+)\\"(\s*:)/g, '$1"$2"$3')
+    .replace(/:\s*\\"([^"\\]*)\\"(\s*[,}\]])/g, ': "$1"$2')
+    .replace(/:\s*\\"([^"\\]*)("(?:\s*[,}\]]))/g, ': "$1$2')
+    .replace(/:\s*"([^"\\]*)\\"(\s*[,}\]])/g, ': "$1"$2');
   let currentJson = jsonPart.replace(
     /([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)(\s*:)/g,
     '$1"$2"$3',