qwenproxy-cli 1.0.4 → 1.0.6

package/README.md

@@ -284,7 +284,7 @@ qpx
 | `qpx login` | Abre navegador visível para autenticar novas contas interativamente |
 | `qpx sync` | Configura e sincroniza clientes (Claude Code, Codex, OpenCode, OMP) |
 | `qpx clean` | Limpa caches temporários dos perfis Chromium (~4.5MB por conta) |
-| `qpx clean:all` | Limpa caches e remove versões antigas de navegadores órfãos no SSD |
+| `qpx clean:all` | Limpa caches e remove versões antigas de navegadores órfãos em disco |
 | `qpx purge` | Limpa o histórico de conversas remotas no Qwen de todas as contas |
 | `qpx reset` | Reseta cooldowns e rate limits salvos no banco de dados |
 ### Opção 2: Execução Instantânea (Zero Instalação)
@@ -845,7 +845,7 @@ QwenProxy/
 | `npm start`         | Iniciar apenas o servidor QwenProxy em modo headless                    |
 | `npm run sync`      | Sincronizar clientes (Claude Code, Codex, OpenCode, OMP) com backup     |
 | `npm run clean`     | Limpar caches temporários dos perfis Chromium (~4.5MB por conta)        |
-| `npm run clean:all` | Limpar caches + remover navegadores órfãos e versões antigas no SSD     |
+| `npm run clean:all` | Limpar caches + remover navegadores órfãos e versões antigas em disco   |
 | `npm run reset`     | Zerar cooldowns de contas no banco de dados                             |
 | `npm run login`     | Adicionar/autenticar novas contas visualmente no navegador              |
 | `npm run purge`     | Limpar chats remotos do Qwen nas contas configuradas                    |

package/bin/qwenproxy.js

@@ -115,19 +115,47 @@ try {
   tsxLoaderArg = pathToFileURL(tsxEntry).href;
 } catch {}
 
