@pedrofariasx/qwenproxy 1.4.0 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrofariasx/qwenproxy",
-  "version": "1.4.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/routes/chat.ts

@@ -272,48 +272,75 @@ export async function chatCompletions(c: Context) {
     const isNewSession = !messages.some(m => m.role === 'assistant');
 
     // Account selection with fallback on rate-limit/failure
-    let account = getNextAccount();
-    const triedAccountIds = new Set<string>();
-    let lastError: any = null;
-
+    const isGuestModeOnly = process.env.QWEN_GUEST_MODE_ONLY?.toLowerCase() === 'true';
     let stream: ReadableStream | undefined;
     let uiSessionId = '';
     const completionId = 'chatcmpl-' + crypto.randomUUID();
+    let lastError: any = null;
 
-    while (account) {
-      const accountId = account.id;
-      const accountEmail = account.email;
-
-      if (triedAccountIds.has(accountId)) {
-        account = getNextAvailableAccount(triedAccountIds);
-        continue;
+    if (isGuestModeOnly) {
+      console.log('[Chat] Guest mode only enabled. Bypassing account rotation.');
+      try {
+        const result = await createQwenStream(
+          finalPrompt,
+          isThinkingModel,
+          body.model,
+          null,
+          'guest',
+          undefined,
+          pendingMultimodal.length > 0 ? pendingMultimodal : undefined
+        );
+        stream = result.stream;
+        uiSessionId = result.uiSessionId;
+        registerStream(completionId, {
+          abortController: result.controller,
+          accountId: 'guest',
+          uiSessionId: result.uiSessionId,
+          targetResponseId: '',
+          headers: result.headers,
+        });
+      } catch (err: any) {
+        console.error('[Chat] Guest mode failed:', err.message);
+        throw err;
       }
-      triedAccountIds.add(accountId);
+    } else {
+      let account = getNextAccount();
+      const triedAccountIds = new Set<string>();
 
-      const cooldownInfo = getAccountCooldownInfo(accountId);
-      if (cooldownInfo && accountId !== 'global') {
-        console.log(`[Chat] Skipping account ${accountEmail} (${accountId}) — on cooldown for ${Math.round(cooldownInfo.remainingMs / 1000)}s (${cooldownInfo.reason})`);
-        account = getNextAvailableAccount(triedAccountIds);
-        continue;
-      }
+      while (account) {
+        const accountId = account.id;
+        const accountEmail = account.email;
 
-      console.log(`[Chat] Routing request to account: ${accountEmail} (${accountId})`);
+        if (triedAccountIds.has(accountId)) {
+          account = getNextAvailableAccount(triedAccountIds);
+          continue;
+        }
+        triedAccountIds.add(accountId);
 
-      let retries = 3;
-      let retryDelay = 500;
-      let success = false;
+        const cooldownInfo = getAccountCooldownInfo(accountId);
+        if (cooldownInfo && accountId !== 'global') {
+          console.log(`[Chat] Skipping account ${accountEmail} (${accountId}) — on cooldown for ${Math.round(cooldownInfo.remainingMs / 1000)}s (${cooldownInfo.reason})`);
+          account = getNextAvailableAccount(triedAccountIds);
+          continue;
+        }
 
-      while (retries > 0) {
-        try {
-          const result = await createQwenStream(
-            finalPrompt,
-            isThinkingModel,
-            body.model,
-            null, // Always force new chat for concurrency isolation
-            accountId === 'global' ? undefined : accountId,
-            undefined,
-            pendingMultimodal.length > 0 ? pendingMultimodal : undefined
-          );
+        console.log(`[Chat] Routing request to account: ${accountEmail} (${accountId})`);
+
+        let retries = 3;
+        let retryDelay = 500;
+        let success = false;
+
+        while (retries > 0) {
+          try {
+            const result = await createQwenStream(
+              finalPrompt,
+              isThinkingModel,
+              body.model,
+              null, // Always force new chat for concurrency isolation
+              accountId === 'global' ? undefined : accountId,
+              undefined,
+              pendingMultimodal.length > 0 ? pendingMultimodal : undefined
+            );
             stream = result.stream;
             uiSessionId = result.uiSessionId;
             registerStream(completionId, {
@@ -325,59 +352,84 @@ export async function chatCompletions(c: Context) {
             });
             success = true;
             break;
-        } catch (err: any) {
-          retries--;
-
-          if (err.upstreamCode === 'RateLimited' || err.upstreamStatus === 429) {
-            const hourHint = err.message?.match(/Wait about (\d+) hour/);
-            const hours = hourHint ? parseInt(hourHint[1]) : 24;
-            const cooldownMs = hours * 60 * 60 * 1000;
-            markAccountRateLimited(accountId, cooldownMs, 'RateLimited');
-            console.warn(`[Chat] Account ${accountEmail} (${accountId}) rate-limited. Entering cooldown for ${hours} hours.`);
-            lastError = err;
-            break;
-          }
+          } catch (err: any) {
+            retries--;
+
+            if (err.upstreamCode === 'RateLimited' || err.upstreamStatus === 429) {
+              const hourHint = err.message?.match(/Wait about (\d+) hour/);
+              const hours = hourHint ? parseInt(hourHint[1]) : 24;
+              const cooldownMs = hours * 60 * 60 * 1000;
+              markAccountRateLimited(accountId, cooldownMs, 'RateLimited');
+              console.warn(`[Chat] Account ${accountEmail} (${accountId}) rate-limited. Entering cooldown for ${hours} hours.`);
+              lastError = err;
+              break;
+            }
 
-          if (retries === 0) {
-            if (err.upstreamStatus && err.upstreamStatus >= 500) {
-              markAccountRateLimited(accountId, undefined, 'ServerError');
-              console.warn(`[Chat] Account ${accountEmail} (${accountId}) returned server error. Marked for cooldown.`);
+            if (retries === 0) {
+              if (err.upstreamStatus && err.upstreamStatus >= 500) {
+                markAccountRateLimited(accountId, undefined, 'ServerError');
+                console.warn(`[Chat] Account ${accountEmail} (${accountId}) returned server error. Marked for cooldown.`);
+              }
+              lastError = err;
+              break;
             }
-            lastError = err;
-            break;
-          }
 
-          let useDelay = retryDelay;
-          if (err instanceof RetryableQwenStreamError && err.retryAfterMs !== undefined) {
-            useDelay = err.retryAfterMs;
-          }
-          const isRetryable = err instanceof RetryableQwenStreamError || err.message?.includes('in progress') || err.message?.includes('Bad_Request');
-          if (!isRetryable) {
-            lastError = err;
-            break;
+            let useDelay = retryDelay;
+            if (err instanceof RetryableQwenStreamError && err.retryAfterMs !== undefined) {
+              useDelay = err.retryAfterMs;
+            }
+            const isRetryable = err instanceof RetryableQwenStreamError || err.message?.includes('in progress') || err.message?.includes('Bad_Request');
+            if (!isRetryable) {
+              lastError = err;
+              break;
+            }
+            console.warn(`[Chat] Qwen request failed for ${accountEmail}, retrying in ${useDelay}ms... (${retries} left)`);
+            await new Promise(r => setTimeout(r, useDelay));
+            retryDelay = Math.min(retryDelay * 2, 5000);
           }
-          console.warn(`[Chat] Qwen request failed for ${accountEmail}, retrying in ${useDelay}ms... (${retries} left)`);
-          await new Promise(r => setTimeout(r, useDelay));
-          retryDelay = Math.min(retryDelay * 2, 5000);
         }
-      }
 
-      if (success) {
-        break;
-      }
+        if (success) {
+          break;
+        }
 
-      account = getNextAvailableAccount(triedAccountIds);
+        account = getNextAvailableAccount(triedAccountIds);
+      }
     }
 
     if (!stream) {
       removeStream(completionId);
-      // Check if all accounts are on cooldown
       const accounts = loadAccounts();
-      const allOnCooldown = accounts.every(a => getAccountCooldownInfo(a.id) !== null);
+      const allOnCooldown = accounts.length === 0 || accounts.every(a => getAccountCooldownInfo(a.id) !== null);
+      
       if (allOnCooldown) {
-        console.warn(`[Chat] CRITICAL: All ${accounts.length} accounts are currently rate-limited or on cooldown!`);
+        console.warn(`[Chat] CRITICAL: All accounts are rate-limited, on cooldown, or none configured! Falling back to GUEST mode.`);
+        try {
+          const result = await createQwenStream(
+            finalPrompt,
+            isThinkingModel,
+            body.model,
+            null,
+            'guest',
+            undefined,
+            pendingMultimodal.length > 0 ? pendingMultimodal : undefined
+          );
+          stream = result.stream;
+          uiSessionId = result.uiSessionId;
+          registerStream(completionId, {
+            abortController: result.controller,
+            accountId: 'guest',
+            uiSessionId: result.uiSessionId,
+            targetResponseId: '',
+            headers: result.headers,
+          });
+        } catch (guestErr: any) {
+          console.error('[Chat] Guest mode also failed:', guestErr.message);
+          throw lastError || new Error('All accounts and guest mode failed');
+        }
+      } else {
+        throw lastError || new Error('All accounts failed');
       }
-      throw lastError || new Error('All accounts failed');
     }
 
     if (!isStream) {

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' };
 }