@pedrofariasx/qwenproxy 1.5.0 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrofariasx/qwenproxy",
-  "version": "1.5.0",
+  "version": "1.5.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/services/playwright.ts

@@ -355,7 +355,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: 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36',
+      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'] || 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36',
+      };
+      
+      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);
 

package/src/services/qwen.ts

@@ -1,4 +1,4 @@
-import { getQwenHeaders, getBasicHeaders } from './playwright.js';
+import { getQwenHeaders, getBasicHeaders, getGuestHeaders } from './playwright.js';
 import { MAX_PAYLOAD_SIZE } from '../core/model-registry.js';
 import { markAccountRateLimited } from '../core/account-manager.js';
 import crypto from 'crypto';
@@ -415,19 +415,56 @@ 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 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),
+    });
+    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 {
+      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;
     }
-    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 +510,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: [
@@ -528,7 +565,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,7 +621,7 @@ 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(() => '');
@@ -617,7 +654,7 @@ export async function createQwenStream(
           } 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;
@@ -703,5 +740,5 @@ export async function createQwenStream(
     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' };
 }