fix: dynamic User-Agent detection for platform and architecture

- Add platform detection utility (Linux, macOS, Windows, etc.)
- Add architecture detection (x64, arm64, ia32, etc.)
- Generate User-Agent header dynamically instead of hardcoded Linux/x64
- Maintain qwen-code v0.12.0 client version for compatibility
- Add 9 unit tests for platform detection
- Update CHANGELOG with fix documentation

Fixes authentication on non-Linux systems and ARM devices (M1/M2/M3 Macs, Raspberry Pi)

Author: luanweslley77

CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### 🔧 Fixes
+
+- **Dynamic User-Agent detection** - User-Agent header now dynamically detects platform and architecture instead of hardcoded Linux/x64
+  - Supports Linux, macOS, Windows, FreeBSD, OpenBSD, Solaris, AIX
+  - Supports x64, arm64, ia32, ppc64, arm, mips architectures
+  - Maintains qwen-code v0.12.0 client version for compatibility
+  - Fixes authentication on non-Linux systems and ARM devices (M1/M2/M3 Macs, Raspberry Pi, etc.)
+
+
 ## [1.5.0] - 2026-03-14 (Updated)
 
 ### 🚨 Critical Fixes

src/constants.ts

@@ -89,9 +89,14 @@ export const QWEN_MODELS = {
 } as const;
 
 // Official Qwen Code CLI Headers for performance and quota recognition
-export const QWEN_OFFICIAL_HEADERS = {
-  'X-DashScope-CacheControl': 'enable',
-  'X-DashScope-AuthType': 'qwen-oauth',
-  'X-DashScope-UserAgent': 'QwenCode/0.12.0 (Linux; x64)',
-  'User-Agent': 'QwenCode/0.12.0 (Linux; x64)'
-} as const;
+// User-Agent is generated dynamically based on current platform
+import { generateUserAgent, generateDashScopeUserAgent } from './utils/user-agent.js';
+
+export function getQwenHeaders(): Record<string, string> {
+  return {
+    'X-DashScope-CacheControl': 'enable',
+    'X-DashScope-AuthType': 'qwen-oauth',
+    'X-DashScope-UserAgent': generateDashScopeUserAgent(),
+    'User-Agent': generateUserAgent(),
+  };
+}

src/index.ts

