@pedrofariasx/qwenproxy 1.5.1 → 1.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrofariasx/qwenproxy",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "Local OpenAI-compatible proxy API that routes requests to Qwen (chat.qwen.ai) via Playwright browser automation.",
   "main": "index.js",
   "scripts": {

package/src/api/models.ts

@@ -41,9 +41,9 @@ app.get('/v1/models', async (c) => {
         'X-Request-Id': crypto.randomUUID(),
         'source': 'web',
         'bx-v': bxV,
-        'sec-ch-ua': '"Chromium";v="148", "Google Chrome";v="148", "Not/A)Brand";v="99"',
+        'sec-ch-ua': '"Chromium";v="137", "Google Chrome";v="137", "Not/A)Brand";v="99"',
         'sec-ch-ua-mobile': '?0',
-        'sec-ch-ua-platform': '"Linux"',
+        'sec-ch-ua-platform': '"Windows"',
         'Timezone': new Date().toString(),
         'Cookie': cookie,
       },
@@ -125,9 +125,9 @@ app.get('/v1/models/:model', async (c) => {
           'X-Request-Id': crypto.randomUUID(),
           'source': 'web',
           'bx-v': bxV,
-          'sec-ch-ua': '"Chromium";v="148", "Google Chrome";v="148", "Not/A)Brand";v="99"',
+          'sec-ch-ua': '"Chromium";v="137", "Google Chrome";v="137", "Not/A)Brand";v="99"',
           'sec-ch-ua-mobile': '?0',
-          'sec-ch-ua-platform': '"Linux"',
+          'sec-ch-ua-platform': '"Windows"',
           'Timezone': new Date().toString(),
           'Cookie': cookie,
         },

package/src/core/accounts.ts

@@ -74,9 +74,8 @@ export function listAccounts(): QwenAccount[] {
 }
 
 export function getAccountCredentials(id: string): QwenAccount | undefined {
-  const db = getDatabase()
-  const row = db.prepare('SELECT id, email, password, cooldown_until, cooldown_reason FROM accounts WHERE id = ?').get(id)
-  return row as QwenAccount | undefined
+  const cached = getCachedAccounts()
+  return cached.find(a => a.id === id)
 }
 
 export function updateAccountCooldown(id: string, cooldownUntil: number, reason: string | null): void {

package/src/routes/chat.ts

@@ -566,12 +566,12 @@ export async function chatCompletions(c: Context) {
         const createdTimestamp = Math.floor(Date.now() / 1000);
 
         const fastWriteContent = (content: string) => {
-          const escaped = content.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+          const escaped = JSON.stringify(content).slice(1, -1);
           streamWriter.write(`data: {"id":"${completionId}","object":"chat.completion.chunk","created":${createdTimestamp},"model":"${body.model}","choices":[{"index":0,"delta":{"content":"${escaped}"},"logprobs":null,"finish_reason":null}]}\n\n`);
         };
 
         const fastWriteReasoning = (content: string) => {
-          const escaped = content.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+          const escaped = JSON.stringify(content).slice(1, -1);
           streamWriter.write(`data: {"id":"${completionId}","object":"chat.completion.chunk","created":${createdTimestamp},"model":"${body.model}","choices":[{"index":0,"delta":{"reasoning_content":"${escaped}"},"logprobs":null,"finish_reason":null}]}\n\n`);
         };
 

package/src/services/playwright.ts

@@ -61,19 +61,22 @@ function getAccountHeaderCache(accountId: string): AccountHeaderCache {
   return cache;
 }
 
-const HEADERS_TTL = 60 * 60 * 1000;
+const HEADERS_TTL = 5 * 60 * 1000;
 const COOKIE_CACHE_TTL = 5 * 60 * 1000;
 const cookieCaches = new Map<string, { cookie: string, timestamp: number }>();
 const REFRESH_THRESHOLD = 0.7;
 
 const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
+export const CHROME_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36';
+export const CHROME_CLIENT_HINTS = '"Chromium";v="137", "Google Chrome";v="137", "Not/A)Brand";v="99"';
+
 function getStealthScript(): string {
   return `
+    try {
+      delete navigator.__proto__.webdriver;
+    } catch(e) {}
     Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
-    Object.defineProperty(navigator, 'plugins', {
-      get: () => [1, 2, 3, 4, 5],
-    });
     Object.defineProperty(navigator, 'languages', {
       get: () => ['pt-BR', 'pt', 'en-US', 'en'],
     });
@@ -82,32 +85,153 @@ function getStealthScript(): string {
     Object.defineProperty(navigator, 'platform', { get: () => 'Win32' });
     Object.defineProperty(screen, 'colorDepth', { get: () => 24 });
     Object.defineProperty(screen, 'pixelDepth', { get: () => 24 });
+
     window.chrome = {
-      runtime: {},
-      loadTimes: function() {},
-      csi: function() {},
-      app: {},
+      runtime: { onConnect: {}, onMessage: {} },
+      loadTimes: function() { return {}; },
+      csi: function() { return {}; },
+      app: { isInstalled: false, InstallState: { DISABLED: 'disabled', INSTALLED: 'installed', NOT_INSTALLED: 'not_installed' }, RunningState: { CANNOT_RUN: 'cannot_run', READY_TO_RUN: 'ready_to_run', RUNNING: 'running' } },
     };
+
     const originalQuery = window.navigator.permissions.query;
     window.navigator.permissions.query = (parameters) =>
       parameters.name === 'notifications'
-        ? Promise.resolve({ state: Notification.permission })
+        ? Promise.resolve({ state: (typeof Notification !== 'undefined' ? Notification.permission : 'default'), onchange: null })
         : originalQuery(parameters);
+
     const getParameter = WebGLRenderingContext.prototype.getParameter;
     WebGLRenderingContext.prototype.getParameter = function(parameter) {
       if (parameter === 37445) return 'Intel Inc.';
       if (parameter === 37446) return 'Intel Iris OpenGL Engine';
       return getParameter.apply(this, arguments);
     };
+    if (typeof WebGL2RenderingContext !== 'undefined') {
+      const getParameter2 = WebGL2RenderingContext.prototype.getParameter;
+      WebGL2RenderingContext.prototype.getParameter = function(parameter) {
+        if (parameter === 37445) return 'Intel Inc.';
+        if (parameter === 37446) return 'Intel Iris OpenGL Engine';
+        return getParameter2.apply(this, arguments);
+      };
+    }
+
     Object.defineProperty(navigator, 'connection', {
       get: () => ({
         effectiveType: '4g',
         rtt: 50,
         downlink: 10,
         saveData: false,
+        addEventListener: () => {},
+        removeEventListener: () => {},
       }),
     });
-    delete navigator.__proto__.webdriver;
+
+    (function() {
+      function makeMime(desc, suffixes, type) {
+        const m = { description: desc, suffixes: suffixes, type: type };
+        return m;
+      }
+      const pdfMime = makeMime('Portable Document Format', 'pdf', 'application/pdf');
+      const pdfxMime = makeMime('Portable Document Format', 'pdf', 'text/pdf');
+      const pdfPlugin = {
+        name: 'PDF Viewer',
+        description: 'Portable Document Format',
+        filename: 'internal-pdf-viewer',
+        length: 2,
+        0: pdfMime,
+        1: pdfxMime,
+      };
+      pdfMime.enabledPlugin = pdfPlugin;
+      pdfxMime.enabledPlugin = pdfPlugin;
+
+      const chromePdfMime = makeMime('Portable Document Format', 'pdf', 'application/pdf');
+      const chromePdfMime2 = makeMime('Portable Document Format', 'pdf', 'text/pdf');
+      const chromePdfPlugin = {
+        name: 'Chrome PDF Viewer',
+        description: 'Portable Document Format',
+        filename: 'internal-pdf-viewer',
+        length: 2,
+        0: chromePdfMime,
+        1: chromePdfMime2,
+      };
+      chromePdfMime.enabledPlugin = chromePdfPlugin;
+      chromePdfMime2.enabledPlugin = chromePdfPlugin;
+
+      const nativePlugin = {
+        name: 'Native Client',
+        description: '',
+        filename: 'internal-nacl-plugin',
+        length: 2,
+        0: makeMime('Native Client Executable', '', 'application/x-nacl'),
+        1: makeMime('Portable Native Client Executable', '', 'application/x-pnacl'),
+      };
+      nativePlugin[0].enabledPlugin = nativePlugin;
+      nativePlugin[1].enabledPlugin = nativePlugin;
+
+      const pluginsList = [pdfPlugin, chromePdfPlugin, nativePlugin];
+      const mimeList = [pdfMime, pdfxMime, chromePdfMime, chromePdfMime2, nativePlugin[0], nativePlugin[1]];
+
+      function makeNamedNodeMap(items, namedEntries) {
+        const arr = [...items];
+        for (const [k, v] of namedEntries) arr[k] = v;
+        arr.item = function(i) { return this[i] || null; };
+        arr.namedItem = function(name) { return this[name] || null; };
+        arr.refresh = function() {};
+        return arr;
+      }
+
+      const pluginEntries = pluginsList.map((p, i) => [p.name, p]);
+      const mimeEntries = mimeList.map((m) => [m.type, m]);
+
+      const pluginsArr = makeNamedNodeMap(pluginsList, pluginEntries);
+      const mimeArr = makeNamedNodeMap(mimeList, mimeEntries);
+
+      Object.defineProperty(navigator, 'plugins', { get: () => pluginsArr });
+      Object.defineProperty(navigator, 'mimeTypes', { get: () => mimeArr });
+    })();
+
+    (function() {
+      const _toDataURL = HTMLCanvasElement.prototype.toDataURL;
+      const _toBlob = HTMLCanvasElement.prototype.toBlob;
+      const _getImageData = CanvasRenderingContext2D.prototype.getImageData;
+
+      function addNoise(canvas) {
+        try {
+          const ctx = canvas.getContext('2d');
+          if (!ctx) return;
+          const style = ctx.fillStyle;
+          ctx.fillStyle = 'rgba(255,255,255,0.01)';
+          ctx.fillRect(0, 0, 1, 1);
+          ctx.fillStyle = style;
+        } catch(e) {}
+      }
+
+      HTMLCanvasElement.prototype.toDataURL = function(...args) {
+        addNoise(this);
+        return _toDataURL.apply(this, args);
+      };
+      HTMLCanvasElement.prototype.toBlob = function(...args) {
+        addNoise(this);
+        return _toBlob.apply(this, args);
+      };
+    })();
+
+    (function() {
+      if (typeof OfflineAudioContext === 'undefined') return;
+      const _startRendering = OfflineAudioContext.prototype.startRendering;
+      OfflineAudioContext.prototype.startRendering = function() {
+        return _startRendering.apply(this, arguments).then(buffer => {
+          try {
+            for (let ch = 0; ch < buffer.numberOfChannels; ch++) {
+              const data = buffer.getChannelData(ch);
+              for (let i = 0; i < Math.min(data.length, 100); i++) {
+                data[i] += (Math.random() - 0.5) * 1e-7;
+              }
+            }
+          } catch(e) {}
+          return buffer;
+        });
+      };
+    })();
   `;
 }
 
@@ -228,7 +352,7 @@ export async function initPlaywright(headless = true, browserType: BrowserType =
   context = await engine.launchPersistentContext(profilePath, {
     headless,
     channel,
-    userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
+    userAgent: CHROME_UA,
     ignoreDefaultArgs: ['--enable-automation'],
     args: [
       '--disable-blink-features=AutomationControlled',
@@ -371,7 +495,7 @@ export async function getGuestHeaders(): Promise<Record<string, string>> {
     guestContext = await engine.launchPersistentContext(profilePath, {
       headless: config.browser.headless,
       channel,
-      userAgent: 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36',
+      userAgent: CHROME_UA,
       ignoreDefaultArgs: ['--enable-automation'],
       args: ['--disable-blink-features=AutomationControlled', '--disable-features=IsolateOrigins,site-per-process', '--disable-infobars', '--no-first-run', '--no-default-browser-check']
     });
@@ -405,7 +529,7 @@ export async function getGuestHeaders(): Promise<Record<string, string>> {
         'bx-ua': reqHeaders['bx-ua'] || '',
         'bx-umidtoken': reqHeaders['bx-umidtoken'] || '',
         'bx-v': reqHeaders['bx-v'] || '2.5.36',
-        'user-agent': reqHeaders['user-agent'] || 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36',
+        'user-agent': reqHeaders['user-agent'] || CHROME_UA,
       };
       
       if (extractedHeaders['bx-ua']) {
@@ -587,7 +711,7 @@ async function _getQwenHeadersInternal(forceNew = false, accountId?: string): Pr
   const isOnQwen = currentUrl.includes('chat.qwen.ai');
   const isOnSpecificChat = isOnQwen && /\/c\//.test(currentUrl);
 
-  if (!isOnQwen || forceNew || isOnSpecificChat) {
+  if (!isOnQwen || forceNew) {
     console.log(`[Playwright] Navigating to Qwen home for ${cacheKey}... (Current: ${currentUrl})`);
     await page.goto('https://chat.qwen.ai/', { waitUntil: 'domcontentloaded' });
   }
@@ -703,9 +827,9 @@ async function _getQwenHeadersInternal(forceNew = false, accountId?: string): Pr
 
       await page.focus(inputSelector);
       await page.fill(inputSelector, '');
-      await page.type(inputSelector, 'a', { delay: 100 });
+      await page.type(inputSelector, 'a', { delay: 20 });
       console.log(`[Playwright] Typed char for ${cacheKey}, waiting for UI to update...`);
-      await sleep(2000);
+      await sleep(800);
 
       const selectors = [
         '.message-input-right-button-send .send-button',
@@ -756,7 +880,7 @@ export async function initPlaywrightForAccount(account: QwenAccount, headless =
   const acctContext = await engine.launchPersistentContext(profilePath, {
     headless,
     channel,
-    userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
+    userAgent: CHROME_UA,
     ignoreDefaultArgs: ['--enable-automation'],
     args: [
       '--disable-blink-features=AutomationControlled',
@@ -807,7 +931,7 @@ export async function launchManualLoginAccount(accountId: string, browserType: B
   const acctContext = await engine.launchPersistentContext(profilePath, {
     headless: false,
     channel,
-    userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
+    userAgent: CHROME_UA,
     ignoreDefaultArgs: ['--enable-automation'],
     args: [
       '--disable-blink-features=AutomationControlled',
@@ -890,3 +1014,234 @@ async function loginToQwenWithContext(acctContext: BrowserContext, acctPage: Pag
   console.error(`[Playwright] Login failed for ${email}:`, result.data || result.error);
   return false;
 }
+
+export function getPageForAccount(accountId?: string): Page | null {
+  if (accountId === 'guest') return guestPage;
+  if (accountId) return accountPages.get(accountId) || null;
+  return activePage;
+}
+
+const streamCallbacks = new Map<string, {
+  onChunk: (chunk: string) => void;
+  onEnd: () => void;
+  onError: (msg: string) => void;
+  onMeta: (meta: { status: number; statusText: string; contentType: string; headers: Record<string, string> }) => void;
+  onBody: (body: string) => void;
+}>();
+
+const abortControllers = new Map<string, () => void>();
+
+const pagesWithExposed = new WeakSet<Page>();
+
+async function ensureStreamBridge(page: Page): Promise<void> {
+  if (pagesWithExposed.has(page)) return;
+  pagesWithExposed.add(page);
+  await page.exposeFunction('__streamRelay', (reqId: string, type: string, data: any) => {
+    const cb = streamCallbacks.get(reqId);
+    if (!cb) return;
+    switch (type) {
+      case 'meta': cb.onMeta(data); break;
+      case 'chunk': cb.onChunk(data); break;
+      case 'end': cb.onEnd(); streamCallbacks.delete(reqId); abortControllers.delete(reqId); break;
+      case 'error': cb.onError(data); streamCallbacks.delete(reqId); abortControllers.delete(reqId); break;
+      case 'body': cb.onBody(data); streamCallbacks.delete(reqId); abortControllers.delete(reqId); break;
+    }
+  });
+}
+
+export async function browserFetch(
+  page: Page,
+  url: string,
+  options: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeoutMs?: number;
+  } = {},
+): Promise<{ status: number; statusText: string; contentType: string; body: string; headers: Record<string, string> }> {
+  await ensureStreamBridge(page);
+  const reqId = crypto.randomUUID();
+
+  return page.evaluate(async ({ url, options, reqId }: any) => {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeoutMs || 30000);
+    try {
+      const resp = await fetch(url, {
+        method: options.method || 'POST',
+        headers: options.headers || {},
+        body: options.body || undefined,
+        signal: controller.signal,
+      });
+      clearTimeout(timeoutId);
+      const respHeaders: Record<string, string> = {};
+      resp.headers.forEach((v: string, k: string) => { respHeaders[k] = v; });
+      const body = await resp.text();
+      return {
+        status: resp.status,
+        statusText: resp.statusText,
+        contentType: resp.headers.get('content-type') || '',
+        body,
+        headers: respHeaders,
+      };
+    } catch (e: any) {
+      clearTimeout(timeoutId);
+      throw new Error(`browserFetch failed: ${e.message}`);
+    }
+  }, { url, options, reqId });
+}
+
+export async function browserStreamFetch(
+  page: Page,
+  url: string,
+  options: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeoutMs?: number;
+  } = {},
+): Promise<{
+  status: number;
+  statusText: string;
+  contentType: string;
+  headers: Record<string, string>;
+  stream: ReadableStream<Uint8Array>;
+  body: string;
+  reqId: string;
+  abort: () => void;
+}> {
+  await ensureStreamBridge(page);
+  const reqId = crypto.randomUUID();
+  const enc = new TextEncoder();
+
+  let metaResolve!: (value: { status: number; statusText: string; contentType: string; headers: Record<string, string> }) => void;
+  const metaPromise = new Promise<{ status: number; statusText: string; contentType: string; headers: Record<string, string> }>((resolve) => {
+    metaResolve = resolve;
+  });
+
+  const metaTimeout = setTimeout(() => {
+    streamCallbacks.delete(reqId);
+    abortControllers.delete(reqId);
+    metaResolve({ status: 0, statusText: 'Timeout', contentType: '', headers: {} });
+  }, options.timeoutMs || 130000);
+
+  streamCallbacks.set(reqId, {
+    onMeta: (meta) => {
+      clearTimeout(metaTimeout);
+      metaResolve(meta);
+    },
+    onChunk: () => {},
+    onEnd: () => {},
+    onError: () => {},
+    onBody: () => {},
+  });
+
+  let abortFn = () => {};
+  let bodyResolve!: (value: string) => void;
+  const bodyPromise = new Promise<string>((resolve) => { bodyResolve = resolve; });
+
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      const cb = streamCallbacks.get(reqId);
+      if (!cb) return;
+      cb.onChunk = (chunk: string) => {
+        try { controller.enqueue(enc.encode(chunk)); } catch {}
+      };
+      cb.onEnd = () => {
+        try { controller.close(); } catch {}
+        streamCallbacks.delete(reqId);
+        abortControllers.delete(reqId);
+      };
+      cb.onError = (msg: string) => {
+        try { controller.error(new Error(msg)); } catch {}
+        streamCallbacks.delete(reqId);
+        abortControllers.delete(reqId);
+      };
+      cb.onBody = (text: string) => {
+        bodyResolve(text);
+        streamCallbacks.delete(reqId);
+        abortControllers.delete(reqId);
+      };
+
+      page.evaluate(async ({ url, options, reqId }: any) => {
+        const controller = new AbortController();
+        (window as any).__abortControllers = (window as any).__abortControllers || {};
+        (window as any).__abortControllers[reqId] = controller;
+        const timeoutId = setTimeout(() => controller.abort(), options.timeoutMs || 130000);
+        try {
+          const resp = await fetch(url, {
+            method: options.method || 'POST',
+            headers: options.headers || {},
+            body: options.body || undefined,
+            signal: controller.signal,
+          });
+          clearTimeout(timeoutId);
+          const respHeaders: Record<string, string> = {};
+          resp.headers.forEach((v: string, k: string) => { respHeaders[k] = v; });
+          (window as any).__streamRelay(reqId, 'meta', {
+            status: resp.status,
+            statusText: resp.statusText,
+            contentType: resp.headers.get('content-type') || '',
+            headers: respHeaders,
+          });
+
+          if (!resp.ok || !resp.body) {
+            const bodyText = await resp.text();
+            (window as any).__streamRelay(reqId, 'body', bodyText);
+            delete (window as any).__abortControllers[reqId];
+            return;
+          }
+
+          const reader = resp.body.getReader();
+          const decoder = new TextDecoder();
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              (window as any).__streamRelay(reqId, 'end', null);
+              break;
+            }
+            (window as any).__streamRelay(reqId, 'chunk', decoder.decode(value, { stream: true }));
+          }
+          delete (window as any).__abortControllers[reqId];
+        } catch (e: any) {
+          clearTimeout(timeoutId);
+          (window as any).__streamRelay(reqId, 'error', e.message);
+          delete (window as any).__abortControllers[reqId];
+        }
+      }, { url, options, reqId }).catch((e: any) => {
+        const cb = streamCallbacks.get(reqId);
+        if (cb) {
+          cb.onError(e.message);
+        }
+      });
+    },
+    cancel() {
+      page.evaluate((reqId: string) => {
+        const c = (window as any).__abortControllers?.[reqId];
+        if (c) { c.abort(); delete (window as any).__abortControllers[reqId]; }
+      }, reqId).catch(() => {});
+      streamCallbacks.delete(reqId);
+      abortControllers.delete(reqId);
+    },
+  });
+
+  const meta = await metaPromise;
+
+  abortFn = () => {
+    page.evaluate((reqId: string) => {
+      const c = (window as any).__abortControllers?.[reqId];
+      if (c) { c.abort(); delete (window as any).__abortControllers[reqId]; }
+    }, reqId).catch(() => {});
+    streamCallbacks.delete(reqId);
+    abortControllers.delete(reqId);
+  };
+
+  abortControllers.set(reqId, abortFn);
+
+  return {
+    ...meta,
+    stream,
+    body: meta.contentType.includes('text/event-stream') ? '' : await bodyPromise,
+    reqId,
+    abort: abortFn,
+  };
+}

package/src/services/qwen.ts

@@ -1,4 +1,4 @@
-import { getQwenHeaders, getBasicHeaders, getGuestHeaders } from './playwright.js';
+import { getQwenHeaders, getBasicHeaders, getGuestHeaders, getPageForAccount, browserFetch, browserStreamFetch, CHROME_CLIENT_HINTS, CHROME_UA } from './playwright.js';
 import { MAX_PAYLOAD_SIZE } from '../core/model-registry.js';
 import { markAccountRateLimited } from '../core/account-manager.js';
 import crypto from 'crypto';
@@ -11,7 +11,7 @@ const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
 
 function getClientHintsHeaders(): Record<string, string> {
   return {
-    'sec-ch-ua': '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+    'sec-ch-ua': CHROME_CLIENT_HINTS,
     'sec-ch-ua-mobile': '?0',
     'sec-ch-ua-platform': '"Windows"',
   };
@@ -86,6 +86,7 @@ const refillPromises: Map<string, Promise<void>> = new Map();
 
 const WARM_POOL_SIZE = 10;
 const WARM_POOL_TTL_MS = 10 * 60 * 1000;
+const WARM_POOL_LOW_WATER = 3;
 
 function cleanupStalePool(accountId: string) {
   const pool = warmPool.get(accountId);
@@ -106,7 +107,58 @@ async function getBasicQwenHeaders(accountId?: string): Promise<Record<string, s
   };
 }
 
-async function createRealQwenChat(header: Record<string, string>): Promise<string> {
+async function createRealQwenChat(header: Record<string, string>, accountId?: string): Promise<string> {
+  const page = getPageForAccount(accountId);
+  const body = JSON.stringify({
+    title: 'Nova Conversa',
+    models: ['qwen3.7-plus'],
+    chat_mode: 'normal',
+    chat_type: 't2t',
+    timestamp: Date.now(),
+    project_id: '',
+  });
+
+  const pageUrl = page?.url() || '';
+  const isOnQwenOrigin = pageUrl.includes('chat.qwen.ai');
+
+  if (page && !page.isClosed() && isOnQwenOrigin) {
+    try {
+      const result = await browserFetch(page, 'https://chat.qwen.ai/api/v2/chats/new', {
+        method: 'POST',
+        headers: {
+          'accept': 'application/json, text/plain, */*',
+          'content-type': 'application/json',
+          'x-request-id': crypto.randomUUID(),
+          'timezone': CACHED_TIMEZONE,
+        },
+        body,
+        timeoutMs: 30000,
+      });
+
+      if (result.status === 429) {
+        throw new QwenUpstreamError('Qwen upstream error: RateLimited: Too many requests.', 'RateLimited', 429);
+      }
+      if (!result.status || result.status >= 400) {
+        throw new Error(`Failed to create chat: ${result.status} - ${result.body}`);
+      }
+      const json = JSON.parse(result.body);
+      if (json && json.success === false) {
+        const code = json.data?.code || json.code || 'UpstreamError';
+        const details = json.data?.details || json.message || 'Qwen returned an error';
+        const wait = json.data?.num !== undefined ? ` Wait about ${json.data.num} hour(s) before trying again.` : '';
+        let status = 502;
+        if (code === 'RateLimited') status = 429;
+        throw new QwenUpstreamError(`Qwen upstream error: ${code}: ${details}.${wait}`, code, status);
+      }
+      const chatId = json.chat_id || json.id || json.data?.chat_id || json.data?.id;
+      if (!chatId) throw new Error(`Unexpected chat response: ${JSON.stringify(json).slice(0, 200)}`);
+      return chatId;
+    } catch (err: any) {
+      if (err instanceof QwenUpstreamError) throw err;
+      console.warn('[WarmPool] browserFetch failed for chat creation, falling back to Node.js fetch:', err.message);
+    }
+  }
+
   const response = await fetch('https://chat.qwen.ai/api/v2/chats/new', {
     method: 'POST',
     headers: {
@@ -123,25 +175,14 @@ async function createRealQwenChat(header: Record<string, string>): Promise<strin
       'bx-umidtoken': header['bx-umidtoken'] || '',
       ...getClientHintsHeaders(),
     },
-    body: JSON.stringify({
-      title: 'Nova Conversa',
-      models: ['qwen3.7-plus'],
-      chat_mode: 'normal',
-      chat_type: 't2t',
-      timestamp: Date.now(),
-      project_id: '',
-    }),
+    body,
     signal: AbortSignal.timeout(30000),
   });
 
   if (!response.ok) {
     const errText = await response.text().catch(() => '');
     if (response.status === 429) {
-      throw new QwenUpstreamError(
-        'Qwen upstream error: RateLimited: Too many requests.',
-        'RateLimited',
-        429
-      );
+      throw new QwenUpstreamError('Qwen upstream error: RateLimited: Too many requests.', 'RateLimited', 429);
     }
     throw new Error(`Failed to create chat: ${response.status} - ${errText}`);
   }
@@ -149,16 +190,10 @@ async function createRealQwenChat(header: Record<string, string>): Promise<strin
   if (json && json.success === false) {
     const code = json.data?.code || json.code || 'UpstreamError';
     const details = json.data?.details || json.message || 'Qwen returned an error';
-    const wait = json.data?.num !== undefined
-      ? ` Wait about ${json.data.num} hour(s) before trying again.`
-      : '';
+    const wait = json.data?.num !== undefined ? ` Wait about ${json.data.num} hour(s) before trying again.` : '';
     let status = 502;
     if (code === 'RateLimited') status = 429;
-    throw new QwenUpstreamError(
-      `Qwen upstream error: ${code}: ${details}.${wait}`,
-      code,
-      status
-    );
+    throw new QwenUpstreamError(`Qwen upstream error: ${code}: ${details}.${wait}`, code, status);
   }
   const chatId = json.chat_id || json.id || json.data?.chat_id || json.data?.id;
   if (!chatId) throw new Error(`Unexpected chat response: ${JSON.stringify(json).slice(0, 200)}`);
@@ -181,10 +216,14 @@ async function refillPoolForAccount(accountId: string) {
     return;
   }
 
-  const creationPromises = Array.from({ length: need }, async () => {
+  const acctId = accountId === 'global' ? undefined : accountId;
+  for (let i = 0; i < need; i++) {
+    if (i > 0) {
+      await sleep(800 + Math.floor(Math.random() * 2200));
+    }
     try {
-      const chatId = await createRealQwenChat(headers);
-      return { chatId, headers, accountId, timestamp: Date.now() };
+      const chatId = await createRealQwenChat(headers, acctId);
+      pool.push({ chatId, headers, accountId, timestamp: Date.now() });
     } catch (err: any) {
       if (err instanceof QwenUpstreamError) {
         if (err.upstreamCode === 'RateLimited' || err.upstreamStatus === 429) {
@@ -192,16 +231,11 @@ async function refillPoolForAccount(accountId: string) {
           const cooldownMs = hourHint ? parseInt(hourHint[1]) * 60 * 60 * 1000 : undefined;
           markAccountRateLimited(accountId, cooldownMs, 'RateLimited');
           console.warn(`[WarmPool] Account ${accountId} rate-limited during chat creation. Marked for cooldown.`);
+          break;
         }
       }
       console.error(`[WarmPool] chat creation failed for ${accountId}:`, (err as Error).message);
-      return null;
     }
-  });
-
-  const results = await Promise.all(creationPromises);
-  for (const entry of results) {
-    if (entry) pool.push(entry);
   }
 }
 
@@ -210,6 +244,11 @@ export async function getWarmedChat(accountId?: string) {
   let pool = warmPool.get(key);
   if (!pool) { pool = []; warmPool.set(key, pool); }
   cleanupStalePool(key);
+
+  if (pool.length < WARM_POOL_LOW_WATER && !refillPromises.has(key)) {
+    refillPromises.set(key, refillPoolForAccount(key).finally(() => refillPromises.delete(key)));
+  }
+
   if (pool.length === 0) {
     if (!refillPromises.has(key)) {
       refillPromises.set(key, refillPoolForAccount(key).finally(() => refillPromises.delete(key)));
@@ -304,6 +343,32 @@ export async function disableNativeTools(accountId?: string): Promise<void> {
     };
 
     console.log(`[Qwen] Disabling native tools for ${cacheKey}...`);
+    const page = getPageForAccount(accountId);
+    if (page && !page.isClosed() && page.url().includes('chat.qwen.ai')) {
+      try {
+        const result = await browserFetch(page, 'https://chat.qwen.ai/api/v2/users/user/settings/update', {
+          method: 'POST',
+          headers: {
+            'accept': 'application/json, text/plain, */*',
+            'content-type': 'application/json',
+            'x-request-id': crypto.randomUUID(),
+            'timezone': CACHED_TIMEZONE,
+          },
+          body: JSON.stringify(payload),
+          timeoutMs: 30000,
+        });
+        if (result.status && result.status < 400) {
+          console.log(`[Qwen] Native tools disabled successfully for ${cacheKey}.`);
+          nativeToolsDisabled.add(cacheKey);
+          return;
+        }
+        console.error(`[Qwen] Failed to disable native tools for ${cacheKey}: ${result.status} - ${result.body}`);
+        return;
+      } catch (err: any) {
+        console.warn('[Qwen] browserFetch failed for disableNativeTools, falling back:', err.message);
+      }
+    }
+
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 30000);
     const response = await fetch('https://chat.qwen.ai/api/v2/users/user/settings/update', {
@@ -346,6 +411,27 @@ export async function fetchQwenModels(accountId?: string): Promise<any[]> {
     return cachedModels;
   }
 
+  const page = getPageForAccount(accountId);
+  if (page && !page.isClosed() && page.url().includes('chat.qwen.ai')) {
+    try {
+      const result = await browserFetch(page, 'https://chat.qwen.ai/api/models', {
+        method: 'GET',
+        headers: {
+          'accept': 'application/json, text/plain, */*',
+          'x-request-id': crypto.randomUUID(),
+          'timezone': CACHED_TIMEZONE,
+          'source': 'web',
+        },
+        timeoutMs: 30000,
+      });
+      if (result.status && result.status < 400) {
+        return processModelsJson(JSON.parse(result.body));
+      }
+    } catch (err: any) {
+      console.warn('[Qwen] browserFetch failed for models, falling back:', err.message);
+    }
+  }
+
   const { cookie, userAgent, bxV, bxUa, bxUmidtoken } = await getBasicHeaders(accountId);
 
   const response = await fetch('https://chat.qwen.ai/api/models', {
@@ -370,6 +456,10 @@ export async function fetchQwenModels(accountId?: string): Promise<any[]> {
   }
 
   const json = await response.json();
+  return processModelsJson(json);
+}
+
+function processModelsJson(json: any): any[] {
   if (json.data && Array.isArray(json.data)) {
     const models = json.data.map((m: any) => ({
       id: m.id,
@@ -390,7 +480,7 @@ export async function fetchQwenModels(accountId?: string): Promise<any[]> {
     ];
 
     cachedModels = extendedModels;
-    lastModelsFetch = now;
+    lastModelsFetch = Date.now();
     return extendedModels;
   }
 
@@ -420,36 +510,53 @@ export async function createQwenStream(
 
   if (accountId === 'guest') {
     chatHeaders = await getGuestHeaders();
-    const response = await fetch('https://chat.qwen.ai/api/v2/chats/new', {
-      method: 'POST',
-      headers: {
-        'accept': 'application/json, text/plain, */*',
-        'accept-language': 'pt-BR,pt;q=0.9',
-        'content-type': 'application/json',
-        cookie: chatHeaders['cookie'],
-        origin: 'https://chat.qwen.ai',
-        referer: 'https://chat.qwen.ai/c/guest',
-        'user-agent': chatHeaders['user-agent'],
-        'x-request-id': crypto.randomUUID(),
-        'bx-v': chatHeaders['bx-v'],
-        'bx-ua': chatHeaders['bx-ua'],
-        'bx-umidtoken': chatHeaders['bx-umidtoken'],
-        ...getClientHintsHeaders(),
-      },
-      body: JSON.stringify({
-        title: 'Guest Chat',
-        models: [modelId.replace('-no-thinking', '')],
-        chat_mode: 'guest',
-        chat_type: 't2t',
-        timestamp: Date.now(),
-        project_id: '',
-      }),
-      signal: AbortSignal.timeout(30000),
+    const guestPage = getPageForAccount('guest');
+    const guestBody = JSON.stringify({
+      title: 'Guest Chat',
+      models: [modelId.replace('-no-thinking', '')],
+      chat_mode: 'guest',
+      chat_type: 't2t',
+      timestamp: Date.now(),
+      project_id: '',
     });
-    if (!response.ok) throw new Error(`Failed to create guest chat: ${response.status}`);
-    const json = await response.json();
-    chatId = json.chat_id || json.id || json.data?.chat_id || json.data?.id;
-    if (!chatId) throw new Error(`Unexpected guest chat response: ${JSON.stringify(json).slice(0, 200)}`);
+
+    if (guestPage && !guestPage.isClosed()) {
+      try {
+        const result = await browserFetch(guestPage, 'https://chat.qwen.ai/api/v2/chats/new', {
+          method: 'POST',
+          headers: { 'accept': 'application/json, text/plain, */*', 'content-type': 'application/json', 'x-request-id': crypto.randomUUID(), 'timezone': CACHED_TIMEZONE },
+          body: guestBody,
+          timeoutMs: 30000,
+        });
+        if (!result.status || result.status >= 400) throw new Error(`Failed to create guest chat: ${result.status}`);
+        const json = JSON.parse(result.body);
+        chatId = json.chat_id || json.id || json.data?.chat_id || json.data?.id;
+        if (!chatId) throw new Error(`Unexpected guest chat response: ${JSON.stringify(json).slice(0, 200)}`);
+      } catch (err: any) {
+        console.warn('[Qwen] browserFetch guest chat failed, falling back:', err.message);
+        const response = await fetch('https://chat.qwen.ai/api/v2/chats/new', {
+          method: 'POST',
+          headers: { 'accept': 'application/json, text/plain, */*', 'content-type': 'application/json', cookie: chatHeaders['cookie'], origin: 'https://chat.qwen.ai', referer: 'https://chat.qwen.ai/c/guest', 'user-agent': chatHeaders['user-agent'], 'x-request-id': crypto.randomUUID(), 'bx-v': chatHeaders['bx-v'], 'bx-ua': chatHeaders['bx-ua'], 'bx-umidtoken': chatHeaders['bx-umidtoken'], ...getClientHintsHeaders() },
+          body: guestBody,
+          signal: AbortSignal.timeout(30000),
+        });
+        if (!response.ok) throw new Error(`Failed to create guest chat: ${response.status}`);
+        const json = await response.json();
+        chatId = json.chat_id || json.id || json.data?.chat_id || json.data?.id;
+        if (!chatId) throw new Error(`Unexpected guest chat response: ${JSON.stringify(json).slice(0, 200)}`);
+      }
+    } else {
+      const response = await fetch('https://chat.qwen.ai/api/v2/chats/new', {
+        method: 'POST',
+        headers: { 'accept': 'application/json, text/plain, */*', 'content-type': 'application/json', cookie: chatHeaders['cookie'], origin: 'https://chat.qwen.ai', referer: 'https://chat.qwen.ai/c/guest', 'user-agent': chatHeaders['user-agent'], 'x-request-id': crypto.randomUUID(), 'bx-v': chatHeaders['bx-v'], 'bx-ua': chatHeaders['bx-ua'], 'bx-umidtoken': chatHeaders['bx-umidtoken'], ...getClientHintsHeaders() },
+        body: guestBody,
+        signal: AbortSignal.timeout(30000),
+      });
+      if (!response.ok) throw new Error(`Failed to create guest chat: ${response.status}`);
+      const json = await response.json();
+      chatId = json.chat_id || json.id || json.data?.chat_id || json.data?.id;
+      if (!chatId) throw new Error(`Unexpected guest chat response: ${JSON.stringify(json).slice(0, 200)}`);
+    }
   } else {
     let chatEntry: WarmPoolEntry;
     try {
@@ -555,6 +662,66 @@ export async function createQwenStream(
   const timeoutMs = BASE_TIMEOUT_MS + Math.ceil(payloadMB * TIMEOUT_PER_MB);
 
   const url = `https://chat.qwen.ai/api/v2/chat/completions?chat_id=${chatId}`;
+
+  const completionHeaders: Record<string, string> = {
+    'accept': 'text/event-stream',
+    'content-type': 'application/json',
+    'x-request-id': crypto.randomUUID(),
+    'timezone': CACHED_TIMEZONE,
+  };
+
+  const page = getPageForAccount(accountId);
+  if (page && !page.isClosed() && page.url().includes('chat.qwen.ai')) {
+    try {
+      const browserResult = await browserStreamFetch(page, url, {
+        method: 'POST',
+        headers: completionHeaders,
+        body: payloadJson,
+        timeoutMs,
+      });
+
+      if (browserResult.contentType.includes('text/event-stream') && browserResult.status < 400) {
+        const controller = new AbortController();
+        return { stream: browserResult.stream, headers: chatHeaders, uiSessionId: chatId, controller, accountId: accountId || 'guest' };
+      }
+
+      if (browserResult.body) {
+        const peekText = browserResult.body;
+        if (peekText.includes('FAIL_SYS_USER_VALIDATE') || peekText.includes('_____tmd_____') || peekText.includes('RGV587_ERROR')) {
+          console.warn('[Qwen] TMD challenge detected via browser, refreshing headers and retrying...');
+          try {
+            const { headers: freshHeaders } = await getQwenHeaders(true, accountId);
+            await sleep(500 + Math.floor(Math.random() * 1000));
+            const retryResult = await browserStreamFetch(page, url, {
+              method: 'POST',
+              headers: completionHeaders,
+              body: payloadJson,
+              timeoutMs,
+            });
+            if (retryResult.contentType.includes('text/event-stream') && retryResult.status < 400) {
+              const controller = new AbortController();
+              return { stream: retryResult.stream, headers: freshHeaders, uiSessionId: chatId, controller, accountId: accountId || 'guest' };
+            }
+            if (retryResult.body && (retryResult.body.includes('FAIL_SYS_USER_VALIDATE') || retryResult.body.includes('_____tmd_____'))) {
+              throw new QwenUpstreamError('Qwen TMD challenge persists after header refresh.', 'FAIL_SYS_USER_VALIDATE', 403);
+            }
+            if (retryResult.body) {
+              handleErrorBody(retryResult.body, retryResult.status);
+            }
+          } catch (retryErr) {
+            if (retryErr instanceof QwenUpstreamError) throw retryErr;
+            console.error('[Qwen] Browser TMD retry failed:', (retryErr as Error).message);
+          }
+          throw new QwenUpstreamError('Qwen TMD anti-bot challenge detected. Headers were refreshed but the challenge persists.', 'FAIL_SYS_USER_VALIDATE', 403);
+        }
+        handleErrorBody(peekText, browserResult.status);
+      }
+    } catch (browserErr: any) {
+      if (browserErr instanceof QwenUpstreamError || browserErr instanceof RetryableQwenStreamError) throw browserErr;
+      console.warn('[Qwen] Browser stream fetch failed, falling back to Node.js:', browserErr.message);
+    }
+  }
+
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
   const response = await fetch(url, {
@@ -626,34 +793,10 @@ export async function createQwenStream(
 
         const retryPeek = await retryResponse.clone().text().catch(() => '');
         if (retryPeek.includes('FAIL_SYS_USER_VALIDATE') || retryPeek.includes('_____tmd_____')) {
-          throw new QwenUpstreamError(
-            'Qwen TMD challenge persists after header refresh. The account may need manual captcha resolution.',
-            'FAIL_SYS_USER_VALIDATE',
-            403,
-          );
+          throw new QwenUpstreamError('Qwen TMD challenge persists after header refresh. The account may need manual captcha resolution.', 'FAIL_SYS_USER_VALIDATE', 403);
         }
 
         if (retryResponse.ok && retryResponse.body) {
-          try {
-            const errorJson = JSON.parse(retryPeek);
-            if (errorJson && (errorJson.success === false || errorJson.error)) {
-              const code = errorJson.data?.code || errorJson.code || 'UpstreamError';
-              const details = errorJson.data?.details || errorJson.message || errorJson.error?.message || 'Qwen returned an error';
-              const wait = errorJson.data?.num !== undefined
-                ? ` Wait about ${errorJson.data.num} hour(s) before trying again.`
-                : '';
-              let status = 502;
-              if (code === 'RateLimited') status = 429;
-              
-              throw new QwenUpstreamError(
-                `Qwen upstream error: ${code}: ${details}.${wait}`,
-                code,
-                status,
-              );
-            }
-          } catch (e) {
-            if (e instanceof QwenUpstreamError) throw e;
-          }
           return { stream: retryResponse.body, headers: freshHeaders, uiSessionId: chatId, controller: retryController, accountId: accountId || 'guest' };
         }
       } catch (retryErr) {
@@ -661,32 +804,9 @@ export async function createQwenStream(
         console.error('[Qwen] TMD retry failed:', (retryErr as Error).message);
       }
 
-      throw new QwenUpstreamError(
-        'Qwen TMD anti-bot challenge detected. Headers were refreshed but the challenge persists.',
-        'FAIL_SYS_USER_VALIDATE',
-        403,
-      );
+      throw new QwenUpstreamError('Qwen TMD anti-bot challenge detected. Headers were refreshed but the challenge persists.', 'FAIL_SYS_USER_VALIDATE', 403);
     } else {
-      try {
-        const errorJson = JSON.parse(peekText);
-        if (errorJson && (errorJson.success === false || errorJson.error)) {
-          const code = errorJson.data?.code || errorJson.code || 'UpstreamError';
-          const details = errorJson.data?.details || errorJson.message || errorJson.error?.message || 'Qwen returned an error';
-          const wait = errorJson.data?.num !== undefined
-            ? ` Wait about ${errorJson.data.num} hour(s) before trying again.`
-            : '';
-          let status = 502;
-          if (code === 'RateLimited') status = 429;
-          
-          throw new QwenUpstreamError(
-            `Qwen upstream error: ${code}: ${details}.${wait}`,
-            code,
-            status,
-          );
-        }
-      } catch (e) {
-        if (e instanceof QwenUpstreamError) throw e;
-      }
+      handleErrorBody(peekText, response.status);
     }
   }
 
@@ -695,50 +815,53 @@ export async function createQwenStream(
     const contentType = response.headers.get('content-type') || '';
 
     if (contentType.includes('application/json')) {
-      try {
-        const errorJson = JSON.parse(errText);
-        if (errorJson?.data?.details?.includes('chat is in progress') ||
-            errorJson?.data?.details?.includes('The chat is in progress')) {
-          const retryAfterMs = 2000 + Math.floor(Math.random() * 2000);
-          throw new RetryableQwenStreamError(
-            `Qwen: ${errorJson.data.details}`,
-            retryAfterMs,
-          );
-        }
-        if (errorJson?.success === false) {
-          const code = errorJson.data?.code || errorJson.code || 'UpstreamError';
-          const details = errorJson.data?.details || errorJson.message || 'Qwen returned an error';
-          const wait = errorJson.data?.num !== undefined
-            ? ` Wait about ${errorJson.data.num} hour(s) before trying again.`
-            : '';
-          let status: number;
-          if (code === 'RateLimited') status = 429;
-          else if (code === 'Not_Found') status = 404;
-          else if (code === 'UpstreamError') status = 502;
-          else status = 502;
-          throw new QwenUpstreamError(
-            `Qwen upstream error: ${code}: ${details}.${wait}`,
-            code,
-            status,
-          );
-        }
-        if (errorJson?.data?.details?.includes('is not exist') ||
-            errorJson?.data?.details?.includes('not exist') ||
-            errorJson.data?.details?.includes('does not exist')) {
-          throw new RetryableQwenStreamError(
-            `Qwen: ${errorJson.data.details}`,
-            0,
-          );
-        }
-      } catch (parseOrRetryError) {
-        if (parseOrRetryError instanceof RetryableQwenStreamError ||
-            parseOrRetryError instanceof QwenUpstreamError) {
-          throw parseOrRetryError;
-        }
-      }
+      handleJsonErrorBody(errText);
     }
     throw new Error(`Failed to fetch from Qwen: ${response.status} ${response.statusText} - ${errText}`);
   }
 
   return { stream: response.body, headers: chatHeaders, uiSessionId: chatId, controller, accountId: accountId || 'guest' };
 }
+
+function handleErrorBody(peekText: string, status: number): never {
+  try {
+    const errorJson = JSON.parse(peekText);
+    if (errorJson && (errorJson.success === false || errorJson.error)) {
+      const code = errorJson.data?.code || errorJson.code || 'UpstreamError';
+      const details = errorJson.data?.details || errorJson.message || errorJson.error?.message || 'Qwen returned an error';
+      const wait = errorJson.data?.num !== undefined ? ` Wait about ${errorJson.data.num} hour(s) before trying again.` : '';
+      let errStatus = 502;
+      if (code === 'RateLimited') errStatus = 429;
+      throw new QwenUpstreamError(`Qwen upstream error: ${code}: ${details}.${wait}`, code, errStatus);
+    }
+  } catch (e) {
+    if (e instanceof QwenUpstreamError) throw e;
+  }
+  throw new Error(`Qwen returned status ${status}: ${peekText.slice(0, 500)}`);
+}
+
+function handleJsonErrorBody(errText: string): never {
+  try {
+    const errorJson = JSON.parse(errText);
+    if (errorJson?.data?.details?.includes('chat is in progress') || errorJson?.data?.details?.includes('The chat is in progress')) {
+      const retryAfterMs = 2000 + Math.floor(Math.random() * 2000);
+      throw new RetryableQwenStreamError(`Qwen: ${errorJson.data.details}`, retryAfterMs);
+    }
+    if (errorJson?.success === false) {
+      const code = errorJson.data?.code || errorJson.code || 'UpstreamError';
+      const details = errorJson.data?.details || errorJson.message || 'Qwen returned an error';
+      const wait = errorJson.data?.num !== undefined ? ` Wait about ${errorJson.data.num} hour(s) before trying again.` : '';
+      let status: number;
+      if (code === 'RateLimited') status = 429;
+      else if (code === 'Not_Found') status = 404;
+      else status = 502;
+      throw new QwenUpstreamError(`Qwen upstream error: ${code}: ${details}.${wait}`, code, status);
+    }
+    if (errorJson?.data?.details?.includes('is not exist') || errorJson?.data?.details?.includes('not exist') || errorJson.data?.details?.includes('does not exist')) {
+      throw new RetryableQwenStreamError(`Qwen: ${errorJson.data.details}`, 0);
+    }
+  } catch (e) {
+    if (e instanceof RetryableQwenStreamError || e instanceof QwenUpstreamError) throw e;
+  }
+  throw new Error(`Qwen JSON error: ${errText.slice(0, 500)}`);
+}