@pedrofariasx/qwenproxy 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrofariasx/qwenproxy",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "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/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',
@@ -355,7 +479,118 @@ async function loginToQwenUI(email: string, password: string): Promise<boolean>
   return false;
 }
 
+let guestContext: BrowserContext | null = null;
+let guestPage: Page | null = null;
+let guestHeadersCache: { headers: Record<string, string>, timestamp: number } | null = null;
+const GUEST_HEADERS_TTL = 30 * 60 * 1000;
+
+export async function getGuestHeaders(): Promise<Record<string, string>> {
+  if (guestHeadersCache && (Date.now() - guestHeadersCache.timestamp) < GUEST_HEADERS_TTL) {
+    return guestHeadersCache.headers;
+  }
+
+  if (!guestPage) {
+    const profilePath = path.resolve('qwen_profiles', '_guest');
+    const { engine, channel } = resolveBrowserEngine('chromium');
+    guestContext = await engine.launchPersistentContext(profilePath, {
+      headless: config.browser.headless,
+      channel,
+      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']
+    });
+    await guestContext.addInitScript(getStealthScript());
+    guestPage = await guestContext.newPage();
+    
+    await guestPage.goto('https://chat.qwen.ai/c/guest', { waitUntil: 'domcontentloaded' });
+    
+    try {
+      const keepSessionBtn = await guestPage.$('button:has-text("Manter sessão terminada"), button:has-text("Keep session ended"), button:has-text("Manter sessão encerrada")');
+      if (keepSessionBtn) {
+        await keepSessionBtn.click();
+        console.log('[Playwright] Guest: Clicked "Manter sessão terminada"');
+        await sleep(1000);
+      }
+    } catch (e) {
+      // Modal might not be there
+    }
+  }
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error('Timeout getting guest headers')), 30000);
+    
+    const routeHandler = async (route: any, request: any) => {
+      clearTimeout(timeout);
+      const reqHeaders = request.headers();
+      console.log('[Playwright] Guest intercepted request:', request.url());
+      
+      const extractedHeaders = {
+        'cookie': reqHeaders['cookie'] || '',
+        'bx-ua': reqHeaders['bx-ua'] || '',
+        'bx-umidtoken': reqHeaders['bx-umidtoken'] || '',
+        'bx-v': reqHeaders['bx-v'] || '2.5.36',
+        'user-agent': reqHeaders['user-agent'] || CHROME_UA,
+      };
+      
+      if (extractedHeaders['bx-ua']) {
+        console.log('[Playwright] Guest: Successfully captured bx-ua');
+        guestHeadersCache = { headers: extractedHeaders, timestamp: Date.now() };
+        await route.abort('aborted');
+        await guestPage!.unroute('**/api/v2/chat/completions*', routeHandler);
+        
+        import('./qwen.js').then(m => m.disableNativeTools('guest').catch(() => {}));
+        
+        resolve(extractedHeaders);
+      } else {
+        console.log('[Playwright] Guest: Request missing bx-ua, continuing route. Headers:', Object.keys(reqHeaders));
+        await route.continue();
+        // If it's the completions request and we still don't have bx-ua, we might need to resolve anyway 
+        // or the UI interaction failed to trigger the SDK.
+        if (request.url().includes('/api/v2/chat/completions')) {
+           console.warn('[Playwright] Guest: Completions request made without bx-ua. Resolving with available headers.');
+           guestHeadersCache = { headers: extractedHeaders, timestamp: Date.now() };
+           await guestPage!.unroute('**/api/v2/chat/completions*', routeHandler);
+           resolve(extractedHeaders);
+        }
+      }
+    };
+
+    guestPage!.route('**/api/v2/chat/completions*', routeHandler).then(async () => {
+      const inputSelector = 'textarea:visible, [contenteditable="true"]:visible';
+      try {
+        await guestPage!.waitForSelector(inputSelector, { timeout: 10000 });
+        await guestPage!.focus(inputSelector);
+        await guestPage!.fill(inputSelector, '');
+        await guestPage!.type(inputSelector, 'a', { delay: 50 });
+        await sleep(1000);
+        
+        const selectors = ['.message-input-right-button-send .send-button', '.chat-prompt-send-button', 'button.send-button'];
+        let clicked = false;
+        for (const selector of selectors) {
+          const btn = await guestPage!.$(selector);
+          if (btn && await btn.isVisible()) {
+            await btn.click({ force: true, delay: 50 }).catch(() => {});
+            clicked = true;
+            break;
+          }
+        }
+        if (!clicked) {
+          await guestPage!.keyboard.press('Enter');
+        }
+      } catch (e) {
+        clearTimeout(timeout);
+        reject(e);
+      }
+    });
+  });
+}
+
 export async function getQwenHeaders(forceNew = false, accountId?: string): Promise<{ headers: Record<string, string>, chatSessionId: string, parentMessageId: string | null }> {
+  if (accountId === 'guest') {
+    const headers = await getGuestHeaders();
+    return { headers, chatSessionId: 'guest-session', parentMessageId: null };
+  }
+
   const cacheKey = accountId || 'global';
   const cache = getAccountHeaderCache(cacheKey);
 
@@ -476,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' });
   }
