qwenproxy-cli 1.6.4 → 1.6.5

package/src/routes/chat/streaming.ts

@@ -33,6 +33,10 @@ import {
 import type { Message, OpenAIRequest, Usage } from "../../utils/types.ts";
 import { touchChatLock } from "./account.ts";
 import { StreamingToolParser } from "../../tools/parser.ts";
+import {
+  decideMissingToolCallRetry,
+  type MissingToolCallReason,
+} from "../../tools/tool-call-heuristics.ts";
 import {
   getStream,
   markStreamEmitted,
@@ -609,8 +613,17 @@ export async function processNonStreamingResponse(
 
     const finishReason = toolCallsOut.length ? "tool_calls" : "stop";
 
-    // Auto-retry if all tool calls were malformed (no successful tool calls)
-    const allToolsFailed = toolParser && toolParser.getMalformedToolCalls().length > 0 && toolCallsOut.length === 0;
+    // Auto-retry if all tool calls were malformed or model hesitated with missing call
+    const retryDecision = toolParser
+      ? decideMissingToolCallRetry({
+          declaredToolCount: declaredTools.length,
+          successfulToolCallCount: toolParser.getSuccessfulToolCallCount(),
+          malformedToolCallCount: toolParser.getMalformedToolCalls().length,
+          emittedToolCallCount: toolParser.getEmittedToolCallCount(),
+          text: finalContent,
+        })
+      : { retry: false, reason: null as MissingToolCallReason };
+    const allToolsFailed = retryDecision.retry;
     const malformedRetryCount = midStreamRetry?.malformedRetryCount ?? 0;
     if (
       allToolsFailed &&
@@ -618,7 +631,7 @@ export async function processNonStreamingResponse(
       midStreamRetry &&
       malformedRetryCount < config.retry.autoRetryMalformedToolsMax
     ) {
-      const malformedCalls = toolParser.getMalformedToolCalls();
+      const malformedCalls = toolParser?.getMalformedToolCalls() ?? [];
       const malformedCount = malformedCalls.length;
 
       // Build detailed error message with available tools list
@@ -634,7 +647,9 @@ export async function processNonStreamingResponse(
         : "";
 
       let errorMessage: string;
-      if (undeclaredNames.length > 0) {
+      if (retryDecision.reason === "no_call") {
+        errorMessage = `You did not emit any tool call. Respond with a single tool-call block using one of the declared tools.${toolsHint}`;
+      } else if (undeclaredNames.length > 0) {
         errorMessage = `Your previous ${malformedCount} tool call(s) used undeclared tool names: ${undeclaredNames.join(", ")}. Only declared tools can be executed. Please retry with valid tool names.${toolsHint}`;
       } else {
         const previews = malformedCalls
@@ -719,7 +734,7 @@ export async function processNonStreamingResponse(
         );
       }
 
-      console.log(`🔄 [Chat] Auto-retry (${malformedRetryCount + 1}/${config.retry.autoRetryMalformedToolsMax}) | ${newStreamResult.activeAccountLabel} | ${body.model} | chat=${newStreamResult.uiSessionId.substring(0, 12)} | reason=malformed_tool_calls`);
+      console.log(`🔄 [Chat] Auto-retry (${malformedRetryCount + 1}/${config.retry.autoRetryMalformedToolsMax}) | ${newStreamResult.activeAccountLabel} | ${body.model} | chat=${newStreamResult.uiSessionId.substring(0, 12)} | reason=${retryDecision.reason === "no_call" ? "missing_tool_call" : "malformed_tool_calls"}`);
 
       // Process the new stream. Propagate the retry context with an incremented
       // counter so a subsequent malformed response can retry again up to
@@ -2164,9 +2179,14 @@ export async function processStreamingResponse(
 
         while (malformedRetryCount < maxMalformedRetries) {
           if (!toolParser) break;
-          const allToolsFailed =
-            toolParser.getMalformedToolCalls().length > 0 &&
-            toolParser.getSuccessfulToolCallCount() === 0;
+          const retryDecision = decideMissingToolCallRetry({
+            declaredToolCount: declaredTools.length,
+            successfulToolCallCount: toolParser.getSuccessfulToolCallCount(),
+            malformedToolCallCount: toolParser.getMalformedToolCalls().length,
+            emittedToolCallCount: toolParser.getEmittedToolCallCount(),
+            text: finalContent,
+          });
+          const allToolsFailed = retryDecision.retry;
           if (!allToolsFailed) break;
 
           const malformedCalls = toolParser.getMalformedToolCalls();
@@ -2185,7 +2205,9 @@ export async function processStreamingResponse(
               : "";
 
           let errorMessage: string;
-          if (undeclaredNames.length > 0) {
+          if (retryDecision.reason === "no_call") {
+            errorMessage = `You did not emit any tool call. Respond with a single tool-call block using one of the declared tools.${toolsHint}`;
+          } else if (undeclaredNames.length > 0) {
             errorMessage = `Your previous ${malformedCount} tool call(s) used undeclared tool names: ${undeclaredNames.join(", ")}. Only declared tools can be executed. Please retry with valid tool names.${toolsHint}`;
           } else {
             const previews = malformedCalls
@@ -2270,7 +2292,7 @@ export async function processStreamingResponse(
           }
 
           console.log(
-            `🔄 [Chat] Auto-retry (${malformedRetryCount + 1}/${maxMalformedRetries}) | ${newStreamResult.activeAccountLabel} | ${body.model} | chat=${newStreamResult.uiSessionId.substring(0, 12)} | reason=malformed_tool_calls`,
+            `🔄 [Chat] Auto-retry (${malformedRetryCount + 1}/${maxMalformedRetries}) | ${newStreamResult.activeAccountLabel} | ${body.model} | chat=${newStreamResult.uiSessionId.substring(0, 12)} | reason=${retryDecision.reason === "no_call" ? "missing_tool_call" : "malformed_tool_calls"}`,
           );
 
           // Transfer the retry's stream registry entry to the original

package/src/routes/responses/adapter.ts

@@ -372,7 +372,10 @@ export function chatCompletionsToResponses(
       cached_tokens: (chatRes.usage as any).prompt_tokens_details?.cached_tokens ?? 0,
     },
     output_tokens_details: {
-      reasoning_tokens: (chatRes.usage as any).completion_tokens_details?.reasoning_tokens ?? 0,
+      reasoning_tokens:
+        (chatRes.usage as any).completion_tokens_details?.reasoning_tokens ??
+        (chatRes.usage as any).output_tokens_details?.reasoning_tokens ??
+        0,
     },
     ...(chatRes.usage.context_meter
       ? { context_meter: chatRes.usage.context_meter }

package/src/services/context-meter.ts

@@ -189,7 +189,7 @@ export function enrichUsageWithContextMeter(
       ? usage.prompt_tokens
       : null;
   const reportedPromptTokens = options.reportUsage
-    ? (upstreamPromptTokens ?? snapshot.estimatedContextTokens)
+    ? (upstreamPromptTokens ?? usage.prompt_tokens)
     : usage.prompt_tokens;
   const contextMeter: ContextMeterSnapshot = {
     ...snapshot,

package/src/services/playwright.ts

@@ -83,6 +83,7 @@ import { setWafContextResetListener } from "../core/waf-isolation.ts";
 import { updateQwenWebVersion, getQwenWebVersion } from "./qwen-headers.ts";
 import { getAccountProfilePath, getProfilesDir } from "../core/paths.ts";
 import { parseJwtExpiry, isTokenExpiringSoon } from "../utils/jwt.ts";
+import { formatAsciiTimezone } from "../utils/timezone.ts";
 
 type ContextInitHook = (context: BrowserContext) => Promise<void> | void;
 const contextInitHooks: ContextInitHook[] = [];
@@ -517,7 +518,7 @@ const headerCaches = new Map<string, AccountHeaderCache>();
 // across the browser session; cookies are dynamically updated from the browser context.
 const HEADER_CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
 const HEADER_REFRESH_THRESHOLD = 0.8; // Background refresh at 80% of TTL
-const COOKIE_CACHE_TTL = 15 * 60 * 1000; // 15 minutes
+const COOKIE_CACHE_TTL = 60 * 1000; // 1 minute (prevents returning stale expiring token after refresh)
 const cookieCaches = new Map<string, { cookie: string; timestamp: number }>();
 const lastAccountActivity = new Map<string, number>();
 const lastKeepAliveNavigation = new Map<string, number>();
@@ -1777,6 +1778,26 @@ export async function initPlaywrightForAccount(
             }
           }
         }
+
+        // If the session restored from SQLite has an expired access token (e.g. was in standby for hours/days),
+        // proactively refresh it in-page now with the 30-day refresh_token instead of waiting for the first chat
+        // request to hit an upstream 401 and trigger a slow re-auth / captcha loop.
+        const currentCache = getHeaderCache(account.id);
+        const currentCookie = currentCache?.headers?.cookie || "";
+        if (currentCookie && isTokenExpiringSoon(currentCookie, 5)) {
+          try {
+            const refreshRes = await refreshAccountToken(account.id);
+            if (refreshRes.success) {
+              console.log(
+                `⚡ [Playwright] Silently refreshed expired token restored from DB for ${maskEmail(account.email)}`,
+              );
+            }
+          } catch (err: any) {
+            console.warn(
+              `⚠️  [Playwright] Failed to proactively refresh expired token from DB for ${maskEmail(account.email)}: ${err?.message || err}`,
+            );
+          }
+        }
         return;
       }
 
@@ -2160,7 +2181,7 @@ export async function startEmailOtpLogin(
         email: normalizedEmail,
         requestId,
         version: getQwenWebVersion() || "0.3.12",
-        timezone: new Date().toString().split(" (")[0],
+        timezone: formatAsciiTimezone(),
       },
     ).catch((err: any) => ({ ok: false, error: err?.message || String(err) }));
 
@@ -2272,7 +2293,7 @@ export async function verifyEmailOtpLogin(
       code: cleanCode,
       requestId,
       version: getQwenWebVersion() || "0.3.12",
-      timezone: new Date().toString().split(" (")[0],
+      timezone: formatAsciiTimezone(),
     },
   ).catch((err: any) => ({ ok: false, error: err?.message || String(err) }));
 
@@ -2626,7 +2647,7 @@ async function loginViaApi(
 
     const evalRes = await page
       .evaluate(
-        async ({ email, password, signinUrl, requestId }) => {
+        async ({ email, password, signinUrl, requestId, tz }) => {
           try {
             const response = await fetch(signinUrl, {
               method: "POST",
@@ -2638,7 +2659,7 @@ async function loginViaApi(
                 source: "web",
                 version: "0.3.11",
                 "x-request-origin": "https://chat.qwen.ai",
-                timezone: new Date().toString().split(" (")[0],
+                timezone: tz,
                 "x-request-id": requestId,
               },
               body: JSON.stringify({ email, password }),
@@ -2649,7 +2670,7 @@ async function loginViaApi(
             return { ok: false, error: e.message };
           }
         },
-        { email, password: hashedPassword, signinUrl, requestId },
+        { email, password: hashedPassword, signinUrl, requestId, tz: formatAsciiTimezone() },
       )
       .catch(() => null);
 
@@ -2667,7 +2688,7 @@ async function loginViaApi(
       const fallbackUrl = qwenUrl("/api/v2/auths/signin");
       const fallbackRes = await page
         .evaluate(
-          async ({ email, password, fallbackUrl, requestId }) => {
+          async ({ email, password, fallbackUrl, requestId, tz }) => {
             try {
               const response = await fetch(fallbackUrl, {
                 method: "POST",
@@ -2678,7 +2699,7 @@ async function loginViaApi(
                   "content-type": "application/json",
                   source: "web",
                   version: "0.3.11",
-                  timezone: new Date().toString().split(" (")[0],
+                  timezone: tz,
                   "x-request-id": requestId,
                 },
                 body: JSON.stringify({ email, password }),
@@ -2689,7 +2710,7 @@ async function loginViaApi(
               return { ok: false, error: e.message };
             }
           },
-          { email, password: hashedPassword, fallbackUrl, requestId },
+          { email, password: hashedPassword, fallbackUrl, requestId, tz: formatAsciiTimezone() },
         )
         .catch(() => null);
 
@@ -3111,7 +3132,7 @@ export async function refreshAccountToken(
   if (refreshToken) {
     try {
       const refreshResult = await page.evaluate(
-        async ({ rTok }) => {
+        async ({ rTok, tz }) => {
           try {
             const response = await fetch("https://auth.qwen.ai/api/v2/auths/refresh", {
               method: "GET",
@@ -3121,7 +3142,7 @@ export async function refreshAccountToken(
                 source: "web",
                 version: "0.3.11",
                 "x-request-origin": "https://chat.qwen.ai",
-                timezone: new Date().toString().split(" (")[0],
+                timezone: tz,
                 authorization: `Bearer ${rTok}`,
               },
             });
@@ -3131,7 +3152,7 @@ export async function refreshAccountToken(
             return { ok: false, error: e.message };
           }
         },
-        { rTok: refreshToken },
+        { rTok: refreshToken, tz: formatAsciiTimezone() },
       );
 
       const json = refreshResult?.data;
@@ -3175,6 +3196,7 @@ export async function refreshAccountToken(
           const cache = getHeaderCache(accountId);
           cache.headers.cookie = cookieStr;
           cache.lastRefresh = Date.now();
+          cookieCaches.set(accountId, { cookie: cookieStr, timestamp: Date.now() });
           markAccountHeadersReady(accountId);
 
           // Update SQLite session with new tokens
@@ -3213,6 +3235,7 @@ export async function refreshAccountToken(
         const cache = getHeaderCache(accountId);
         cache.headers.cookie = cookieStr;
         cache.lastRefresh = Date.now();
+        cookieCaches.set(accountId, { cookie: cookieStr, timestamp: Date.now() });
         markAccountHeadersReady(accountId);
         saveAuthSession(accountId, {
           cookie: cookieStr,
@@ -4653,11 +4676,11 @@ export async function keepAlivePlaywrightAccount(
 
     // Proactive session check: if token expires within 5 minutes, refresh in-page silently using refreshAccountToken
     const lastRefreshAttempt = lastProactiveTokenRefresh.get(accountId) ?? 0;
-    const cookie = await getCookies(accountId);
+    const cookie = await getCookies(accountId, true);
     if (cookie && isTokenExpiringSoon(cookie, 5) && now - lastRefreshAttempt > 60_000) {
       lastProactiveTokenRefresh.set(accountId, now);
-      console.log(
-        `💓 [SessionKeeper] Account ${accountId} access token expiring soon (<5m); silently refreshing...`,
+      logger.debug(
+        `[SessionKeeper] Account ${accountId} access token expiring soon (<5m); silently refreshing...`,
       );
       const res = await refreshAccountToken(accountId);
       if (res.success) {
@@ -4665,6 +4688,9 @@ export async function keepAlivePlaywrightAccount(
         touchAccountActivity(accountId);
         return true;
       }
+      logger.warn(
+        `[SessionKeeper] Failed to silently refresh expiring token for ${accountId}: ${res.error || "unknown error"}`,
+      );
     }
 
     const lastNavigation = lastKeepAliveNavigation.get(accountId) ?? 0;

package/src/services/qwen-headers.ts

@@ -2,6 +2,7 @@ import { v4 as uuidv4 } from "uuid";
 import { qwenUrl, qwenOrigin } from "./qwen-url.ts";
 import { config } from "../core/config.js";
 import { getChromeMajor, getSystemLocale } from "./fingerprint.ts";
+import { formatAsciiTimezone } from "../utils/timezone.ts";
 
 export function getSystemAcceptLanguage(customLocale?: string): string {
   const locale = customLocale || getSystemLocale();
@@ -79,8 +80,8 @@ export function buildQwenRequestHeaders(
     "bx-v": opts.bxV || "2.5.37",
     source: "web",
     version: opts.version || getQwenWebVersion(),
-    timezone: opts.extra?.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 || formatAsciiTimezone(),
+    Timezone: opts.extra?.Timezone || opts.extra?.timezone || formatAsciiTimezone(),
     // 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

@@ -31,6 +31,7 @@ import { withAccountPage, assertAntiBotHeaders, onBrowserContextCreated, isPlayw
 import { recoverBaxiaCaptcha } from "./captcha-coordinator.ts";
 import { startBaxiaCaptchaWatcher } from "./captcha-solver.ts";
 import { isAccountBusy } from "../core/account-concurrency.ts";
+import { formatAsciiTimezone, sanitizeHeaderForFetch } from "../utils/timezone.ts";
 
 // Re-exported from extracted modules for backward compatibility
 export {
@@ -611,18 +612,21 @@ export function buildCapturedQwenHeaders(
 // the first's whole generation). FIFO handoff on release keeps the old
 // leak-recovery semantics (release is idempotent; a dropped stream still blocks
 // its slot until cancel/idle-timeout frees it — same as before).
+export const STREAM_SLOT_MAX_HOLD_MS = 30 * 60 * 1000; // 30 minutes
+
 interface AccountStreamSlots {
-  active: number;
-  queue: Array<() => void>;
+  activeSlots: Map<number, number>; // slotId -> startedAt
+  queue: Array<(releaseFn: () => void) => void>;
 }
 const accountStreamMutexes = new Map<string, AccountStreamSlots>();
+let nextStreamSlotId = 1;
 
-function getAccountStreamMutex(
+export function getAccountStreamMutex(
   accountId: string,
 ): AccountStreamSlots {
   let slots = accountStreamMutexes.get(accountId);
   if (!slots) {
-    slots = { active: 0, queue: [] };
+    slots = { activeSlots: new Map(), queue: [] };
     accountStreamMutexes.set(accountId, slots);
   }
   return slots;
@@ -632,29 +636,78 @@ function streamSlotCapacity(): number {
   return Math.max(1, config.concurrency.maxStreamsPerAccount);
 }
 
-function createStreamSlotRelease(slots: AccountStreamSlots): () => void {
+function createStreamSlotRelease(slots: AccountStreamSlots, slotId: number): () => void {
   let released = false;
   return () => {
     if (released) return;
     released = true;
-    slots.active -= 1;
+    slots.activeSlots.delete(slotId);
     const next = slots.queue.shift();
     if (next) {
       // Hand the slot directly to the waiter (FIFO), same as the old mutex.
-      slots.active += 1;
-      next();
+      const nextId = nextStreamSlotId++;
+      slots.activeSlots.set(nextId, Date.now());
+      next(createStreamSlotRelease(slots, nextId));
     }
   };
 }
 
-async function acquireAccountStreamLock(accountId: string): Promise<() => void> {
+export function sweepStaleAccountStreamSlots(maxHoldMs: number = STREAM_SLOT_MAX_HOLD_MS): number {
+  const now = Date.now();
+  let sweptCount = 0;
+  for (const [accountId, slots] of accountStreamMutexes.entries()) {
+    for (const [slotId, startedAt] of Array.from(slots.activeSlots.entries())) {
+      if (now - startedAt >= maxHoldMs) {
+        logger.warn(
+          `[Qwen] Force-releasing stale stream slot | account=${accountId} | slotId=${slotId} | heldFor=${now - startedAt}ms | maxHold=${maxHoldMs}ms`,
+        );
+        slots.activeSlots.delete(slotId);
+        sweptCount++;
+        const next = slots.queue.shift();
+        if (next) {
+          const nextId = nextStreamSlotId++;
+          slots.activeSlots.set(nextId, now);
+          next(createStreamSlotRelease(slots, nextId));
+        }
+      }
+    }
+  }
+  return sweptCount;
+}
+
+let staleSlotSweeperTimer: NodeJS.Timeout | null = null;
+
+export function ensureStaleSlotSweeperStarted(): void {
+  if (staleSlotSweeperTimer) return;
+  staleSlotSweeperTimer = setInterval(() => {
+    try {
+      sweepStaleAccountStreamSlots();
+    } catch (err) {
+      logger.error("[Qwen] Error in stale stream slot sweeper", {
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }, 60_000);
+  staleSlotSweeperTimer.unref();
+}
+
+export function stopStaleSlotSweeperForTests(): void {
+  if (staleSlotSweeperTimer) {
+    clearInterval(staleSlotSweeperTimer);
+    staleSlotSweeperTimer = null;
+  }
+}
+
+export async function acquireAccountStreamLock(accountId: string): Promise<() => void> {
+  ensureStaleSlotSweeperStarted();
   const slots = getAccountStreamMutex(accountId);
-  if (slots.active < streamSlotCapacity()) {
-    slots.active += 1;
-    return Promise.resolve(createStreamSlotRelease(slots));
+  if (slots.activeSlots.size < streamSlotCapacity()) {
+    const slotId = nextStreamSlotId++;
+    slots.activeSlots.set(slotId, Date.now());
+    return Promise.resolve(createStreamSlotRelease(slots, slotId));
   }
   return new Promise<() => void>((resolve) => {
-    slots.queue.push(() => resolve(createStreamSlotRelease(slots)));
+    slots.queue.push((releaseFn) => resolve(releaseFn));
   });
 }
 
@@ -830,7 +883,7 @@ async function withQwenBrowserPage<T>(
  * adds Cookie, User-Agent, Origin, Referer, and sec-* headers, so we only
  * pass the anti-bot tokens and metadata that the browser cannot infer.
  */
-function getBrowserFetchHeaders(
+export function getBrowserFetchHeaders(
   headers: Record<string, string>,
 ): Record<string, string> {
   const browserAllowedHeaders = new Set([
@@ -847,11 +900,13 @@ function getBrowserFetchHeaders(
     "x-accel-buffering",
   ]);
 
-  return Object.fromEntries(
-    Object.entries(headers).filter(([name]) =>
-      browserAllowedHeaders.has(name.toLowerCase()),
-    ),
-  );
+  const result: Record<string, string> = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (browserAllowedHeaders.has(name.toLowerCase())) {
+      result[name] = sanitizeHeaderForFetch(String(value ?? ""));
+    }
+  }
+  return result;
 }
 
 interface BrowserTextResponse {
@@ -906,13 +961,14 @@ export async function requestQwenTextInBrowser(
 
   const evaluateRequest = (page: Page) =>
     page.evaluate(
-      async ({ url, method, headers, body, referrer, timeoutMs }: {
+      async ({ url, method, headers, body, referrer, timeoutMs, tz }: {
         url: string;
         method: "GET" | "POST" | "DELETE";
         headers: Record<string, string>;
         body?: string;
         referrer?: string;
         timeoutMs: number;
+        tz: string;
       }): Promise<BrowserTextResponse> => {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
@@ -939,7 +995,7 @@ export async function requestQwenTextInBrowser(
                     source: "web",
                     version: "0.3.11",
                     "x-request-origin": "https://chat.qwen.ai",
-                    timezone: new Date().toString().split(" (")[0],
+                    timezone: tz,
                     authorization: `Bearer ${rTok}`,
                   },
                   signal: AbortSignal.timeout(5000),
@@ -985,6 +1041,7 @@ export async function requestQwenTextInBrowser(
         body,
         referrer: options.referrer,
         timeoutMs: options.timeoutMs ?? Math.min(config.timeouts.page, 20_000),
+        tz: formatAsciiTimezone(),
       },
     );
   const recoverOnTimeout = !options.noMutexRecovery;
@@ -1931,7 +1988,7 @@ export async function disableNativeTools(accountId?: string): Promise<void> {
           async (page) => {
             const requestId = crypto.randomUUID();
             const response = await page.evaluate(
-              async ({ payload, timeoutMs, requestId }: { payload: any; timeoutMs: number; requestId: string }) => {
+              async ({ payload, timeoutMs, requestId, tz }: { payload: any; timeoutMs: number; requestId: string; tz: string }) => {
                 const controller = new AbortController();
                 const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
                 try {
@@ -1943,7 +2000,7 @@ export async function disableNativeTools(accountId?: string): Promise<void> {
                         accept: "application/json, text/plain, */*",
                         "content-type": "application/json",
                         "x-request-id": requestId,
-                        timezone: new Date().toString().split(" (")[0],
+                        timezone: tz,
                         source: "web",
                       },
                       body: JSON.stringify(payload),
@@ -1955,7 +2012,7 @@ export async function disableNativeTools(accountId?: string): Promise<void> {
                   clearTimeout(timeoutId);
                 }
               },
-              { payload, timeoutMs: config.timeouts.http, requestId },
+              { payload, timeoutMs: config.timeouts.http, requestId, tz: formatAsciiTimezone() },
             );
             return response;
           },
@@ -2241,7 +2298,7 @@ export async function deleteSingleQwenChat(
   const requestHeaders: Record<string, string> = {
     source: "web",
     version: "0.2.89",
-    timezone: new Date().toString().split(" (")[0],
+    timezone: formatAsciiTimezone(),
     "x-request-id": crypto.randomUUID(),
     Referer: qwenUrl(`/c/${encodeURIComponent(chatId)}`),
   };
@@ -2294,7 +2351,7 @@ export async function fetchRemoteQwenChats(
 
   const requestHeaders: Record<string, string> = {
     version: "0.2.89",
-    timezone: new Date().toString().split(" (")[0],
+    timezone: formatAsciiTimezone(),
     "x-request-id": crypto.randomUUID(),
     Referer: qwenUrl("/settings/chats"),
   };
@@ -2356,7 +2413,7 @@ export async function fetchQwenModels(
         async (page) => {
           const requestId = crypto.randomUUID();
           const response = await page.evaluate(
-            async ({ timeoutMs, requestId }: { timeoutMs: number; requestId: string }) => {
+            async ({ timeoutMs, requestId, tz }: { timeoutMs: number; requestId: string; tz: string }) => {
               const controller = new AbortController();
               const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
               try {
@@ -2365,7 +2422,7 @@ export async function fetchQwenModels(
                   headers: {
                     accept: "application/json, text/plain, */*",
                     "x-request-id": requestId,
-                    timezone: new Date().toString().split(" (")[0],
+                    timezone: tz,
                     source: "web",
                   },
                   signal: controller.signal,
@@ -2375,7 +2432,7 @@ export async function fetchQwenModels(
                 clearTimeout(timeoutId);
               }
             },
-            { timeoutMs: config.timeouts.http, requestId },
+            { timeoutMs: config.timeouts.http, requestId, tz: formatAsciiTimezone() },
           );
           return response;
         },
@@ -2421,7 +2478,7 @@ export async function fetchQwenModels(
       bxUa,
       bxUmidtoken,
       extra: {
-        timezone: new Date().toString(),
+        timezone: formatAsciiTimezone(),
       },
     }),
     undefined,

package/src/tools/tool-call-heuristics.ts

@@ -0,0 +1,88 @@
+/**
+ * tool-call-heuristics.ts — Heuristics for deciding whether a turn that produced
+ * NO (successful) tool call should be auto-retried.
+ *
+ * The existing retry path only fires when a `<tool_call>` block was emitted
+ * but could not be parsed (malformed / undeclared). It does NOT cover the case
+ * where the model emits no tool-call block at all and instead answers with
+ * prose that references tools as if they were missing, e.g.:
+ *
+ *   "Tool bash does not exists."
+ *   "Tool read does not exists."
+ *
+ * In that case the client sees `finish_reason: "stop"` with no `tool_calls`,
+ * ends its turn, and the loop stalls until a human nudges it ("continue").
+ */
+
+export type MissingToolCallReason = "malformed" | "no_call" | "json_in_text" | null;
+
+export interface MissingToolCallInput {
+  /** Number of tool definitions declared on the request. */
+  declaredToolCount: number;
+  /** Tool calls that parsed AND resolved to a declared tool. */
+  successfulToolCallCount: number;
+  /** `<tool_call>` blocks captured but rejected (bad JSON / undeclared name). */
+  malformedToolCallCount: number;
+  /** Total tool-call blocks the parser saw (malformed + capped + valid). */
+  emittedToolCallCount: number;
+  /** Assistant-visible text for the turn (excluding the tool-call blocks). */
+  text: string;
+}
+
+export interface MissingToolCallDecision {
+  retry: boolean;
+  reason: MissingToolCallReason;
+}
+
+/**
+ * Matches a model reply that talks about a tool as if it did not exist, which
+ * is the signature of the "lost tool definitions under long context" failure.
+ * Kept deliberately narrow to avoid retrying legitimate prose.
+ */
+export function isToolHesitationText(text: string): boolean {
+  if (!text) return false;
+  return /\btools?\b[^.\n]{0,24}?\b(?:does\s*n[o']?t|do\s*n[o']?t|does\s*not|do\s*not)\b[^.\n]{0,12}?\bexist/i.test(
+    text,
+  );
+}
+
+/**
+ * Detects when the model dumped a raw tool-call JSON payload as prose instead
+ * of emitting it as a structured tool call.
+ */
+export function isRawToolCallJsonInText(text: string): boolean {
+  if (!text) return false;
+  const hasToolCallJson =
+    /\{\s*"name"\s*:\s*"[a-zA-Z_][a-zA-Z0-9_]*"\s*,\s*"arguments"\s*:\s*\{/i.test(text);
+  const hasStrayCloseTag = /<\/tool_call>/.test(text);
+  return hasToolCallJson || hasStrayCloseTag;
+}
+
+export function decideMissingToolCallRetry(
+  input: MissingToolCallInput,
+): MissingToolCallDecision {
+  const {
+    declaredToolCount,
+    successfulToolCallCount,
+    malformedToolCallCount,
+    emittedToolCallCount,
+    text,
+  } = input;
+
+  // No tools were declared: a text answer is the expected outcome.
+  if (declaredToolCount <= 0) return { retry: false, reason: null };
+
+  // A usable call was produced: nothing to recover.
+  if (successfulToolCallCount > 0) return { retry: false, reason: null };
+
+  // Existing behaviour: a block was emitted but it was rejected.
+  if (malformedToolCallCount > 0) return { retry: true, reason: "malformed" };
+
+  // New behaviour: no `<tool_call>` block was emitted at all, yet the model
+  // talked about tools as missing (the "does not exists" case).
+  if (emittedToolCallCount === 0 && isToolHesitationText(text)) {
+    return { retry: true, reason: "no_call" };
+  }
+
+  return { retry: false, reason: null };
+}