-// Ensure Playwright Chromium is installed for first-time global users
-try {
-  const { chromium } = await import("patchright");
-  const execPath = chromium.executablePath();
-  if (!fs.existsSync(execPath)) {
-    console.log("⏳ [QwenProxy] Instalando o navegador Chromium pela primeira vez...");
-    spawnSync("npx", ["patchright", "install", "chromium"], {
-      stdio: "inherit",
-      shell: true,
-    });
-    console.log("✓ [QwenProxy] Navegador instalado com sucesso!\n");
-  }
-} catch {}
+// Ensure Playwright Chromium is installed only for commands that need the browser
+const browserCommands = ["start", "tui", "login"];
+const isBrowserCommand =
+  !firstArg ||
+  browserCommands.includes(firstArg) ||
+  rawArgs.includes("--tui") ||
+  rawArgs.includes("--server");
+
+if (isBrowserCommand) {
+  try {
+    const { chromium } = await import("patchright");
+    const execPath = chromium.executablePath();
+    if (!fs.existsSync(execPath)) {
+      console.log("⏳ [QwenProxy] Instalando o navegador Chromium pela primeira vez...");
+      let cliPath = "";
+      try {
+        const patchrightEntry = require.resolve("patchright");
+        cliPath = path.join(path.dirname(patchrightEntry), "cli.js");
+      } catch {}
+      const installEnv = {
+        ...process.env,
+        PLAYWRIGHT_DOWNLOAD_CONNECTION_TIMEOUT:
+          process.env.PLAYWRIGHT_DOWNLOAD_CONNECTION_TIMEOUT || "300000",
+      };
+
+      if (cliPath && fs.existsSync(cliPath)) {
+        spawnSync(process.execPath, [cliPath, "install", "chromium"], {
+          stdio: "inherit",
+          env: installEnv,
+        });
+      } else {
+        const cmd = process.platform === "win32" ? "npx.cmd" : "npx";
+        spawnSync(cmd, ["--yes", "patchright", "install", "chromium"], {
+          stdio: "inherit",
+          env: installEnv,
+        });
+      }
+      console.log("✓ [QwenProxy] Navegador instalado com sucesso!\n");
+    }
+  } catch {}
+}
 
 const child = spawn(process.execPath, ["--import", tsxLoaderArg, targetPath, ...scriptArgs], {
   stdio: "inherit",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "High-performance OpenAI & Anthropic compatible API gateway for Qwen with multi-account rotation, interactive TUI, and resilient tool calling.",
   "main": "src/index.ts",
   "bin": {

package/src/api/server.ts

@@ -597,6 +597,7 @@ export async function stopServer(): Promise<void> {
 
 export async function startServer(options?: {
   installSignalHandlers?: boolean;
+  showBanner?: boolean;
 }): Promise<StartedServerInfo> {
   if (server) {
     if (options?.installSignalHandlers !== false) installSignalHandlers();
@@ -829,7 +830,8 @@ export async function startServer(options?: {
 
     const endpoint = `${started.url}/v1`;
 
-    console.log(`
+    if (options?.showBanner !== false) {
+      console.log(`
 +${"-".repeat(W)}+
 |${blank()}|
 |${center("QwenProxy")}|
@@ -845,6 +847,7 @@ export async function startServer(options?: {
 |${blank()}|
 +${"-".repeat(W)}+
 `);
+    }
     return started;
   })();
 

package/src/clean-cache.ts

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { chromium } from "patchright";
-import { pruneAllPlaywrightProfiles } from "./services/playwright.ts";
+import { pruneAllPlaywrightProfiles, cleanupOrphanProfiles } from "./services/playwright.ts";
 
 export function formatBytes(bytes: number): string {
   if (bytes < 1024) return `${bytes} B`;
@@ -141,13 +141,19 @@ async function main() {
   // 1. Profile Transient Cache Pruning (V8 Code Cache, GPU Cache)
   console.log("1. Limpando caches transitórios dos perfis (data/qwen_profiles/)...");
   const profileResult = pruneAllPlaywrightProfiles();
-  if (profileResult.totalFreedFiles > 0) {
-    console.log(
-      `   [OK] Perfis limpos com sucesso!`,
-    );
-    console.log(
-      `   Espaço liberado: ${formatBytes(profileResult.totalFreedBytes)} em ${profileResult.totalFreedFiles} arquivos (${profileResult.profilesCleaned} perfil(is)).`,
-    );
+  const orphanResult = cleanupOrphanProfiles();
+  if (profileResult.totalFreedFiles > 0 || orphanResult.removedCount > 0) {
+    console.log(`   [OK] Perfis limpos com sucesso!`);
+    if (profileResult.totalFreedFiles > 0) {
+      console.log(
+        `   Espaço liberado: ${formatBytes(profileResult.totalFreedBytes)} em ${profileResult.totalFreedFiles} arquivos (${profileResult.profilesCleaned} perfil(is)).`,
+      );
+    }
+    if (orphanResult.removedCount > 0) {
+      console.log(
+        `   Perfis órfãos removidos: ${orphanResult.removedCount} (${formatBytes(orphanResult.freedBytes)} liberados).`,
+      );
+    }
     console.log(
       `   (Todos os cookies, sessões e logins foram 100% preservados!)`,
     );
@@ -172,13 +178,13 @@ async function main() {
       for (const d of browserResult.unusedDirs) {
         console.log(`     - ${d.name} (${d.size})`);
       }
-      console.log(`   Total recuperado no SSD: ${formatBytes(browserResult.freedBytes)}!`);
+      console.log(`   Total recuperado em disco: ${formatBytes(browserResult.freedBytes)}!`);
     } else {
-      console.log(`   [INFO] Encontrados ${browserResult.unusedDirs.length} navegador(es) legados/não utilizados no seu SSD:`);
+      console.log(`   [INFO] Encontrados ${browserResult.unusedDirs.length} navegador(es) legados/não utilizados em disco:`);
       for (const d of browserResult.unusedDirs) {
         console.log(`     - ${d.name} (${d.size})`);
       }
-      console.log(`   Espaço recuperável no SSD: ${formatBytes(totalReclaimable)}.`);
+      console.log(`   Espaço recuperável em disco: ${formatBytes(totalReclaimable)}.`);
       console.log(`   Para liberar esse espaço automaticamente, execute:`);
       console.log(`   npm run clean:all\n`);
     }

package/src/core/config.ts

@@ -154,6 +154,7 @@ const envSchema = z
     QWEN_PERSONALIZATION_FROM_REQUEST: z.string().default("true"),
     QWEN_PERSONALIZATION_VERIFY_GET: z.string().default("true"),
     QWEN_BROWSER_ONLY_FETCH: z.string().default("true"),
+    QWEN_MAP_OPENAI_MODELS: z.string().default("true"),
     QWEN_MAX_PROMPT_BYTES: z.string().default("0"),
     QWEN_MAX_PERSONALIZATION_BYTES: z.string().default("200000"),
     CONTEXT_METER_ENABLED: z.string().default("true"),
@@ -358,6 +359,7 @@ export const config = {
     /** "thread" (reuse upstream chat) or "temp" (new ephemeral chat per request). */
     /** When true, all requests (personalization, models, media, chat) route exclusively through the browser page (no direct Node fetch). */
     browserOnlyFetch: env.QWEN_BROWSER_ONLY_FETCH !== "false",
+    mapOpenAiModels: env.QWEN_MAP_OPENAI_MODELS !== "false",
     chatMode: env.QWEN_CHAT_MODE,
     maxPromptBytes: Math.max(0, parseInt(env.QWEN_MAX_PROMPT_BYTES)),
     maxPersonalizationBytes: Math.max(

package/src/core/model-alias.ts

@@ -63,15 +63,55 @@ export function stripThinkingSuffix(model: string): {
   return { baseModel: normalizedModel, enableThinking: true, reasoningMode: "auto" };
 }
 
+/**
+ * Mapeia modelos populares de terceiros (OpenAI / Anthropic) para o tier Qwen equivalente:
+ * - mini / haiku / 3.5 -> qwen3.7-plus
+ * - gpt-4* / o1* / o3* / opus / sonnet / claude-* -> qwen3.8-max
+ * Modelos que já começam com "qwen" passam intactos.
+ */
+export function mapKnownModelAlias(model: string): string {
+  if (!model) return model;
+  const lower = model.toLowerCase();
+  if (lower.startsWith("qwen")) return model;
+
+  // Lightweight / mini models
+  if (
+    lower.includes("mini") ||
+    lower.includes("haiku") ||
+    lower.includes("3.5-turbo")
+  ) {
+    return "qwen3.7-plus";
+  }
+
+  // Flagship reasoning / chat models
+  if (
+    lower.startsWith("gpt-") ||
+    lower.startsWith("chatgpt-") ||
+    lower.startsWith("o1") ||
+    lower.startsWith("o3") ||
+    lower.includes("sonnet") ||
+    lower.includes("opus") ||
+    lower.startsWith("claude")
+  ) {
+    return "qwen3.8-max";
+  }
+
+  return model;
+}
+
 /**
  * Mapeia o id de modelo para o Qwen upstream.
- * Ids `qwen*` passam direto (após remover o sufixo de raciocínio); ids de
- * outros provedores (gpt-*, grok-*, etc.) também passam “as-is” — o Codex/Custom
- * provider envia o id Qwen correto, e qualquer id desconhecido deve chegar ao
- * upstream para que este responda um erro claro de modelo, em vez de ser
- * silenciosamente roteado para um tier qualquer.
+ * Quando enableAliases é verdadeiro (padrão via QWEN_MAP_OPENAI_MODELS),
+ * converte gpt-* / o1* / claude-* para os tiers correspondentes do Qwen.
  */
-export function mapClientModelToQwen(model: string): string {
+export function mapClientModelToQwen(
+  model: string,
+  enableAliases = true,
+): string {
   if (!model) return model;
-  return stripThinkingSuffix(model.trim()).baseModel;
+  const base = stripThinkingSuffix(model.trim()).baseModel;
+  if (enableAliases) {
+    return mapKnownModelAlias(base);
+  }
+  return base;
 }

package/src/login.ts

@@ -130,6 +130,11 @@ async function removeAccountFlow() {
   const confirm = await askQuestion(`\nRemove ${account.email}? (y/N): `);
   if (confirm.toLowerCase() === "y") {
     if (removeAccount(account.id)) {
+      try {
+        const { removePlaywrightProfile } = await import("./services/playwright.ts");
+        const { getAccountProfilePath } = await import("./core/paths.ts");
+        removePlaywrightProfile(getAccountProfilePath(account.id));
+      } catch {}
       console.log(`Account ${maskEmail(account.email)} removed.`);
     } else {
       console.log("Failed to remove account.");

package/src/routes/chat/validation.ts

@@ -70,7 +70,7 @@ export async function parseRequestBody(c: Context): Promise<ParsedRequest> {
 
   // Thinking suffixes → base model + reasoning mode
   const { baseModel, enableThinking, reasoningMode } = stripThinkingSuffix(body.model);
-  const modelId = mapClientModelToQwen(baseModel);
+  const modelId = mapClientModelToQwen(baseModel, config.qwen.mapOpenAiModels);
 
   // OpenAI `reasoning_effort` (none|minimal|low|medium|high|xhigh|max).
   // Precedence: an explicit model suffix wins — effort only acts on unsuffixed

package/src/services/fingerprint.ts

@@ -23,9 +23,48 @@ function pick<T>(rng: () => number, values: readonly T[]): T {
 function randInt(rng: () => number, min: number, max: number): number {
   return Math.floor(rng() * (max - min + 1)) + min;
 }
+let dynamicChromeMajor = 151;
 
-const CHROME_MAJOR = 149;
+export function updateChromeMajor(major: number): void {
+  if (typeof major === "number" && major >= 100) {
+    dynamicChromeMajor = major;
+  }
+}
+
+export function getChromeMajor(): number {
+  return dynamicChromeMajor;
+}
+
+export function getSystemLocale(): string {
+  return (
+    process.env.QWEN_LOCALE ||
+    (typeof Intl !== "undefined" && Intl.DateTimeFormat
+      ? Intl.DateTimeFormat().resolvedOptions().locale
+      : "") ||
+    "pt-BR"
+  );
+}
+
+function getLanguageProfiles(locale = getSystemLocale()): readonly (readonly string[])[] {
+  const primary = locale.split("-")[0];
+  if (primary === "en") {
+    return [
+      ["en-US", "en"],
+      ["en-US", "en", "es"],
+      ["en", "en-US"],
+      ["en-US", "en;q=0.9"],
+    ] as const;
+  }
+  return [
+    [locale, primary, "en-US", "en"],
+    [locale, primary, "en-US", "en", "es"],
+    [locale, "en-US", "en", primary],
+    [locale, primary, "en"],
+    [locale, `${primary};q=0.9`, "en-US;q=0.8", "en;q=0.7"],
+  ] as const;
+}
 
+const CHROME_MAJOR = 151;
 const VIEWPORTS = [
   { width: 1366, height: 768 },
   { width: 1440, height: 900 },
@@ -176,20 +215,21 @@ export function getFingerprintProfile(accountId: string): FingerprintProfile {
   const rng = mulberry32(seed);
   const viewport = pick(rng, VIEWPORTS);
   const webgl = pick(rng, WEBGL_PROFILES);
-  const languages = [...pick(rng, LANGUAGE_PROFILES)];
+  const languages = [...pick(rng, getLanguageProfiles())];
   const hardwareConcurrency = pick(rng, HARDWARE_CONCURRENCIES);
   const deviceMemory = pick(rng, DEVICE_MEMORIES);
   const platformInfo = pick(rng, PLATFORM_VERSIONS);
   const notABrand = pick(rng, NOT_A_BRAND_VARIANTS);
 
+  const major = dynamicChromeMajor;
   const build = randInt(rng, 7300, 7600);
   const patch = randInt(rng, 0, 160);
-  const chromeVersion = `${CHROME_MAJOR}.0.${build}.${patch}`;
+  const chromeVersion = `${major}.0.${build}.${patch}`;
 
   const brands = [
     { brand: notABrand.brand, version: notABrand.version },
-    { brand: "Google Chrome", version: String(CHROME_MAJOR) },
-    { brand: "Chromium", version: String(CHROME_MAJOR) },
+    { brand: "Google Chrome", version: String(major) },
+    { brand: "Chromium", version: String(major) },
   ];
   const fullVersionList = [
     { brand: notABrand.brand, version: chromeVersion },

package/src/services/playwright.ts

@@ -7,7 +7,38 @@ import { chromium, type Browser, type BrowserContext, type Page } from "patchrig
 import path from "path";
 import fs from "fs";
 import crypto from "crypto";
-import type { QwenAccount } from "../core/accounts.ts";
+import { spawnSync } from "child_process";
+import { createRequire } from "module";
+
+const requireLocal = createRequire(import.meta.url);
+
+function autoInstallPlaywrightChromium(): void {
+  const installEnv = {
+    ...process.env,
+    PLAYWRIGHT_DOWNLOAD_CONNECTION_TIMEOUT:
+      process.env.PLAYWRIGHT_DOWNLOAD_CONNECTION_TIMEOUT || "300000",
+  };
+  try {
+    const patchrightEntry = requireLocal.resolve("patchright");
+    const cliPath = path.join(path.dirname(patchrightEntry), "cli.js");
+    if (fs.existsSync(cliPath)) {
+      console.log("⏳ [Playwright] Navegador Chromium não encontrado. Instalando automaticamente...");
+      spawnSync(process.execPath, [cliPath, "install", "chromium"], {
+        stdio: "inherit",
+        env: installEnv,
+      });
+      return;
+    }
+  } catch {}
+
+  console.log("⏳ [Playwright] Navegador Chromium não encontrado. Instalando via npx...");
+  const cmd = process.platform === "win32" ? "npx.cmd" : "npx";
+  spawnSync(cmd, ["--yes", "patchright", "install", "chromium"], {
+    stdio: "inherit",
+    env: installEnv,
+  });
+}
+import { loadAccounts, type QwenAccount } from "../core/accounts.ts";
 // Imported here rather than injected from session-keeper.ts: account-concurrency
 // only depends on config/logger, so playwright -> account-concurrency stays
 // acyclic, while the reverse direction would drag the browser layer into core.
@@ -23,6 +54,7 @@ import { getAccountsByPriority } from "../core/account-priority.ts";
 import {
   clearFingerprintCache,
   getFingerprintProfile,
+  updateChromeMajor,
   type FingerprintProfile,
 } from "./fingerprint.ts";
 import { subtlePageActivity } from "./human-behavior.ts";
@@ -260,16 +292,38 @@ export async function getOrLaunchSharedBrowser(
     const launchArgs = buildChromiumLaunchArgs(defaultViewport);
 
     console.log(
-      `[Playwright] Launching single shared ${browserType} browser...`,
+      `🌐 [Playwright] Launching single shared ${browserType} browser...`,
     );
 
-    const browser = await engine.launch({
-      headless,
-      channel,
-      ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
-      args: launchArgs,
-    });
+    let browser: Browser;
+    try {
+      browser = await engine.launch({
+        headless,
+        channel,
+        ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
+        args: launchArgs,
+      });
+    } catch (launchErr: any) {
+      if (launchErr?.message?.includes("Executable doesn't exist")) {
+        autoInstallPlaywrightChromium();
+        browser = await engine.launch({
+          headless,
+          channel,
+          ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
+          args: launchArgs,
+        });
+      } else {
+        throw launchErr;
+      }
+    }
 
+    try {
+      const v = browser.version();
+      const major = parseInt(v.split(".")[0], 10);
+      if (major >= 100) {
+        updateChromeMajor(major);
+      }
+    } catch {}
     browser.on("disconnected", () => {
       console.warn("[Playwright] Shared browser disconnected");
       sharedBrowser = null;
@@ -2338,6 +2392,64 @@ export function pruneAllPlaywrightProfiles(baseDir = getProfilesDir()): {
 
   return { totalFreedBytes, totalFreedFiles, profilesCleaned };
 }
+/**
+ * Removes profile directories in data/qwen_profiles that do not belong to any
+ * active account configured in the database or environment, plus any lingering
+ * .stale-* directories from previous lock renames.
+ */
+export function cleanupOrphanProfiles(
+  baseDir = getProfilesDir(),
+  activeAccountIds?: Set<string>,
+): {
+  removedCount: number;
+  freedBytes: number;
+} {
+  let removedCount = 0;
+  let freedBytes = 0;
+
+  try {
+    if (!fs.existsSync(baseDir)) {
+      return { removedCount, freedBytes };
+    }
+
+    const activeIds =
+      activeAccountIds ?? new Set(loadAccounts().map((a) => a.id));
+
+    const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const isStale = entry.name.includes(".stale-");
+      const isOrphan = !isStale && !activeIds.has(entry.name);
+
+      if (isStale || isOrphan) {
+        const targetPath = path.join(baseDir, entry.name);
+        try {
+          let bytes = 0;
+          const countSize = (d: string) => {
+            try {
+              const subEntries = fs.readdirSync(d, { withFileTypes: true });
+              for (const e of subEntries) {
+                const full = path.join(d, e.name);
+                if (e.isDirectory()) countSize(full);
+                else if (e.isFile()) {
+                  try { bytes += fs.statSync(full).size; } catch {}
+                }
+              }
+            } catch {}
+          };
+          countSize(targetPath);
+          removePlaywrightProfile(targetPath);
+          if (!fs.existsSync(targetPath)) {
+            removedCount++;
+            freedBytes += bytes;
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+
+  return { removedCount, freedBytes };
+}
 
 const PROFILE_RESET_TIMEOUT_MS = Math.max(90_000, config.timeouts.headers);
 

package/src/services/qwen-chat-pool.ts

@@ -153,10 +153,10 @@ const WARM_POOL_LOW_WATER = 3;
 
 function warmChatKey(
   accountId: string | undefined,
-  model: string,
+  _model: string,
   chatId: string,
 ) {
-  return `${accountId || "global"}:${model}:${chatId}`;
+  return `${accountId || "global"}:${chatId}`;
 }
 
 function markWarmChatInFlight(
@@ -183,8 +183,8 @@ function isWarmChatInFlight(
   return inFlightWarmChats.has(warmChatKey(accountId, model, chatId));
 }
 
-function chatPoolKey(accountId: string | undefined, model: string): string {
-  return `${accountId || "global"}:${model}`;
+function chatPoolKey(accountId: string | undefined, _model?: string): string {
+  return accountId || "global";
 }
 
 function isQwenChatPoolEnabled(): boolean {

package/src/services/qwen-headers.ts

@@ -1,6 +1,24 @@
 import { v4 as uuidv4 } from "uuid";
 import { qwenUrl, qwenOrigin } from "./qwen-url.ts";
 import { config } from "../core/config.js";
+import { getChromeMajor, getSystemLocale } from "./fingerprint.ts";
+
+export function getSystemAcceptLanguage(customLocale?: string): string {
+  const locale = customLocale || getSystemLocale();
+  const primary = locale.split("-")[0];
+  if (locale.toLowerCase() === "en-us" || locale.toLowerCase() === "en") {
+    return "en-US,en;q=0.9";
+  }
+  if (locale.toLowerCase().startsWith("pt")) {
+    return "pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7";
+  }
+  return `${locale},${primary};q=0.9,en-US;q=0.8,en;q=0.7`;
+}
+
+export function getDefaultQwenUserAgent(major = getChromeMajor()): string {
+  return `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${major}.0.0.0 Safari/537.36`;
+}
+
 let dynamicWebVersion: string | null = null;
 
 export function updateQwenWebVersion(version?: string | null): void {
@@ -14,13 +32,12 @@ export function getQwenWebVersion(): string {
 }
 
 export const QWEN_WEB_VERSION = config.qwen.webVersion;
-export const DEFAULT_QWEN_USER_AGENT =
-  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36";
+export const DEFAULT_QWEN_USER_AGENT = getDefaultQwenUserAgent(151);
 const QWEN_TIMEZONE_HEADER = new Date().toString().split(" (")[0];
-
 export interface BuildQwenHeadersOptions {
   cookie: string;
   userAgent?: string;
+  acceptLanguage?: string;
   bxUa?: string;
   bxUmidtoken?: string;
   bxV?: string;
@@ -40,7 +57,10 @@ export function buildQwenRequestHeaders(
   const headers: Record<string, string> = {
     ...(opts.extra ?? {}),
     Accept: "application/json",
-    "Accept-Language": "pt-BR,pt;q=0.9",
+    "Accept-Language":
+      opts.extra?.["Accept-Language"] ||
+      opts.acceptLanguage ||
+      getSystemAcceptLanguage(),
     "Accept-Encoding": "gzip, deflate, br, zstd",
     "Content-Type": "application/json",
     Cookie: opts.cookie,
@@ -54,7 +74,7 @@ export function buildQwenRequestHeaders(
     "Sec-Fetch-Mode": "cors",
     "Sec-Fetch-Site": "same-origin",
     Connection: "keep-alive",
-    "User-Agent": opts.userAgent || DEFAULT_QWEN_USER_AGENT,
+    "User-Agent": opts.userAgent || getDefaultQwenUserAgent(),
     "X-Request-Id": uuidv4(),
     "bx-v": opts.bxV || "2.5.37",
     source: "web",
@@ -62,7 +82,9 @@ export function buildQwenRequestHeaders(
     timezone: opts.extra?.timezone || new Date().toString().split(" (")[0],
     // Use the real browser client-hints when captured (anti-hardcoded); fall
     // back to the static fingerprint otherwise.
-    "sec-ch-ua": opts.secChUa || '"Google Chrome";v="150", "Chromium";v="150", "Not.A/Brand";v="99"',
+    "sec-ch-ua":
+      opts.secChUa ||
+      `"Google Chrome";v="${getChromeMajor()}", "Chromium";v="${getChromeMajor()}", "Not.A/Brand";v="99"`,
     "sec-ch-ua-mobile": opts.secChUaMobile || "?0",
     "sec-ch-ua-platform": opts.secChUaPlatform || '"Windows"',
   };