qwenproxy-cli 1.2.1 → 1.2.3

package/package.json

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

@@ -97,6 +97,18 @@ app.post("/v1/messages", async (c) => {
   try {
     // 3. Translate Anthropic request to internal OpenAI format
     const openaiRequest = translateAnthropicToOpenAI(body);
+    const claudeSessionId =
+      c.req.header("x-claude-code-session-id") ||
+      (typeof body.metadata?.user_id === "string" && body.metadata.user_id.includes('"session_id":')
+        ? (() => {
+            try {
+              const parsed = JSON.parse(body.metadata.user_id as string);
+              return typeof parsed?.session_id === "string" ? parsed.session_id : undefined;
+            } catch {
+              return undefined;
+            }
+          })()
+        : undefined);
 
     const dispatchToChat = (streamMode: boolean) =>
       fetch(`http://127.0.0.1:${config.server.port}/v1/chat/completions`, {
@@ -105,9 +117,14 @@ 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")! }
+            : {}),
+          ...(claudeSessionId ? { "x-session-id": claudeSessionId } : {}),
         },
         body: JSON.stringify({
           ...openaiRequest,
+          ...(claudeSessionId ? { session_id: claudeSessionId } : {}),
           stream: streamMode,
           ...(streamMode ? { stream_options: { include_usage: true } } : {}),
         }),

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/chat/helpers.ts

@@ -113,6 +113,29 @@ export function formatThinkingSummaryContent(delta: any): string {
   return sections.join("\n\n");
 }
 
+/**
+ * Matches thinking phases verified in upstream Qwen Web HAR:
+ * - "thinking_summary": structured thinking in Qwen Max / Plus
+ * - "think": incremental thinking deltas in Qwen Omni
+ */
+export function isThinkingPhase(phase: unknown): boolean {
+  return phase === "think" || phase === "thinking_summary";
+}
+
+/**
+ * Extract thinking/reasoning text from a delta chunk, supporting both
+ * structured summaries (summary_title/summary_thought) and direct content deltas.
+ */
+export function extractThinkingContent(delta: any): string {
+  if (
+    Array.isArray(delta?.extra?.summary_title?.content) ||
+    Array.isArray(delta?.extra?.summary_thought?.content)
+  ) {
+    return formatThinkingSummaryContent(delta);
+  }
+  return typeof delta?.content === "string" ? delta.content : "";
+}
+
 export function isAbortError(err: unknown): boolean {
   if (err instanceof DOMException) {
     return err.name === "AbortError";

package/src/routes/chat/streaming.ts

@@ -67,6 +67,8 @@ import {
 } from "../../services/context-meter.ts";
 import {
   getIncrementalDelta,
+  isThinkingPhase,
+  extractThinkingContent,
   formatThinkingSummaryContent,
   shouldSuppressStreamAbort,
   isAbortError,
@@ -436,9 +438,9 @@ export async function processNonStreamingResponse(
           ) {
             const delta = chunk.choices[0].delta;
 
-            if (delta.phase === "thinking_summary") {
+            if (isThinkingPhase(delta.phase)) {
               isThinkingChunk = true;
-              const formattedSummary = formatThinkingSummaryContent(delta);
+              const formattedSummary = extractThinkingContent(delta);
               if (formattedSummary) {
                 const result = getIncrementalDelta(
                   lastThinkingSummary,
@@ -1737,9 +1739,9 @@ export async function processStreamingResponse(
                 break; // Exit the for loop; the while check leaves the read loop
               }
 
-              if (delta.phase === "thinking_summary") {
+              if (isThinkingPhase(delta.phase)) {
                 isThinkingChunk = true;
-                const formattedSummary = formatThinkingSummaryContent(delta);
+                const formattedSummary = extractThinkingContent(delta);
                 if (formattedSummary) {
                   const result = getIncrementalDelta(
                     lastThinkingSummary,
@@ -2254,9 +2256,9 @@ export async function processStreamingResponse(
               let foundStr = false;
               let isThinkingChunk = false;
 
-              if (delta.phase === "thinking_summary") {
+              if (isThinkingPhase(delta.phase)) {
                 isThinkingChunk = true;
-                const formattedSummary = formatThinkingSummaryContent(delta);
+                const formattedSummary = extractThinkingContent(delta);
                 if (formattedSummary) {
                   const result = getIncrementalDelta(
                     lastThinkingSummary,
@@ -2655,10 +2657,29 @@ export async function processStreamingResponse(
     } else {
       logger.error("[Chat] Stream callback error", errorDetails);
     }
-
-    // The HTTP response is already committed at this point. Emit a terminal
-    // OpenAI-compatible SSE error instead of silently closing the connection.
+    // The HTTP response is already committed at this point.
+    // 1. Emit an explicit assistant message delta so CLI/TUI clients that only
+    //    listen for choices[].delta.content (e.g. OpenCode, Claude Code, etc.)
+    //    render the error visibly in the chat instead of appearing blank/frozen.
+    // 2. Emit a terminal OpenAI-compatible SSE error event + [DONE].
     try {
+      const userFriendlyNotice = `\n\n⚠️ **[Qwen Security / Erro]** ${err.message || "A resposta foi interrompida pelo Qwen."}\n\n`;
+      const errorDelta = {
+        id: completionId,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: body.model,
+        choices: [
+          {
+            index: 0,
+            delta: { content: userFriendlyNotice },
+            logprobs: null,
+            finish_reason: "stop",
+          },
+        ],
+      };
+
+      await errorStream.write(`data: ${JSON.stringify(errorDelta)}\n\n`);
       await errorStream.write(
         `data: ${JSON.stringify({
           error: {
@@ -2668,7 +2689,7 @@ export async function processStreamingResponse(
           },
         })}\n\ndata: [DONE]\n\n`,
       );
-    } catch (_writeErr) {
+    } catch {
       // Stream already closed — client already disconnected or the stream
       // was cancelled. Nothing more we can do.
     }

package/src/routes/chat/validation.ts

@@ -43,14 +43,7 @@ export async function parseRequestBody(c: Context): Promise<ParsedRequest> {
   const body: OpenAIRequest = await c.req.json();
   logIncomingChatRequest(c, body);
   const isStream = body.stream ?? false;
-  const conversationKey =
-    typeof body.session_id === "string" && body.session_id.trim().length > 0
-      ? body.session_id.trim()
-      : typeof body.conversation_id === "string" &&
-          body.conversation_id.trim().length > 0
-        ? body.conversation_id.trim()
-        : null;
-
+  const conversationKey = extractExplicitConversationKey(c, body);
   const messages = body.messages || [];
   let uploadHeaders: Record<string, string> | null = null;
 
@@ -328,6 +321,63 @@ function contentLength(value: unknown): number {
   return 0;
 }
 
+export function extractExplicitConversationKey(
+  c: Context,
+  body: OpenAIRequest,
+): string | null {
+  const b = body as any;
+
+  // 1. Direct body properties (OpenAI-compatible extensions)
+  if (typeof b?.session_id === "string" && b.session_id.trim().length > 0) {
+    return b.session_id.trim();
+  }
+  if (typeof b?.conversation_id === "string" && b.conversation_id.trim().length > 0) {
+    return b.conversation_id.trim();
+  }
+  if (typeof b?.chat_id === "string" && b.chat_id.trim().length > 0) {
+    return b.chat_id.trim();
+  }
+
+  // 2. HTTP headers sent natively by coding agents
+  const headerCandidates = [
+    c.req.header("x-session-id"),             // OpenCode, Cline, AI-SDK, custom
+    c.req.header("x-session-affinity"),       // OpenCode / AI-SDK
+    c.req.header("session-id"),               // OpenAI Codex CLI
+    c.req.header("x-claude-code-session-id"), // Claude Code CLI
+    c.req.header("x-conversation-id"),        // Standard agents
+    c.req.header("conversation-id"),          // Standard agents
+    c.req.header("x-client-request-id"),      // Client fallback ID
+  ];
+
+  for (const candidate of headerCandidates) {
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate.trim();
+    }
+  }
+
+  // 3. Metadata payloads (Claude Code embeds session_id in user_id metadata JSON)
+  if (b?.metadata && typeof b.metadata === "object") {
+    if (typeof b.metadata.session_id === "string" && b.metadata.session_id.trim().length > 0) {
+      return b.metadata.session_id.trim();
+    }
+    if (typeof b.metadata.user_id === "string" && b.metadata.user_id.includes('"session_id":')) {
+      try {
+        const parsed = JSON.parse(b.metadata.user_id);
+        if (typeof parsed?.session_id === "string" && parsed.session_id.trim().length > 0) {
+          return parsed.session_id.trim();
+        }
+      } catch {}
+    }
+  }
+
+  // 4. Prompt cache key (used by Codex for session consistency)
+  if (typeof b?.prompt_cache_key === "string" && b.prompt_cache_key.trim().length > 0) {
+    return b.prompt_cache_key.trim();
+  }
+
+  return null;
+}
+
 function logIncomingChatRequest(c: Context, body: OpenAIRequest): void {
   const messages = Array.isArray(body.messages) ? body.messages : [];
   const tools = Array.isArray((body as any).tools) ? (body as any).tools : [];

package/src/routes/responses/index.ts

@@ -65,11 +65,16 @@ app.post("/v1/responses", async (c) => {
       historyMessages = history;
     }
 
+    const responsesSessionId =
+      c.req.header("session-id") ||
+      c.req.header("x-session-id") ||
+      c.req.header("x-client-request-id") ||
+      (req as any).prompt_cache_key ||
+      (typeof (body as any)?.session_id === "string" ? (body as any).session_id : undefined);
     // Convert to Chat Completions format
     const chatRequest = responsesToChatCompletions(req, historyMessages);
 
     if (isStream) {
-      // ============ STREAMING MODE ============
       const socket =
         (c.env as any)?.incoming?.socket || (c.req.raw as any)?.socket;
       if (socket && typeof socket.setNoDelay === "function") {
@@ -136,9 +141,14 @@ 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")! }
+                    : {}),
+                  ...(responsesSessionId ? { "session-id": responsesSessionId, "x-session-id": responsesSessionId } : {}),
                 },
                 body: JSON.stringify({
                   ...chatRequest,
+                  ...(responsesSessionId ? { session_id: responsesSessionId } : {}),
                   stream: true,
                   stream_options: { include_usage: true },
                 }),
@@ -300,19 +310,17 @@ 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")! }
+              : {}),
+            ...(responsesSessionId ? { "session-id": responsesSessionId, "x-session-id": responsesSessionId } : {}),
           },
-          body: JSON.stringify(chatRequest),
+          body: JSON.stringify({
+            ...chatRequest,
+            ...(responsesSessionId ? { session_id: responsesSessionId } : {}),
+          }),
         },
       );
-
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.error(
-          `[Responses] Upstream error: ${response.status} ${errorText}`,
-        );
-        return responsesError(c, "api_error", "Upstream service error", 502);
-      }
-
       const chatResponse = await response.json();
       const responsesResponse = chatCompletionsToResponses(
         chatResponse,

package/src/services/playwright.ts

@@ -61,7 +61,7 @@ import { loadAccounts, type QwenAccount } from "../core/accounts.ts";
 // acyclic, while the reverse direction would drag the browser layer into core.
 import { hasActiveAccountLease } from "../core/account-concurrency.ts";
 import { config } from "../core/config.ts";
-import { maskEmail } from "../core/logger.ts";
+import { maskEmail, logger } from "../core/logger.ts";
 import { Mutex } from "../core/mutex.ts";
 import {
   markAccountHeadersReady,
@@ -184,6 +184,22 @@ async function recoverStuckAccountMutex(
   // account be initialized again instead of remaining permanently wedged.
   if (accountMutexes.get(accountId) !== mutex) return;
 
+  const lockState = mutex.state();
+  // A lock is only considered stuck if it has been held for at least PLAYWRIGHT_MUTEX_WAIT_MS (60s).
+  // A waiter with a short timeout (e.g. 5s) timing out does NOT mean the lock holder is stuck!
+  // Furthermore, never nuke an account while it is initializing (init: takes 20-30s)
+  // or while it is actively serving a stream to a user.
+  if (
+    lockState.heldForMs < PLAYWRIGHT_MUTEX_WAIT_MS ||
+    lockState.heldBy.startsWith("init:") ||
+    isAccountServingStream(accountId)
+  ) {
+    logger.warn(
+      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${PLAYWRIGHT_MUTEX_WAIT_MS}ms | servingStream=${isAccountServingStream(accountId)}`,
+    );
+    return;
+  }
+
   console.warn(
     `[Playwright] Recovering stuck account mutex | account=${accountId} | key=${key}`,
   );
@@ -3353,6 +3369,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";
@@ -795,7 +795,7 @@ async function withQwenBrowserPage<T>(
       return fn(page);
     },
     operationTimeoutMs,
-    Math.min(config.timeouts.page, 5_000),
+    Math.min(config.timeouts.page, 30_000),
     recoverOnTimeout,
   );
 }
@@ -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 = "";
   }