@@ -645,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',
@@ -696,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',
@@ -779,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 } 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"',
   };
@@ -106,7 +106,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 +174,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 +189,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 +215,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 +230,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);
   }
 }
 
@@ -304,6 +337,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 +405,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 +450,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 +474,7 @@ export async function fetchQwenModels(accountId?: string): Promise<any[]> {
     ];
 
     cachedModels = extendedModels;
-    lastModelsFetch = now;
+    lastModelsFetch = Date.now();
     return extendedModels;
   }
 
@@ -415,19 +499,73 @@ export async function createQwenStream(
   files?: QwenFileEntry[],
   pendingMultimodal?: Array<Array<{ type: string; text?: string; image_url?: { url: string }; video_url?: { url: string }; audio_url?: { url: string }; file_url?: { url: string } }>>
 ): Promise<{ stream: ReadableStream, headers: Record<string, string>, uiSessionId: string, controller: AbortController, accountId: string }> {
-  let chatEntry: WarmPoolEntry;
-  try {
-    chatEntry = await getWarmedChat(accountId);
-  } catch (err: any) {
-    if (err.message?.includes('chat is in progress') || err.message?.includes('The chat is in progress')) {
-      const retryAfterMs = 2000 + Math.floor(Math.random() * 2000);
-      throw new RetryableQwenStreamError(`Qwen: ${err.message}`, retryAfterMs);
+  let chatId: string;
+  let chatHeaders: Record<string, string>;
+
+  if (accountId === 'guest') {
+    chatHeaders = await getGuestHeaders();
+    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 (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)}`);
     }
-    throw err;
+  } else {
+    let chatEntry: WarmPoolEntry;
+    try {
+      chatEntry = await getWarmedChat(accountId);
+    } catch (err: any) {
+      if (err.message?.includes('chat is in progress') || err.message?.includes('The chat is in progress')) {
+        const retryAfterMs = 2000 + Math.floor(Math.random() * 2000);
+        throw new RetryableQwenStreamError(`Qwen: ${err.message}`, retryAfterMs);
+      }
+      throw err;
+    }
+    chatId = chatEntry.chatId;
+    chatHeaders = chatEntry.headers;
   }
 
-  const chatId = chatEntry.chatId;
-  const chatHeaders = chatEntry.headers;
   const actualParentId: string | null = null;
 
   // Process pending multimodal uploads — requires full headers with bx-ua/bx-umidtoken
@@ -473,7 +611,7 @@ export async function createQwenStream(
     version: '2.1',
     incremental_output: true,
     chat_id: chatId,
-    chat_mode: 'normal',
+    chat_mode: accountId === 'guest' ? 'guest' : 'normal',
     model: model,
     parent_id: actualParentId,
     messages: [
@@ -518,6 +656,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, {
@@ -528,7 +726,7 @@ export async function createQwenStream(
       'content-type': 'application/json',
       'cookie': chatHeaders['cookie'],
       'origin': 'https://chat.qwen.ai',
-      'referer': `https://chat.qwen.ai/c/${chatId}`,
+      'referer': accountId === 'guest' ? 'https://chat.qwen.ai/c/guest' : `https://chat.qwen.ai/c/${chatId}`,
       'sec-fetch-dest': 'empty',
       'sec-fetch-mode': 'cors',
       'sec-fetch-site': 'same-origin',
@@ -584,72 +782,25 @@ export async function createQwenStream(
 
         const retryContentType = retryResponse.headers.get('content-type') || '';
         if (retryResponse.ok && retryContentType.includes('text/event-stream') && retryResponse.body) {
-          return { stream: retryResponse.body, headers: freshHeaders, uiSessionId: chatId, controller: retryController, accountId: chatEntry.accountId };
+          return { stream: retryResponse.body, headers: freshHeaders, uiSessionId: chatId, controller: retryController, accountId: accountId || 'guest' };
         }
 
         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: chatEntry.accountId };
+          return { stream: retryResponse.body, headers: freshHeaders, uiSessionId: chatId, controller: retryController, accountId: accountId || 'guest' };
         }
       } catch (retryErr) {
         if (retryErr instanceof QwenUpstreamError) throw retryErr;
         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);
     }
   }
 
@@ -658,50 +809,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: chatEntry.accountId };
+  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)}`);
 }