qwenproxy-cli 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "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/routes/anthropic/index.ts

@@ -105,6 +105,9 @@ app.post("/v1/messages", async (c) => {
           "Content-Type": "application/json",
           Authorization: `Bearer ${process.env.API_KEY || config.apiKey || ""}`,
           "x-qwenproxy-route": "Anthropic",
+          ...(c.req.header("x-qwenproxy-chat-mode")
+            ? { "x-qwenproxy-chat-mode": c.req.header("x-qwenproxy-chat-mode")! }
+            : {}),
         },
         body: JSON.stringify({
           ...openaiRequest,

package/src/routes/chat/context.ts

@@ -87,16 +87,17 @@ export async function buildFinalContext(
     ? false
     : useThreadNative && (hasExplicitConversationKey || !isNewSession); // has assistant messages = continuation of existing chat
 
-  // Compute sessionId: only generate a persistent session ID when we have
-  // an explicit conversation key. Otherwise, generate an ephemeral ID for
-  // logging/metrics only (not used for thread reuse). Temp mode never persists
-  // a thread, so it has no session id.
+  // Compute sessionId: deterministic session ID derived from the conversation
+  // key (or "implicit-thread") + system instructions + first user message.
+  // Including completeInstructions in ALL modes (not just explicit keys)
+  // prevents cross-project session collisions when different projects share
+  // the same first user message but have different system prompts / tools.
   const sessionId = isStateless
     ? null
     : (conversationKey || useThreadNative)
       ? deriveSessionId(
           messages,
-          conversationKey ? completeInstructions : "",
+          completeInstructions,
           conversationKey ?? "implicit-thread",
         )
       : null;

package/src/routes/responses/index.ts

@@ -136,6 +136,9 @@ app.post("/v1/responses", async (c) => {
                   "Content-Type": "application/json",
                   Authorization: `Bearer ${process.env.API_KEY || config.apiKey || ""}`,
                   "x-qwenproxy-route": "Responses",
+                  ...(c.req.header("x-qwenproxy-chat-mode")
+                    ? { "x-qwenproxy-chat-mode": c.req.header("x-qwenproxy-chat-mode")! }
+                    : {}),
                 },
                 body: JSON.stringify({
                   ...chatRequest,
@@ -300,6 +303,9 @@ app.post("/v1/responses", async (c) => {
             "Content-Type": "application/json",
             Authorization: `Bearer ${process.env.API_KEY || config.apiKey || ""}`,
             "x-qwenproxy-route": "Responses",
+            ...(c.req.header("x-qwenproxy-chat-mode")
+              ? { "x-qwenproxy-chat-mode": c.req.header("x-qwenproxy-chat-mode")! }
+              : {}),
           },
           body: JSON.stringify(chatRequest),
         },

package/src/services/captcha-coordinator.ts

@@ -130,7 +130,7 @@ export async function recoverBaxiaCaptcha(
       accountId,
       (page) => solveChallengeOnPage(page, challengeUrl),
       solverOperationTimeoutMs,
-      Math.min(config.timeouts.page, 5_000),
+      solverOperationTimeoutMs,
       false,
     );
 

package/src/services/playwright.ts

@@ -2335,19 +2335,30 @@ export async function captureQwenHeaders(
         1,
         Math.min(CHAT_INPUT_ACTION_TIMEOUT_MS, remainingBudgetMs()),
       );
-      try {
-        await page.focus(inputSelector, { timeout: inputActionTimeoutMs });
-        if (settled || page.isClosed()) return;
-        await page.fill(inputSelector, "", { timeout: inputActionTimeoutMs });
+      let interactionSucceeded = false;
+      for (let interactionTry = 1; interactionTry <= 2; interactionTry++) {
         if (settled || page.isClosed()) return;
-        await page.type(inputSelector, "a", {
-          delay: 100,
-          timeout: inputActionTimeoutMs,
-        });
-      } catch {
+        try {
+          await page.focus(inputSelector, { timeout: inputActionTimeoutMs });
+          if (settled || page.isClosed()) return;
+          await page.fill(inputSelector, "", { timeout: inputActionTimeoutMs });
+          if (settled || page.isClosed()) return;
+          await page.type(inputSelector, "a", {
+            delay: 100,
+            timeout: inputActionTimeoutMs,
+          });
+          interactionSucceeded = true;
+          break;
+        } catch {
+          if (settled || page.isClosed()) return;
+          if (interactionTry === 1) {
+            await sleep(300);
+          }
+        }
+      }
+      if (!interactionSucceeded) {
         // The input detached mid-interaction (challenge overlay, SPA
-        // re-render): same diagnosis as never appearing — only a fresh load
-        // recovers it.
+        // re-render): only a fresh load recovers it.
         if (settled || page.isClosed()) return;
         console.warn(
           `⏱️  [Playwright] Chat input interaction failed for ${accountId} (attempt ${attempt}); reloading`,
@@ -3342,6 +3353,10 @@ export function isPlaywrightInitialized(accountId: string): boolean {
   return accountPages.has(accountId);
 }
 
+export function isPlaywrightInitializing(accountId: string): boolean {
+  return inFlightAccountInits.has(accountId);
+}
+
 export function isAccountRecentlyActive(
   accountId: string,
   maxIdleMs = 300_000,

package/src/services/qwen.ts

@@ -27,7 +27,7 @@ import {
   syncModelMetadata,
 } from "../core/model-registry.ts";
 import { type Page, type BrowserContext } from "patchright";
-import { withAccountPage, assertAntiBotHeaders, onBrowserContextCreated } from "./playwright.ts";
+import { withAccountPage, assertAntiBotHeaders, onBrowserContextCreated, isPlaywrightInitializing } from "./playwright.ts";
 import { recoverBaxiaCaptcha } from "./captcha-coordinator.ts";
 import { startBaxiaCaptchaWatcher } from "./captcha-solver.ts";
 import { isAccountBusy } from "../core/account-concurrency.ts";
@@ -1767,6 +1767,14 @@ export async function disableNativeTools(accountId?: string): Promise<void> {
   ) {
     return;
   }
+  // Defer if the account's Playwright browser is still initializing: the
+  // settings POST requires the page mutex, and init legitimately holds it for
+  // 20-30s (navigation + bx SDK + header capture). Attempting to acquire the
+  // mutex now would time out (5s default in withQwenBrowserPage) and log a
+  // spurious WARN. The startup flow calls us again after init finishes.
+  if (accountId && isPlaywrightInitializing(accountId)) {
+    return;
+  }
   disablingNativeToolsInProgress.add(cacheKey);
 
   try {
@@ -2827,7 +2835,7 @@ async function createQwenStreamInternal(
             auto_thinking: mode === "auto",
             thinking_mode: thinkingMode,
             ...(thinkingEnabled ? { thinking_format: "summary" } : {}),
-            auto_search: true,
+            auto_search: false,
           };
         })(),
         extra: {

package/src/tools/parser.ts

@@ -1703,6 +1703,12 @@ export class StreamingToolParser {
       result.text += literalBlock;
     }
 
+    // Count undeclared/malformed tool calls toward the per-turn cap.
+    // Without this, the model can generate unlimited undeclared tool calls
+    // (e.g. Qwen-native WebSearch/WebFetch) that bypass the cap entirely,
+    // causing infinite generation until TOTAL_REQUEST_TIMEOUT (10 min).
+    this.emittedToolCallCount++;
+
     this.advanceMarkdownState(literalBlock);
     this.pendingLeadIn = "";
   }
@@ -2043,18 +2049,23 @@ export class StreamingToolParser {
             recoveryAttempts: truncRecoveryAttempts,
           });
           logger.warn(
-            "[parser] Dropping unrecoverable unclosed tool call at end of stream",
-            {
-              toolName,
-              category: "truncated",
-              contentLength: trimmed.length,
-              content: trimmed.substring(0, 2000),
-              failureReason:
-                "stream ended before tool_call closing tag; content too incomplete to reconstruct",
-              recoveryAttempts: truncRecoveryAttempts,
-              emittedToolCallsSoFar: this.emittedToolCallCount,
-            },
+            `[parser] Dropping unrecoverable unclosed tool call (${toolName || "unknown"}) at end of stream: stream ended before closing tag (${trimmed.length} chars)`,
           );
+          if (isToolcallDebugEnabled()) {
+            logger.debug(
+              "[parser] Unclosed tool call payload details",
+              {
+                toolName,
+                category: "truncated",
+                contentLength: trimmed.length,
+                content: trimmed.substring(0, 2000),
+                failureReason:
+                  "stream ended before tool_call closing tag; content too incomplete to reconstruct",
+                recoveryAttempts: truncRecoveryAttempts,
+                emittedToolCallsSoFar: this.emittedToolCallCount,
+              },
+            );
+          }
           if (
             this.emittedToolCallCount === 0 &&
             this.pendingLeadIn.trim().length > 0