qwenproxy-cli 1.0.5 → 1.0.7

package/bin/qwenproxy.js

@@ -134,15 +134,22 @@ if (isBrowserCommand) {
         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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "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/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/index.ts

@@ -21,6 +21,9 @@ process.on('uncaughtException', (error: unknown) => {
     msg.includes('Target page, context or browser has been closed') ||
     msg.includes('Browser has been closed') ||
     msg.includes('Target closed') ||
+    msg.includes('Target crashed') ||
+    msg.includes('Page crashed') ||
+    msg.includes('Assertion error') ||
     msg.includes('Connection closed')
   ) {
     console.warn(`⚠️  [Playwright] Handled benign driver teardown exception: ${msg}`)
@@ -36,6 +39,9 @@ process.on('unhandledRejection', (reason: unknown) => {
     msg.includes('Target page, context or browser has been closed') ||
     msg.includes('Browser has been closed') ||
     msg.includes('Target closed') ||
+    msg.includes('Target crashed') ||
+    msg.includes('Page crashed') ||
+    msg.includes('Assertion error') ||
     msg.includes('Connection closed')
   ) {
     console.warn(`⚠️  [Playwright] Handled benign driver teardown rejection: ${msg}`)

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/human-behavior.ts

@@ -147,27 +147,43 @@ export async function subtlePageActivity(page: Page): Promise<void> {
   const viewport = page.viewportSize();
   if (!viewport) return;
 
-  const x = Math.floor(viewport.width * (0.25 + Math.random() * 0.5));
-  const y = Math.floor(viewport.height * (0.25 + Math.random() * 0.5));
-  await page.mouse.move(x, y, { steps: 6 + Math.floor(Math.random() * 8) });
+  try {
+    const x = Math.floor(viewport.width * (0.25 + Math.random() * 0.5));
+    const y = Math.floor(viewport.height * (0.25 + Math.random() * 0.5));
+    await page.mouse.move(x, y, { steps: 6 + Math.floor(Math.random() * 8) });
 
-  if (Math.random() < 0.35) {
-    await page.mouse.wheel(0, Math.random() < 0.5 ? 60 : -60).catch(() => {});
-  }
+    if (Math.random() < 0.35) {
+      await page.mouse.wheel(0, Math.random() < 0.5 ? 60 : -60).catch(() => {});
+    }
 
-  await page
-    .evaluate(() => {
-      try {
-        const target = document.querySelector(
-          '[data-testid="sidebar"], .sidebar, nav, aside, main',
-        );
-        if (target) {
-          target.dispatchEvent(new MouseEvent("mouseenter", { bubbles: true }));
-          target.dispatchEvent(new MouseEvent("mouseleave", { bubbles: true }));
+    await page
+      .evaluate(() => {
+        try {
+          const target = document.querySelector(
+            '[data-testid="sidebar"], .sidebar, nav, aside, main',
+          );
+          if (target) {
+            target.dispatchEvent(new MouseEvent("mouseenter", { bubbles: true }));
+            target.dispatchEvent(new MouseEvent("mouseleave", { bubbles: true }));
+          }
+        } catch {
+          // Best-effort keep-alive only.
         }
-      } catch {
-        // Best-effort keep-alive only.
-      }
-    })
-    .catch(() => {});
+      })
+      .catch(() => {});
+  } catch (err: any) {
+    if (page.isClosed()) return;
+    const msg = err instanceof Error ? err.message : String(err);
+    if (
+      msg.includes("Target page, context or browser has been closed") ||
+      msg.includes("Browser has been closed") ||
+      msg.includes("Target closed") ||
+      msg.includes("Target crashed") ||
+      msg.includes("Page crashed") ||
+      msg.includes("Connection closed")
+    ) {
+      return;
+    }
+    throw err;
+  }
 }

package/src/services/playwright.ts

@@ -13,6 +13,11 @@ 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");
@@ -20,6 +25,7 @@ function autoInstallPlaywrightChromium(): void {
       console.log("⏳ [Playwright] Navegador Chromium não encontrado. Instalando automaticamente...");
       spawnSync(process.execPath, [cliPath, "install", "chromium"], {
         stdio: "inherit",
+        env: installEnv,
       });
       return;
     }
@@ -29,6 +35,7 @@ function autoInstallPlaywrightChromium(): void {
   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";
@@ -47,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";
@@ -309,6 +317,13 @@ export async function getOrLaunchSharedBrowser(
       }
     }
 
+    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;
@@ -1186,12 +1201,13 @@ export async function initPlaywrightForAccount(
     // If a context limit is configured, make room by closing idle contexts.
     await evictIdlePlaywrightContextsToLimit().catch(() => {});
 
+    const profilePath = getAccountProfilePath(account.id);
     const fingerprint = getFingerprintProfile(account.id);
-    const sharedBrowser = await getOrLaunchSharedBrowser(browserType, headless);
-    const storageState = loadStorageState(account.id);
+    const { engine, channel } = resolveBrowserEngine(browserType);
 
-    const acctContext = await sharedBrowser.newContext({
-      ...(storageState ? { storageState } : {}),
+    const launchOptions = {
+      headless,
+      channel,
       userAgent: fingerprint.userAgent,
       locale: fingerprint.locale,
       timezoneId: fingerprint.timezoneId,
@@ -1200,13 +1216,37 @@ export async function initPlaywrightForAccount(
       deviceScaleFactor: 1,
       isMobile: false,
       hasTouch: false,
-      colorScheme: "light",
+      colorScheme: "light" as const,
       extraHTTPHeaders: {
         "sec-ch-ua": fingerprint.secChUa,
         "sec-ch-ua-mobile": "?0",
         "sec-ch-ua-platform": '"Windows"',
       },
-    });
+      ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
+      args: buildChromiumLaunchArgs(fingerprint.viewport),
+    };
+
+    let acctContext: BrowserContext;
+    try {
+      acctContext = await engine.launchPersistentContext(profilePath, launchOptions);
+    } catch (launchErr: any) {
+      if (launchErr?.message?.includes("Executable doesn't exist")) {
+        autoInstallPlaywrightChromium();
+        acctContext = await engine.launchPersistentContext(profilePath, launchOptions);
+      } else {
+        throw launchErr;
+      }
+    }
+
+    try {
+      const v = acctContext.browser()?.version();
+      if (v) {
+        const major = parseInt(v.split(".")[0], 10);
+        if (major >= 100) {
+          updateChromeMajor(major);
+        }
+      }
+    } catch {}
 
     try {
       // Comprehensive stealth scripts for anti-bot evasion
@@ -1215,7 +1255,38 @@ export async function initPlaywrightForAccount(
         await hook(acctContext);
       }
 
-      const acctPage = await acctContext.newPage();
+      // If native profile cookies are empty but a backup storage_state.json exists, restore cookies
+      const storageState = loadStorageState(account.id);
+      if (storageState) {
+        try {
+          const raw = fs.readFileSync(storageState, "utf8");
+          const parsed = JSON.parse(raw);
+          if (Array.isArray(parsed.cookies) && parsed.cookies.length > 0) {
+            const currentCookies = await acctContext.cookies();
+            if (currentCookies.length === 0) {
+              await acctContext.addCookies(parsed.cookies).catch(() => {});
+            }
+          }
+        } catch {}
+      }
+
+      // Persistent contexts may already contain an initial about:blank tab.
+      // Reuse it instead of creating a second tab. Prefer a tab already on the
+      // Qwen origin when one exists.
+      const existingPages = acctContext.pages().filter((p) => !p.isClosed());
+      const acctPage =
+        existingPages.find((p) => p.url().startsWith(qwenOrigin())) ??
+        existingPages[0] ??
+        (await acctContext.newPage());
+
+      // Close any extra blank tabs that may have been created by the browser
+      // profile/startup, but keep the primary page selected above.
+      for (const extraPage of existingPages.slice(1)) {
+        if (extraPage !== acctPage && extraPage.url() === "about:blank") {
+          await extraPage.close({ runBeforeUnload: false }).catch(() => {});
+        }
+      }
+
       acctPage.setDefaultTimeout(config.timeouts.page);
       acctPage.setDefaultNavigationTimeout(config.timeouts.navigation);
       accountContexts.set(account.id, acctContext);
@@ -1330,13 +1401,12 @@ export async function validateAccountLogin(
   );
   try {
     if (accountPages.has(account.id)) return true;
-
+    const profilePath = getAccountProfilePath(account.id);
     const fingerprint = getFingerprintProfile(account.id);
-    const sharedBrowser = await getOrLaunchSharedBrowser(browserType, headless);
-    const storageState = loadStorageState(account.id);
-
-    const acctContext = await sharedBrowser.newContext({
-      ...(storageState ? { storageState } : {}),
+    const { engine, channel } = resolveBrowserEngine(browserType);
+    const launchOptions = {
+      headless,
+      channel,
       userAgent: fingerprint.userAgent,
       locale: fingerprint.locale,
       timezoneId: fingerprint.timezoneId,
@@ -1345,18 +1415,51 @@ export async function validateAccountLogin(
       deviceScaleFactor: 1,
       isMobile: false,
       hasTouch: false,
-      colorScheme: "light",
+      colorScheme: "light" as const,
       extraHTTPHeaders: {
         "sec-ch-ua": fingerprint.secChUa,
         "sec-ch-ua-mobile": "?0",
         "sec-ch-ua-platform": '"Windows"',
       },
-    });
+      ignoreDefaultArgs: ["--enable-automation", "--enable-blink-features"],
+      args: buildChromiumLaunchArgs(fingerprint.viewport),
+    };
+
+    let acctContext: BrowserContext;
+    try {
+      acctContext = await engine.launchPersistentContext(profilePath, launchOptions);
+    } catch (launchErr: any) {
+      if (launchErr?.message?.includes("Executable doesn't exist")) {
+        autoInstallPlaywrightChromium();
+        acctContext = await engine.launchPersistentContext(profilePath, launchOptions);
+      } else {
+        throw launchErr;
+      }
+    }
 
     try {
       await acctContext.addInitScript(getStealthScript(fingerprint));
-      const acctPage = await acctContext.newPage();
 
+      // If native profile cookies are empty but a backup storage_state.json exists, restore cookies
+      const storageState = loadStorageState(account.id);
+      if (storageState) {
+        try {
+          const raw = fs.readFileSync(storageState, "utf8");
+          const parsed = JSON.parse(raw);
+          if (Array.isArray(parsed.cookies) && parsed.cookies.length > 0) {
+            const currentCookies = await acctContext.cookies();
+            if (currentCookies.length === 0) {
+              await acctContext.addCookies(parsed.cookies).catch(() => {});
+            }
+          }
+        } catch {}
+      }
+
+      const existingPages = acctContext.pages().filter((p) => !p.isClosed());
+      const acctPage =
+        existingPages.find((p) => p.url().startsWith(qwenOrigin())) ??
+        existingPages[0] ??
+        (await acctContext.newPage());
       // Check if already logged in via cookies
       const cookies = await acctContext.cookies();
       const hasAuthCookie = cookies.some(
@@ -2774,6 +2877,9 @@ export function isPlaywrightAlreadyClosedError(error: unknown): boolean {
     message.includes("Target page, context or browser has been closed") ||
     message.includes("Browser has been closed") ||
     message.includes("Target closed") ||
+    message.includes("Target crashed") ||
+    message.includes("Page crashed") ||
+    message.includes("Assertion error") ||
     message.includes("Cannot find parent object") ||
     message.includes("Connection closed")
   );

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

package/src/sync/omp.ts

@@ -3,7 +3,30 @@ import path from "node:path";
 import type { ClientSyncResult, SyncOptions } from "./types.ts";
 import { createTimestampBackup, restoreFromBackup } from "./utils.ts";
 
-function buildOmpProviderYaml(baseUrl: string, apiKey: string): string {
+function buildOmpProviderYaml(
+  baseUrl: string,
+  apiKey: string,
+  primaryModel: string = "qwen3.8-max",
+): string {
+  const modelList = [primaryModel];
+  if (primaryModel !== "qwen3.7-plus") {
+    modelList.push("qwen3.7-plus");
+  }
+
+  const formattedModels = modelList
+    .map(
+      (m) => `      - id: ${m}
+        name: ${m === "qwen3.8-max" ? "Qwen3.8-Max" : m === "qwen3.7-plus" ? "Qwen3.7-Plus" : m}
+        input: [text, image]
+        contextWindow: 1000000
+        maxTokens: 131072
+        reasoning: true
+        thinking:
+          mode: effort
+          efforts: [low, medium, high]`,
+    )
+    .join("\n");
+
   return `  qwenproxy:
     baseUrl: ${baseUrl}
     api: openai-completions
@@ -13,29 +36,12 @@ function buildOmpProviderYaml(baseUrl: string, apiKey: string): string {
       supportsReasoningEffort: true
       maxTokensField: max_completion_tokens
     models:
-      - id: qwen3.8-max
-        name: Qwen3.8-Max
-        input: [text, image]
-        contextWindow: 1000000
-        maxTokens: 131072
-        reasoning: true
-        thinking:
-          mode: effort
-          efforts: [low, medium, high]
-      - id: qwen3.7-plus
-        name: Qwen3.7-Plus
-        input: [text, image]
-        contextWindow: 1000000
-        maxTokens: 131072
-        reasoning: true
-        thinking:
-          mode: effort
-          efforts: [low, medium, high]
+${formattedModels}
 `;
 }
 
 export function syncOmp(options: SyncOptions): ClientSyncResult {
-  const { filePath, apiKey, baseUrl } = options;
+  const { filePath, apiKey, baseUrl, model = "qwen3.8-max" } = options;
   try {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
 
@@ -47,7 +53,7 @@ export function syncOmp(options: SyncOptions): ClientSyncResult {
       content = fs.readFileSync(filePath, "utf-8");
     }
 
-    const providerBlock = buildOmpProviderYaml(baseUrl, apiKey);
+    const providerBlock = buildOmpProviderYaml(baseUrl, apiKey, model);
 
     if (!content.trim()) {
       content = `providers:\n${providerBlock}`;

package/src/sync/opencode.ts

@@ -3,7 +3,36 @@ import path from "node:path";
 import type { ClientSyncResult, SyncOptions } from "./types.ts";
 import { createTimestampBackup, restoreFromBackup } from "./utils.ts";
 
-function buildOpenCodeProviderObject(baseUrl: string, apiKey: string): Record<string, any> {
+function buildOpenCodeProviderObject(
+  baseUrl: string,
+  apiKey: string,
+  primaryModel: string = "qwen3.8-max",
+): Record<string, any> {
+  const modelsObj: Record<string, any> = {};
+  const modelList = [primaryModel];
+  if (primaryModel !== "qwen3.7-plus") {
+    modelList.push("qwen3.7-plus");
+  }
+
+  for (const m of modelList) {
+    modelsObj[m] = {
+      name:
+        m === "qwen3.8-max"
+          ? "Qwen 3.8 Max"
+          : m === "qwen3.7-plus"
+            ? "Qwen 3.7 Plus"
+            : m,
+      limit: { context: 1048576, output: 65536 },
+      modalities: { input: ["text", "image"], output: ["text"] },
+      reasoning: true,
+      variants: {
+        low: { effort: "low" },
+        medium: { effort: "medium" },
+        high: { effort: "high" },
+      },
+    };
+  }
+
   return {
     npm: "@ai-sdk/openai-compatible",
     name: "QwenProxy",
@@ -11,30 +40,7 @@ function buildOpenCodeProviderObject(baseUrl: string, apiKey: string): Record<st
       baseURL: baseUrl,
       apiKey: apiKey,
     },
-    models: {
-      "qwen3.8-max": {
-        name: "Qwen 3.8 Max",
-        limit: { context: 1048576, output: 65536 },
-        modalities: { input: ["text", "image"], output: ["text"] },
-        reasoning: true,
-        variants: {
-          low: { effort: "low" },
-          medium: { effort: "medium" },
-          high: { effort: "high" },
-        },
-      },
-      "qwen3.7-plus": {
-        name: "Qwen 3.7 Plus",
-        limit: { context: 1048576, output: 65536 },
-        modalities: { input: ["text", "image"], output: ["text"] },
-        reasoning: true,
-        variants: {
-          low: { effort: "low" },
-          medium: { effort: "medium" },
-          high: { effort: "high" },
-        },
-      },
-    },
+    models: modelsObj,
   };
 }
 function findKeyObjectSpan(content: string, key: string): { start: number; end: number; hasTrailingComma: boolean } | null {
@@ -121,10 +127,8 @@ function findKeyObjectSpan(content: string, key: string): { start: number; end:
 }
 
 export function syncOpenCode(options: SyncOptions): ClientSyncResult {
-  const { filePath, apiKey, baseUrl } = options;
+  const { filePath, apiKey, baseUrl, model = "qwen3.8-max" } = options;
   try {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-
     let backupPath: string | undefined;
     let content = "";
 
@@ -133,10 +137,10 @@ export function syncOpenCode(options: SyncOptions): ClientSyncResult {
       content = fs.readFileSync(filePath, "utf-8");
     }
 
-    const providerObj = buildOpenCodeProviderObject(baseUrl, apiKey);
+    const providerObj = buildOpenCodeProviderObject(baseUrl, apiKey, model);
     const providerJson = JSON.stringify(providerObj, null, 6)
       .split("\n")
-      .map((line, idx) => (idx === 0 ? line : "    " + line))
+      .map((line, idx) => (idx === 0 ? line : `    ${line}`))
       .join("\n");
 
     const qwenEntry = `    "qwenproxy": ${providerJson}`;

package/src/tui/app.ts

@@ -11,7 +11,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-let cachedAppVersion = "v1.0.5";
+let cachedAppVersion = "";
 try {
   const currentDir = path.dirname(fileURLToPath(import.meta.url));
   const pkgPath = path.resolve(currentDir, "../../package.json");

package/src/tui/proxy-client.ts

@@ -279,66 +279,67 @@ export async function streamChatCompletions(
  * Fetches all live models dynamically from the running proxy /v1/models catalog.
  */
 let cachedLiveModels: string[] | null = null;
-let isFetchingLiveModels = false;
+let liveModelsPromise: Promise<string[]> | null = null;
 
-export async function fetchLiveModels(): Promise<string[]> {
-  if (cachedLiveModels && cachedLiveModels.length > 0) {
+const DEFAULT_FALLBACK_MODELS = [
+  "qwen3.8-max",
+  "qwen3.7-plus",
+  "qwen3.7-max",
+  "z-image-turbo",
+  "qwen-image-3.0-pro",
+  "qwen-image-3.0",
+  "wan2.7-image-pro",
+  "wan2.7-image",
+  "wan3.0-video",
+  "wan2.7-t2v",
+];
+
+export async function fetchLiveModels(forceRefresh = false): Promise<string[]> {
+  if (!forceRefresh && cachedLiveModels && cachedLiveModels.length > 0) {
     return cachedLiveModels;
   }
 
+  if (liveModelsPromise) {
+    return liveModelsPromise;
+  }
+
   const port = config.server?.port || 7936;
   const configuredHost = config.server?.host;
   const host = configuredHost && configuredHost !== "0.0.0.0" ? configuredHost : "127.0.0.1";
   const apiKey = config.apiKey || "sk-qwenproxy-local";
 
-  if (!isFetchingLiveModels) {
-    isFetchingLiveModels = true;
+  liveModelsPromise = (async () => {
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 2500);
-    fetch(`http://${host}:${port}/v1/models`, {
-      headers: { Authorization: `Bearer ${apiKey}` },
-      signal: controller.signal,
-    })
-      .then(async (resp) => {
-        clearTimeout(timeout);
-        if (resp.ok) {
-          const json = (await resp.json()) as any;
-          if (Array.isArray(json?.data)) {
-            const models = json.data
-              .map((m: any) => m.id)
-              .filter((id: any): id is string => typeof id === "string" && id.trim().length > 0)
-              .filter(
-                (id: string) =>
-                  !id.endsWith("-fast") &&
-                  !id.endsWith("-thinking") &&
-                  !id.endsWith("-no-thinking"),
-              );
-            if (models.length > 0) {
-              cachedLiveModels = Array.from(new Set(models));
-            }
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    try {
+      const resp = await fetch(`http://${host}:${port}/v1/models`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: controller.signal,
+      });
+      if (resp.ok) {
+        const json = (await resp.json()) as any;
+        if (Array.isArray(json?.data)) {
+          const models = json.data
+            .map((m: any) => m.id)
+            .filter((id: any): id is string => typeof id === "string" && id.trim().length > 0)
+            .filter(
+              (id: string) =>
+                !id.endsWith("-fast") &&
+                !id.endsWith("-thinking") &&
+                !id.endsWith("-no-thinking"),
+            );
+          if (models.length > 0) {
+            cachedLiveModels = Array.from(new Set(models));
+            return cachedLiveModels;
           }
         }
-      })
-      .catch(() => {
-        clearTimeout(timeout);
-      })
-      .finally(() => {
-        isFetchingLiveModels = false;
-      });
-  }
+      }
+    } catch {} finally {
+      clearTimeout(timeout);
+      liveModelsPromise = null;
+    }
+    return cachedLiveModels || DEFAULT_FALLBACK_MODELS;
+  })();
 
-  return (
-    cachedLiveModels || [
-      "qwen3.8-max",
-      "qwen3.7-plus",
-      "qwen3.7-max",
-      "z-image-turbo",
-      "qwen-image-3.0-pro",
-      "qwen-image-3.0",
-      "wan2.7-image-pro",
-      "wan2.7-image",
-      "wan3.0-video",
-      "wan2.7-t2v",
-    ]
-  );
+  return liveModelsPromise;
 }

package/src/tui/views/chat-view.ts

@@ -341,6 +341,7 @@ export class ChatView implements TuiView {
       (key.ctrl && key.name === "o") ||
       (key.meta && key.name === "m")
     ) {
+      void this.refreshModels();
       this.isModelModalOpen = true;
       this.modalSelectedIndex = this.selectedModelIndex;
       this.onNeedsRender?.();

package/src/update-cli.ts

@@ -27,17 +27,32 @@ export function detectPackageManager(): PackageManager {
 
   return "npm";
 }
-export function getUpdateArgs(pm: PackageManager, packageName: string): { cmd: string; args: string[] } {
+export function getUpdateArgs(
+  pm: PackageManager,
+  packageName: string,
+  targetVersion?: string,
+): { cmd: string; args: string[] } {
+  const versionTag = targetVersion ? `@${targetVersion}` : "@latest";
   switch (pm) {
     case "bun":
-      return { cmd: "bun", args: ["add", "-g", `${packageName}@latest`] };
+      return { cmd: "bun", args: ["add", "-g", `${packageName}${versionTag}`] };
     case "pnpm":
-      return { cmd: "pnpm", args: ["update", "-g", packageName] };
+      return {
+        cmd: "pnpm",
+        args: targetVersion
+          ? ["add", "-g", `${packageName}@${targetVersion}`]
+          : ["update", "-g", packageName],
+      };
     case "yarn":
-      return { cmd: "yarn", args: ["global", "upgrade", packageName] };
+      return {
+        cmd: "yarn",
+        args: targetVersion
+          ? ["global", "add", `${packageName}@${targetVersion}`]
+          : ["global", "upgrade", packageName],
+      };
     case "npm":
     default:
-      return { cmd: "npm", args: ["install", "-g", `${packageName}@latest`] };
+      return { cmd: "npm", args: ["install", "-g", `${packageName}${versionTag}`] };
   }
 }
 
@@ -93,7 +108,7 @@ export async function runUpdateCommand(): Promise<void> {
   }
 
   console.log(`\n🚀 Nova versão disponível: v${currentVersion} ➔ v${latestVersion}`);
-  const { cmd, args } = getUpdateArgs(pm, packageName);
+  const { cmd, args } = getUpdateArgs(pm, packageName, latestVersion);
   console.log(`⏳ Atualizando globalmente via ${pm} (${cmd} ${args.join(" ")})...`);
   const fullUpdateCmd = `${cmd} ${args.join(" ")}`;
   const updateProc = spawnSync(fullUpdateCmd, {