@@ -11,7 +11,7 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 
-import { QWEN_PROVIDER_ID, QWEN_API_CONFIG, QWEN_MODELS, QWEN_OFFICIAL_HEADERS } from './constants.js';
+import { QWEN_PROVIDER_ID, QWEN_API_CONFIG, QWEN_MODELS, getQwenHeaders } from './constants.js';
 import type { QwenCredentials } from './types.js';
 import { resolveBaseUrl } from './plugin/auth.js';
 import {
@@ -108,7 +108,7 @@ export const QwenAuthPlugin = async (_input: unknown) => {
           apiKey: credentials.accessToken,
           baseURL: baseURL,
           headers: {
-            ...QWEN_OFFICIAL_HEADERS,
+            ...getQwenHeaders(),
           },
           // Custom fetch with throttling, retry and 401 recovery
           fetch: async (url: string, options: any = {}) => {
@@ -124,7 +124,7 @@ export const QwenAuthPlugin = async (_input: unknown) => {
 
                 // Prepare merged headers
                 const mergedHeaders: Record<string, string> = {
-                  ...QWEN_OFFICIAL_HEADERS,
+                  ...getQwenHeaders(),
                 };
 
                 // Merge provided headers (handles both plain object and Headers instance)
@@ -266,13 +266,13 @@ export const QwenAuthPlugin = async (_input: unknown) => {
     config: async (config: Record<string, unknown>) => {
       const providers = (config.provider as Record<string, unknown>) || {};
 
-      providers[QWEN_PROVIDER_ID] = {
-        npm: '@ai-sdk/openai-compatible',
-        name: 'Qwen Code',
-        options: { 
-          baseURL: QWEN_API_CONFIG.baseUrl,
-          headers: QWEN_OFFICIAL_HEADERS
-        },
+        providers[QWEN_PROVIDER_ID] = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Qwen Code',
+          options: { 
+            baseURL: QWEN_API_CONFIG.baseUrl,
+            headers: getQwenHeaders()
+          },
         models: Object.fromEntries(
           Object.entries(QWEN_MODELS).map(([id, m]) => {
             const hasVision = 'capabilities' in m && m.capabilities?.vision;

src/utils/platform.ts

@@ -0,0 +1,44 @@
+/**
+ * Platform detection utilities
+ * Detects OS and architecture dynamically for User-Agent generation
+ */
+
+const PLATFORM_MAP: Record<string, string> = {
+  linux: 'Linux',
+  darwin: 'macOS',
+  win32: 'Windows',
+  freebsd: 'FreeBSD',
+  openbsd: 'OpenBSD',
+  sunos: 'Solaris',
+  aix: 'AIX',
+};
+
+const ARCH_MAP: Record<string, string> = {
+  x64: 'x64',
+  arm64: 'arm64',
+  ia32: 'ia32',
+  ppc64: 'ppc64',
+  arm: 'arm',
+  mips: 'mips',
+};
+
+/**
+ * Detect current platform and return human-readable name
+ */
+export function detectPlatform(): string {
+  return PLATFORM_MAP[process.platform] || 'Unknown';
+}
+
+/**
+ * Detect current architecture and return human-readable name
+ */
+export function detectArch(): string {
+  return ARCH_MAP[process.arch] || 'unknown';
+}
+
+/**
+ * Get platform info in format suitable for User-Agent
+ */
+export function getPlatformInfo(): string {
+  return `${detectPlatform()}; ${detectArch()}`;
+}

src/utils/user-agent.ts

@@ -0,0 +1,32 @@
+/**
+ * User-Agent generator for Qwen Code client emulation
+ * 
+ * Emulates the official qwen-code CLI User-Agent format:
+ * QwenCode/{version} ({platform}; {arch})
+ * 
+ * Example: QwenCode/0.12.0 (Linux; x64)
+ */
+
+import { getPlatformInfo } from './platform.js';
+
+/**
+ * Version of the official qwen-code client that we're emulating.
+ * Update this when the official client updates to a new version.
+ */
+const QWEN_CODE_VERSION = '0.12.0';
+
+/**
+ * Generate User-Agent string with dynamic platform detection
+ */
+export function generateUserAgent(): string {
+  const platformInfo = getPlatformInfo();
+  return `QwenCode/${QWEN_CODE_VERSION} (${platformInfo})`;
+}
+
+/**
+ * Generate X-DashScope-UserAgent header value
+ * (same as User-Agent for now, but separated for future customization)
+ */
+export function generateDashScopeUserAgent(): string {
+  return generateUserAgent();
+}

tests/debug.ts

@@ -15,18 +15,18 @@ import {
   refreshAccessToken,
   isCredentialsExpired,
   SlowDownError,
-} from '../src/qwen/oauth.js';
+} from '../../src/qwen/oauth.js';
 import {
   loadCredentials,
   saveCredentials,
   resolveBaseUrl,
   getCredentialsPath,
-} from '../src/plugin/auth.js';
-import { QWEN_API_CONFIG, QWEN_OAUTH_CONFIG, QWEN_OFFICIAL_HEADERS } from '../src/constants.js';
-import { retryWithBackoff, getErrorStatus } from '../src/utils/retry.js';
-import { RequestQueue } from '../src/plugin/request-queue.js';
-import { tokenManager } from '../src/plugin/token-manager.js';
-import type { QwenCredentials } from '../src/types.js';
+} from '../../src/plugin/auth.js';
+import { QWEN_API_CONFIG, QWEN_OAUTH_CONFIG, getQwenHeaders } from '../../src/constants.js';
+import { retryWithBackoff, getErrorStatus } from '../../src/utils/retry.js';
+import { RequestQueue } from '../../src/plugin/request-queue.js';
+import { tokenManager } from '../../src/plugin/token-manager.js';
+import type { QwenCredentials } from '../../src/types.js';
 
 // ============================================
 // Logging Utilities
@@ -244,7 +244,7 @@ async function testRealChat(): Promise<boolean> {
   log('DEBUG', 'RealChat', `Token: ${creds.accessToken.substring(0, 10)}...`);
 
   const headers = {
-    ...QWEN_OFFICIAL_HEADERS,
+    ...getQwenHeaders(),
     'Authorization': `Bearer ${creds.accessToken}`,
     'Content-Type': 'application/json',
   };

tests/unit/platform.test.ts

@@ -0,0 +1,67 @@
+import { describe, test, expect } from 'bun:test';
+import { detectPlatform, detectArch, getPlatformInfo } from '../../src/utils/platform.js';
+import { generateUserAgent } from '../../src/utils/user-agent.js';
+
+describe('Platform Detection', () => {
+  test('should detect current platform', () => {
+    const platform = detectPlatform();
+    expect(platform).toBeTruthy();
+    expect(typeof platform).toBe('string');
+    expect(platform.length).toBeGreaterThan(0);
+  });
+
+  test('should detect current architecture', () => {
+    const arch = detectArch();
+    expect(arch).toBeTruthy();
+    expect(typeof arch).toBe('string');
+    expect(arch.length).toBeGreaterThan(0);
+  });
+
+  test('should return valid platform info format', () => {
+    const platformInfo = getPlatformInfo();
+    expect(platformInfo).toContain('; ');
+    const [platform, arch] = platformInfo.split('; ');
+    expect(platform).toBeTruthy();
+    expect(arch).toBeTruthy();
+  });
+});
+
+describe('User-Agent Generation', () => {
+  test('should generate valid User-Agent format', () => {
+    const userAgent = generateUserAgent();
+    expect(userAgent).toMatch(/^QwenCode\/\d+\.\d+\.\d+ \(.+; .+\)$/);
+  });
+
+  test('should include version 0.12.0', () => {
+    const userAgent = generateUserAgent();
+    expect(userAgent).toContain('QwenCode/0.12.0');
+  });
+
+  test('should include detected platform', () => {
+    const userAgent = generateUserAgent();
+    const platform = detectPlatform();
+    expect(userAgent).toContain(platform);
+  });
+
+  test('should include detected architecture', () => {
+    const userAgent = generateUserAgent();
+    const arch = detectArch();
+    expect(userAgent).toContain(arch);
+  });
+});
+
+describe('Platform Mapping', () => {
+  test('should map known platforms correctly', () => {
+    // This test verifies the mapping logic works
+    // Actual values depend on the runtime environment
+    const platform = detectPlatform();
+    const knownPlatforms = ['Linux', 'macOS', 'Windows', 'FreeBSD', 'OpenBSD', 'Solaris', 'AIX', 'Unknown'];
+    expect(knownPlatforms).toContain(platform);
+  });
+
+  test('should map known architectures correctly', () => {
+    const arch = detectArch();
+    const knownArches = ['x64', 'arm64', 'ia32', 'ppc64', 'arm', 'mips', 'unknown'];
+    expect(knownArches).toContain(arch);
+  });
+});