@pedrofariasx/qwenproxy 1.3.3 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrofariasx/qwenproxy",
-  "version": "1.3.3",
+  "version": "1.5.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/core/account-manager.ts

@@ -1,4 +1,4 @@
-import { QwenAccount, loadAccounts } from './accounts.js'
+import { QwenAccount, loadAccounts, updateAccountCooldown } from './accounts.js'
 import { config } from './config.js'
 
 let currentIndex = 0
@@ -21,6 +21,20 @@ function getCachedAccounts(): QwenAccount[] {
   if (!accountsCache || (now - accountsCacheTimestamp) > ACCOUNTS_CACHE_TTL) {
     accountsCache = loadAccounts()
     accountsCacheTimestamp = now
+
+    // Sync memory cooldowns map from database values
+    for (const account of accountsCache) {
+      if (account.cooldown_until && account.cooldown_until > now) {
+        cooldowns.set(account.id, {
+          until: account.cooldown_until,
+          reason: account.cooldown_reason || 'RateLimited',
+        })
+      } else {
+        if (cooldowns.has(account.id)) {
+          cooldowns.delete(account.id)
+        }
+      }
+    }
   }
   return accountsCache
 }
@@ -31,15 +45,35 @@ export function invalidateAccountsCache(): void {
 }
 
 export function markAccountRateLimited(accountId: string, cooldownMs?: number, reason?: string): void {
+  const duration = cooldownMs ?? DEFAULT_COOLDOWN_MS
+  const until = Date.now() + duration
+  const cooldownReason = reason ?? 'RateLimited'
+
   cooldowns.set(accountId, {
-    until: Date.now() + (cooldownMs ?? DEFAULT_COOLDOWN_MS),
-    reason: reason ?? 'RateLimited',
+    until,
+    reason: cooldownReason,
   })
-  console.log(`[AccountManager] Account ${accountId} marked as rate-limited. Cooldown until ${new Date(Date.now() + (cooldownMs ?? DEFAULT_COOLDOWN_MS)).toISOString()}`)
+
+  if (accountId !== 'global') {
+    try {
+      updateAccountCooldown(accountId, until, cooldownReason)
+    } catch (err) {
+      console.error(`[AccountManager] Failed to save cooldown to DB for account ${accountId}:`, (err as Error).message)
+    }
+  }
+
+  console.log(`[AccountManager] Account ${accountId} marked as rate-limited. Cooldown until ${new Date(until).toISOString()}`)
 }
 
 export function clearAccountCooldown(accountId: string): void {
   cooldowns.delete(accountId)
+  if (accountId !== 'global') {
+    try {
+      updateAccountCooldown(accountId, 0, null)
+    } catch (err) {
+      console.error(`[AccountManager] Failed to clear cooldown in DB for account ${accountId}:`, (err as Error).message)
+    }
+  }
 }
 
 export function getAccountCooldownInfo(accountId: string): { onCooldown: boolean; remainingMs: number; reason: string } | null {
@@ -48,6 +82,13 @@ export function getAccountCooldownInfo(accountId: string): { onCooldown: boolean
   const remaining = entry.until - Date.now()
   if (remaining <= 0) {
     cooldowns.delete(accountId)
+    if (accountId !== 'global') {
+      try {
+        updateAccountCooldown(accountId, 0, null)
+      } catch (err) {
+        console.error(`[AccountManager] Failed to clear expired cooldown in DB:`, (err as Error).message)
+      }
+    }
     return null
   }
   return { onCooldown: true, remainingMs: remaining, reason: entry.reason }
@@ -88,25 +129,33 @@ export function getNextAccount(forceReset?: boolean): QwenAccount | null {
   return best
 }
 
-export function getNextAvailableAccount(skipAccountId?: string): QwenAccount | null {
+export function getNextAvailableAccount(triedAccountIds?: Set<string> | string): QwenAccount | null {
   const accounts = getCachedAccounts()
   if (accounts.length === 0) return null
 
+  let triedSet: Set<string>
+  if (triedAccountIds instanceof Set) {
+    triedSet = triedAccountIds
+  } else {
+    triedSet = new Set(triedAccountIds ? [triedAccountIds] : [])
+  }
+
+  // 1. Try to find an untried account that is NOT on cooldown
   for (let i = 0; i < accounts.length; i++) {
     const idx = (currentIndex + i) % accounts.length
     const account = accounts[idx]
-    if (skipAccountId && account.id === skipAccountId) continue
+    if (triedSet.has(account.id)) continue
     if (!isAccountOnCooldown(account.id)) {
       currentIndex = (idx + 1) % accounts.length
       return account
     }
   }
 
-  // All remaining accounts on cooldown — return the one with shortest cooldown
+  // 2. If all untried accounts are on cooldown, return the untried one with the shortest remaining cooldown
   let best: QwenAccount | null = null
   let bestRemaining = Infinity
   for (const account of accounts) {
-    if (skipAccountId && account.id === skipAccountId) continue
+    if (triedSet.has(account.id)) continue
     const info = getAccountCooldownInfo(account.id)
     if (info && info.remainingMs < bestRemaining) {
       bestRemaining = info.remainingMs

package/src/core/accounts.ts

@@ -6,6 +6,8 @@ export interface QwenAccount {
   id: string
   email: string
   password: string
+  cooldown_until?: number
+  cooldown_reason?: string | null
 }
 
 let accountsCache: QwenAccount[] | null = null
@@ -16,7 +18,7 @@ function getCachedAccounts(): QwenAccount[] {
   const now = Date.now()
   if (!accountsCache || (now - accountsCacheTimestamp) > ACCOUNTS_CACHE_TTL) {
     const db = getDatabase()
-    accountsCache = db.prepare('SELECT id, email, password FROM accounts ORDER BY created_at ASC').all() as QwenAccount[]
+    accountsCache = db.prepare('SELECT id, email, password, cooldown_until, cooldown_reason FROM accounts ORDER BY created_at ASC').all() as QwenAccount[]
     accountsCacheTimestamp = now
   }
   return accountsCache
@@ -73,6 +75,12 @@ export function listAccounts(): QwenAccount[] {
 
 export function getAccountCredentials(id: string): QwenAccount | undefined {
   const db = getDatabase()
-  const row = db.prepare('SELECT id, email, password FROM accounts WHERE id = ?').get(id)
+  const row = db.prepare('SELECT id, email, password, cooldown_until, cooldown_reason FROM accounts WHERE id = ?').get(id)
   return row as QwenAccount | undefined
 }
+
+export function updateAccountCooldown(id: string, cooldownUntil: number, reason: string | null): void {
+  const db = getDatabase()
+  db.prepare('UPDATE accounts SET cooldown_until = ?, cooldown_reason = ? WHERE id = ?').run(cooldownUntil, reason, id)
+  invalidateAccountsCache()
+}

package/src/core/database.ts

@@ -42,6 +42,18 @@ function runMigrations(db: Database.Database): void {
 
     CREATE INDEX IF NOT EXISTS idx_accounts_email ON accounts(email);
   `)
+
+  // Add cooldown columns if they don't exist
+  try {
+    db.exec(`ALTER TABLE accounts ADD COLUMN cooldown_until INTEGER DEFAULT 0;`)
+  } catch (err) {
+    // Column already exists or error
+  }
+  try {
+    db.exec(`ALTER TABLE accounts ADD COLUMN cooldown_reason TEXT;`)
+  } catch (err) {
+    // Column already exists or error
+  }
 }
 
 /**

package/src/core/model-registry.ts

@@ -25,45 +25,47 @@ const modelContextWindows: Record<string, number> = {
 }
 
 const modelTokenDivisors: Record<string, number> = {
-  'qwen3.7-max': 2.2,
-  'qwen3.6-max-preview': 2.2,
-  'qwen3.5-max-2026-03-08': 2.2,
-  'qwen3-max-2026-01-23': 2.2,
-  'qwen-latest-series-invite-beta-v24': 2.2,
-  'qwen3.7-plus': 2.0,
-  'qwen3.6-plus': 2.0,
-  'qwen3.6-plus-preview': 2.0,
-  'qwen3.5-plus': 2.0,
-  'qwen-plus-2025-07-28': 2.0,
-  'qwen-latest-series-invite-beta-v16': 2.0,
-  'qwen3.5-flash': 1.8,
-  'qwen3.5-omni-plus': 1.8,
-  'qwen3.5-omni-flash': 1.7,
-  'qwen3-omni-flash-2025-12-01': 1.7,
-  'qwen3.5-397b-a17b': 1.9,
-  'qwen3.5-122b-a10b': 1.9,
-  'qwen3.6-35b-a3b': 1.9,
-  'qwen3.5-35b-a3b': 1.9,
-  'qwen3.6-27b': 1.9,
-  'qwen3.5-27b': 1.9,
-  'qwen3-coder-plus': 2.3,
-  'qwen3-vl-plus': 2.1,
+  'qwen3.7-max': 3.5,
+  'qwen3.6-max-preview': 3.5,
+  'qwen3.5-max-2026-03-08': 3.5,
+  'qwen3-max-2026-01-23': 3.5,
+  'qwen-latest-series-invite-beta-v24': 3.5,
+  'qwen3.7-plus': 3.5,
+  'qwen3.6-plus': 3.5,
+  'qwen3.6-plus-preview': 3.5,
+  'qwen3.5-plus': 3.5,
+  'qwen-plus-2025-07-28': 3.5,
+  'qwen-latest-series-invite-beta-v16': 3.5,
+  'qwen3.5-flash': 3.2,
+  'qwen3.5-omni-plus': 3.0,
+  'qwen3.5-omni-flash': 3.0,
+  'qwen3-omni-flash-2025-12-01': 3.0,
+  'qwen3.5-397b-a17b': 3.2,
+  'qwen3.5-122b-a10b': 3.2,
+  'qwen3.6-35b-a3b': 3.2,
+  'qwen3.5-35b-a3b': 3.2,
+  'qwen3.6-27b': 3.2,
+  'qwen3.5-27b': 3.2,
+  'qwen3-coder-plus': 3.8,
+  'qwen3-vl-plus': 3.5,
 }
 
 const defaultContextWindow = 131072
-const defaultTokenDivisor = 2.0
-export const MAX_PAYLOAD_SIZE = 10 * 1024 * 1024
+const defaultTokenDivisor = 3.5
+export const MAX_PAYLOAD_SIZE = 50 * 1024 * 1024
 
 export function setModelContextWindow(modelId: string, contextWindow: number): void {
   modelContextWindows[modelId] = contextWindow
 }
 
-export function getModelContextWindow(modelId: string): number {
+export function getModelContextWindow(modelId?: string): number {
+  if (!modelId) return defaultContextWindow
   const baseId = modelId.replace('-no-thinking', '')
   return modelContextWindows[baseId] ?? defaultContextWindow
 }
 
-export function getModelTokenDivisor(modelId: string): number {
+export function getModelTokenDivisor(modelId?: string): number {
+  if (!modelId) return defaultTokenDivisor
   const baseId = modelId.replace('-no-thinking', '')
   return modelTokenDivisors[baseId] ?? defaultTokenDivisor
 }

package/src/routes/chat.ts

@@ -21,6 +21,7 @@ import { QwenStreamParser, ParsedChunkResult } from '../utils/qwen-stream-parser
 import { getModelContextWindow } from '../core/model-registry.js'
 import { truncateMessages, estimateTokenCount } from '../utils/context-truncation.js';
 import { getNextAccount, getNextAvailableAccount, markAccountRateLimited, getAccountCooldownInfo } from '../core/account-manager.js';
+import { loadAccounts } from '../core/accounts.js';
 import { registerStream, removeStream, getStream } from '../core/stream-registry.js';
 import { metrics } from '../core/metrics.js'
 
@@ -271,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(accountId);
-        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(accountId);
-        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, {
@@ -324,52 +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 cooldownMs = hourHint ? parseInt(hourHint[1]) * 60 * 60 * 1000 : undefined;
-            markAccountRateLimited(accountId, cooldownMs, 'RateLimited');
-            console.warn(`[Chat] Account ${accountEmail} (${accountId}) rate-limited. Marked for cooldown.`);
-            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(accountId);
+        account = getNextAvailableAccount(triedAccountIds);
+      }
     }
 
     if (!stream) {
       removeStream(completionId);
-      throw lastError || new Error('All accounts failed');
+      const accounts = loadAccounts();
+      const allOnCooldown = accounts.length === 0 || accounts.every(a => getAccountCooldownInfo(a.id) !== null);
+      
+      if (allOnCooldown) {
+        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');
+      }
     }
 
     if (!isStream) {

package/src/services/playwright.ts

@@ -188,9 +188,28 @@ export async function getBasicHeaders(accountId?: string): Promise<{ cookie: str
   }
   
   const cache = getAccountHeaderCache(cacheKey);
+  let bxUa = cache.currentHeaders['bx-ua'];
+  let bxUmidtoken = cache.currentHeaders['bx-umidtoken'];
   const bxV = cache.currentHeaders['bx-v'] || '2.5.36';
-  const bxUa = cache.currentHeaders['bx-ua'];
-  const bxUmidtoken = cache.currentHeaders['bx-umidtoken'];
+  
+  // Auto-recover missing anti-fraud headers by triggering full header interception
+  if (!bxUa || !bxUmidtoken) {
+    console.log(`[Playwright] Missing bx-ua/bx-umidtoken for ${cacheKey}, triggering header interception...`);
+    try {
+      const result = await getQwenHeaders(true, accountId);
+      bxUa = result.headers['bx-ua'];
+      bxUmidtoken = result.headers['bx-umidtoken'];
+      return {
+        cookie: await getCookies(accountId),
+        userAgent,
+        bxV: result.headers['bx-v'] || bxV,
+        bxUa,
+        bxUmidtoken,
+      };
+    } catch (err: any) {
+      console.warn(`[Playwright] Failed to auto-recover headers for ${cacheKey}: ${err.message}`);
+    }
+  }
   
   return { cookie, userAgent, bxV, bxUa, bxUmidtoken };
 }
@@ -649,6 +668,25 @@ export async function initPlaywrightForAccount(account: QwenAccount, headless =
   if (!hasAuthCookie && account.email && account.password) {
     await loginToQwenWithContext(acctContext, acctPage, account.email, account.password);
   }
+
+  // Navigate to Qwen home to validate session and populate cookies
+  try {
+    await acctPage.goto('https://chat.qwen.ai/', { waitUntil: 'domcontentloaded', timeout: 15000 });
+    const url = acctPage.url();
+    if (url.includes('auth') || url.includes('login')) {
+      if (account.email && account.password) {
+        console.log(`[Playwright] Session expired for ${account.email}, re-logging in...`);
+        await loginToQwenWithContext(acctContext, acctPage, account.email, account.password);
+        await acctPage.goto('https://chat.qwen.ai/', { waitUntil: 'domcontentloaded', timeout: 15000 });
+      } else {
+        console.warn(`[Playwright] Session expired for account ${account.id} but no credentials available for re-login.`);
+      }
+    } else {
+      console.log(`[Playwright] Session validated for ${account.email}.`);
+    }
+  } catch (err: any) {
+    console.warn(`[Playwright] Failed to validate session for ${account.email}: ${err.message}`);
+  }
 }
 
 export async function launchManualLoginAccount(accountId: string, browserType: BrowserType = 'chromium'): Promise<{ context: BrowserContext, page: Page }> {

package/src/services/qwen.ts

@@ -1,5 +1,6 @@
 import { getQwenHeaders, getBasicHeaders } from './playwright.js';
 import { MAX_PAYLOAD_SIZE } from '../core/model-registry.js';
+import { markAccountRateLimited } from '../core/account-manager.js';
 import crypto from 'crypto';
 
 const CACHED_TIMEZONE = new Date().toString().split(' (')[0];
@@ -133,8 +134,32 @@ async function createRealQwenChat(header: Record<string, string>): Promise<strin
     signal: AbortSignal.timeout(30000),
   });
 
-  if (!response.ok) throw new Error(`Failed to create chat: ${response.status}`);
+  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 Error(`Failed to create chat: ${response.status} - ${errText}`);
+  }
   const json = await response.json();
+  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;
@@ -160,7 +185,15 @@ async function refillPoolForAccount(accountId: string) {
     try {
       const chatId = await createRealQwenChat(headers);
       return { chatId, headers, accountId, timestamp: Date.now() };
-    } catch (err) {
+    } catch (err: any) {
+      if (err instanceof QwenUpstreamError) {
+        if (err.upstreamCode === 'RateLimited' || err.upstreamStatus === 429) {
+          const hourHint = err.message?.match(/Wait about (\d+) hour/);
+          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.`);
+        }
+      }
       console.error(`[WarmPool] chat creation failed for ${accountId}:`, (err as Error).message);
       return null;
     }
@@ -564,6 +597,26 @@ export async function createQwenStream(
         }
 
         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 };
         }
       } catch (retryErr) {
@@ -576,6 +629,27 @@ export async function createQwenStream(
         '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;
+      }
     }
   }
 

package/src/tests/contextTruncation.test.ts

@@ -6,20 +6,20 @@ test('estimateTokenCount: returns 0 for empty string', () => {
   assert.strictEqual(estimateTokenCount(''), 0);
 });
 
-test('estimateTokenCount: estimates tokens conservatively using 2.5 divisor', () => {
+test('estimateTokenCount: estimates tokens conservatively using default divisor', () => {
   assert.strictEqual(estimateTokenCount('hello'), 2);
-  assert.strictEqual(estimateTokenCount('a'.repeat(100)), 40);
-  assert.strictEqual(estimateTokenCount('a'.repeat(250)), 100);
-  assert.strictEqual(estimateTokenCount('a'.repeat(2500)), 1000);
+  assert.strictEqual(estimateTokenCount('a'.repeat(100)), 29);
+  assert.strictEqual(estimateTokenCount('a'.repeat(250)), 72);
+  assert.strictEqual(estimateTokenCount('a'.repeat(2500)), 715);
 });
 
 test('estimateTokenCount: handles single character', () => {
   assert.strictEqual(estimateTokenCount('x'), 1);
 });
 
-test('estimateTokenCount: rounds up for non-multiples of 2.5', () => {
+test('estimateTokenCount: rounds up for non-multiples of default divisor', () => {
   assert.strictEqual(estimateTokenCount('ab'), 1);
-  assert.strictEqual(estimateTokenCount('abc'), 2);
+  assert.strictEqual(estimateTokenCount('abc'), 1);
   assert.strictEqual(estimateTokenCount('abcd'), 2);
 });
 

package/src/tests/rotation.test.ts

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert';
-import { getNextAccount, invalidateAccountsCache } from '../core/account-manager.ts';
+import { getNextAccount, getNextAvailableAccount, markAccountRateLimited, clearAccountCooldown, invalidateAccountsCache } from '../core/account-manager.ts';
 import { addAccount, removeAccount, loadAccounts } from '../core/accounts.ts';
 
 test('Account Rotation: Round-Robin rotation cycle', async () => {
@@ -29,10 +29,15 @@ test('Account Rotation: Round-Robin rotation cycle', async () => {
     assert.ok(third);
     assert.ok(fourth);
 
-    assert.strictEqual(first.email, 'account1@test.com');
-    assert.strictEqual(second.email, 'account2@test.com');
-    assert.strictEqual(third.email, 'account3@test.com');
-    assert.strictEqual(fourth.email, 'account1@test.com');
+    const allAccounts = loadAccounts();
+    const firstIdx = allAccounts.findIndex(a => a.id === first.id);
+    const secondIdx = allAccounts.findIndex(a => a.id === second.id);
+    const thirdIdx = allAccounts.findIndex(a => a.id === third.id);
+    const fourthIdx = allAccounts.findIndex(a => a.id === fourth.id);
+
+    assert.strictEqual(secondIdx, (firstIdx + 1) % allAccounts.length);
+    assert.strictEqual(thirdIdx, (secondIdx + 1) % allAccounts.length);
+    assert.strictEqual(fourthIdx, (thirdIdx + 1) % allAccounts.length);
   } finally {
     const current = loadAccounts();
     for (const acc of current) {
@@ -43,3 +48,57 @@ test('Account Rotation: Round-Robin rotation cycle', async () => {
     invalidateAccountsCache();
   }
 });
+
+test('Account Cooldown: Database persistence and recovery', async () => {
+  const email = 'cooldown-test@test.com';
+  let accountId = '';
+
+  try {
+    const newAcct = addAccount(email, 'password123');
+    accountId = newAcct.id;
+    invalidateAccountsCache();
+
+    // Mark as rate-limited with a 1-hour cooldown
+    const cooldownMs = 60 * 60 * 1000;
+    markAccountRateLimited(accountId, cooldownMs, 'RateLimited');
+
+    // Force reloading accounts from DB (simulating restart)
+    invalidateAccountsCache();
+
+    // Check if the loaded account has the cooldown synced from DB
+    const loadedAccounts = loadAccounts();
+    const target = loadedAccounts.find(a => a.id === accountId);
+    assert.ok(target);
+    assert.ok(target.cooldown_until);
+    assert.ok(target.cooldown_until > Date.now());
+    assert.strictEqual(target.cooldown_reason, 'RateLimited');
+
+    // Verify rotation skips it
+    const triedSet = new Set<string>();
+    triedSet.add('dummy-id'); // to force getNextAvailableAccount check
+    const available = getNextAvailableAccount(triedSet);
+    // Since our test account is on cooldown, if it was returned, it means no other account was available,
+    // or if we have other non-cooldown accounts, it returned one of them.
+    if (available && available.id === accountId) {
+      // If it returned our test account, it must be because all accounts are on cooldown.
+      // Let's assert that the cooldown is actually registered in memory.
+      const info = getNextAccount();
+      // It shouldn't be the first option if others are available
+    }
+
+    // Clear cooldown and verify it is updated in DB
+    clearAccountCooldown(accountId);
+    invalidateAccountsCache();
+
+    const reloaded = loadAccounts().find(a => a.id === accountId);
+    assert.ok(reloaded);
+    assert.strictEqual(reloaded.cooldown_until || 0, 0);
+    assert.strictEqual(reloaded.cooldown_reason, null);
+
+  } finally {
+    if (accountId) {
+      removeAccount(accountId);
+    }
+    invalidateAccountsCache();
+  }
+});

package/src/utils/context-truncation.ts

@@ -1,7 +1,7 @@
 import { getModelTokenDivisor } from '../core/model-registry.js'
 
 export function estimateTokenCount(text: string, modelId?: string): number {
-  const divisor = modelId ? getModelTokenDivisor(modelId) : 2.0
+  const divisor = getModelTokenDivisor(modelId)
   return Math.ceil(text.length / divisor)
 }
 
@@ -36,7 +36,7 @@ export function truncateMessages(
   systemPrompt: string = '',
   modelId?: string
 ): Array<{ role: string; content: string }> {
-  const divisor = modelId ? getModelTokenDivisor(modelId) : 2.0
+  const divisor = getModelTokenDivisor(modelId)
   const systemTokens = estimateTokenCount(systemPrompt, modelId);
   const availableTokens = maxContextLength - systemTokens - 500;