@seaverse/auth-sdk 0.4.0 → 0.4.2

package/README.md

@@ -1,129 +1,129 @@
 # @seaverse/auth-sdk
 
-SeaVerse Backend API 客户端 SDK - 提供完整的认证、容器管理、技能市场等功能
+SeaVerse Backend API Client SDK - Provides complete authentication, container management, skill marketplace, and more
 
 [![npm version](https://img.shields.io/npm/v/@seaverse/auth-sdk.svg)](https://www.npmjs.com/package/@seaverse/auth-sdk)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## 功能特性
+## Features
 
-- 🔐 **用户认证** - 注册、登录、登出、密码重置
-- 🌐 **OAuth登录** - Google、Discord、GitHub 第三方登录
-- 🎨 **登录UI组件** - 开箱即用的精美登录弹窗
-- ✨ **Toast 通知** - 现代化玻璃态提示，CSS 自动注入
-- 🌍 **多环境支持** - Production、Staging、Development、Local
-- ⚡ **TypeScript** - 完整的类型定义
-- 🔧 **认证集成** - 内置Auth、Hooks系统支持
-- 🔄 **响应格式兼容** - 自动兼容多种API响应格式
+- 🔐 **User Authentication** - Registration, login, logout, password reset
+- 🌐 **OAuth Login** - Google, Discord, GitHub third-party login
+- 🎨 **Login UI Components** - Out-of-the-box beautiful login modal
+- ✨ **Toast Notifications** - Modern glassmorphism alerts with auto-injected CSS
+- 🌍 **Multi-Environment Support** - Production, Staging, Development, Local
+- ⚡ **TypeScript** - Full type definitions
+- 🔧 **Auth Integration** - Built-in Auth and Hooks system support
+- 🔄 **Response Format Compatibility** - Automatic compatibility with multiple API response formats
 
-## 安装
+## Installation
 
 ```bash
 npm install @seaverse/auth-sdk
-# 或
+# or
 pnpm add @seaverse/auth-sdk
 ```
 
-## 核心概念
+## Core Concepts
 
-### App ID 和多租户架构
+### App ID and Multi-Tenant Architecture
 
-**重要**: 从 v0.2.0 开始，`appId` 是初始化 SDK 时的**必需参数**。
+**Important**: Starting from v0.2.0, `appId` is a **required parameter** when initializing the SDK.
 
-#### 什么是 App ID？
+#### What is App ID?
 
-每个应用都有唯一的 `app_id`：
+Each application has a unique `app_id`:
 - `app_id = "your app id"`
 
-#### 多租户隔离
+#### Multi-Tenant Isolation
 
-- 用户数据按 `app_id` 隔离
-- 同一邮箱可在不同应用中注册，使用不同密码
-- 每个应用拥有独立的用户池
+- User data is isolated by `app_id`
+- The same email can be registered in different applications with different passwords
+- Each application has its own independent user pool
 
-#### X-App-ID 请求头
+#### X-App-ID Request Header
 
-SDK 会自动在**每个请求**的请求头中添加 `X-App-ID`，无需手动设置：
+The SDK automatically adds `X-App-ID` to **every request** header, no manual configuration needed:
 
 ```typescript
 const client = new SeaVerseBackendAPIClient({
-  appId: 'game-abc123',  // SDK 自动将此值添加到所有请求的 X-App-ID header
+  appId: 'game-abc123',  // SDK automatically adds this value to all requests' X-App-ID header
 });
 
-// 所有 API 调用都会自动携带 X-App-ID: game-abc123
+// All API calls will automatically carry X-App-ID: game-abc123
 await client.login({ email, password });
 await client.getCurrentUser();
 ```
 
-## 快速开始
+## Quick Start
 
-### 1. 基本使用
+### 1. Basic Usage
 
 ```typescript
 import { SeaVerseBackendAPIClient } from '@seaverse/auth-sdk';
 
-// 方式1: SeaVerse 平台应用（自动检测环境）
+// Method 1: SeaVerse platform application (auto-detect environment)
 const client = new SeaVerseBackendAPIClient({
-  appId: 'your app id', // 必需：应用ID
+  appId: 'your app id', // Required: Application ID
 });
 
-// 方式2: 第三方应用（指定环境）
+// Method 2: Third-party application (specify environment)
 const client = new SeaVerseBackendAPIClient({
-  appId: 'your app id',        // 必需：您的应用ID
+  appId: 'your app id',        // Required: Your application ID
   environment: 'production',   // 'production' | 'staging' | 'development' | 'local'
 });
 
-// 方式3: 自定义URL
+// Method 3: Custom URL
 const client = new SeaVerseBackendAPIClient({
-  appId: 'your app id',             // 必需：您的应用ID
+  appId: 'your app id',             // Required: Your application ID
   baseURL: 'https://custom-api.example.com',
 });
 
-// 方式4: 启用请求重试（默认禁用）
+// Method 4: Enable request retry (disabled by default)
 const client = new SeaVerseBackendAPIClient({
   appId: 'your app id',
   retryOptions: {
-    maxRetries: 3,                  // 最多重试 3 次
-    retryDelay: 1000,               // 初始延迟 1000ms，每次重试延迟加倍
-    retryStatusCodes: [408, 429, 500, 502, 503, 504],  // 这些状态码会触发重试
+    maxRetries: 3,                  // Retry up to 3 times
+    retryDelay: 1000,               // Initial delay 1000ms, doubles each retry
+    retryStatusCodes: [408, 429, 500, 502, 503, 504],  // Retry on these status codes
   },
 });
 
-// 健康检查
+// Health check
 const health = await client.getHealth();
 console.log('Health:', health);
 ```
 
-### 2. Iframe 场景下的 Token 获取
+### 2. Token Retrieval in Iframe Scenarios
 
-当你的应用被嵌入到 iframe 中时，可以使用 `getIframeToken()` 方法从父页面获取认证 token。这对于第三方登录重定向场景特别有用。
+When your application is embedded in an iframe, you can use the `getIframeToken()` method to retrieve the authentication token from the parent page. This is particularly useful for third-party login redirect scenarios.
 
-#### 检查是否在 iframe 中运行
+#### Check if Running in Iframe
 
-在调用 iframe 相关方法前，建议先检查应用是否在 iframe 中运行：
+Before calling iframe-related methods, it's recommended to check if the application is running in an iframe:
 
 ```typescript
 import { SeaVerseBackendAPIClient } from '@seaverse/auth-sdk';
 
-// 方式 1: 使用静态方法（无需 client 实例）
+// Method 1: Use static method (no client instance needed)
 if (SeaVerseBackendAPIClient.isInIframe()) {
-  console.log('应用正在 iframe 中运行');
+  console.log('Application is running in iframe');
 } else {
-  console.log('应用不在 iframe 中运行');
+  console.log('Application is not running in iframe');
 }
 
-// 方式 2: 使用实例方法
+// Method 2: Use instance method
 const client = new SeaVerseBackendAPIClient({
   appId: 'your app id',
 });
 
 if (client.isInIframe()) {
-  console.log('应用正在 iframe 中运行');
-  // 可以安全地调用 getIframeToken()
+  console.log('Application is running in iframe');
+  // Safe to call getIframeToken()
 }
 ```
 
-#### 子页面 (iframe 内) 使用方式
+#### Child Page (Inside Iframe) Usage
 
 ```typescript
 import { SeaVerseBackendAPIClient } from '@seaverse/auth-sdk';
@@ -132,46 +132,46 @@ const client = new SeaVerseBackendAPIClient({
   appId: 'your app id',
 });
 
-// 先检查是否在 iframe 中
+// First check if running in iframe
 if (!client.isInIframe()) {
-  console.log('应用不在 iframe 中，跳过 token 获取');
-  // 可以使用其他登录方式
+  console.log('Not in iframe, skip token retrieval');
+  // Can use other login methods
 } else {
-  // 在 iframe 中请求父页面的 token
+  // Request token from parent page while in iframe
   try {
     const token = await client.getIframeToken({
-      timeout: 10000 // 可选，默认 30 秒
+      timeout: 10000 // Optional, default 30 seconds
     });
 
-    // 设置 token 到 client
+    // Set token to client
     client.setToken(token);
     localStorage.setItem('token', token);
 
-    console.log('成功从父页面获取 token');
+    console.log('Successfully retrieved token from parent page');
 
-    // 现在可以使用需要认证的 API
+    // Now can use authenticated APIs
     const user = await client.getCurrentUser();
-    console.log('当前用户:', user);
+    console.log('Current user:', user);
   } catch (error) {
-    console.error('获取 token 失败:', error);
+    console.error('Failed to retrieve token:', error);
   }
 }
 ```
 
-#### 父页面监听并响应 token 请求
+#### Parent Page Listens and Responds to Token Requests
 
 ```typescript
-// 父页面需要监听来自 iframe 的 token 请求
+// Parent page needs to listen for token requests from iframe
 window.addEventListener('message', (event) => {
-  // 检查消息类型
+  // Check message type
   if (event.data.type === 'seaverse:get_token') {
     const requestId = event.data.requestId;
 
-    // 获取你的 token (从 localStorage、API 等)
+    // Get your token (from localStorage, API, etc)
     const token = localStorage.getItem('token');
 
     if (token) {
-      // 发送 token 给 iframe
+      // Send token to iframe
       event.source.postMessage({
         type: 'seaverse:token',
         requestId: requestId,
@@ -181,7 +181,7 @@ window.addEventListener('message', (event) => {
         },
       }, '*');
     } else {
-      // 发送错误消息
+      // Send error message
       event.source.postMessage({
         type: 'seaverse:token_error',
         requestId: requestId,
@@ -192,10 +192,10 @@ window.addEventListener('message', (event) => {
 });
 ```
 
-#### 完整的 iframe 登录流程示例
+#### Complete Iframe Login Flow Example
 
 ```typescript
-// 子页面 (iframe)
+// Child page (iframe)
 import { SeaVerseBackendAPIClient } from '@seaverse/auth-sdk';
 
 const client = new SeaVerseBackendAPIClient({
@@ -203,28 +203,28 @@ const client = new SeaVerseBackendAPIClient({
 });
 
 async function initIframeApp() {
-  // 0. 检查是否在 iframe 中
+  // 0. Check if running in iframe
   if (!client.isInIframe()) {
-    console.log('应用不在 iframe 中，使用常规登录流程');
-    // 使用常规登录流程
+    console.log('Not in iframe, use regular login flow');
+    // Use regular login flow
     showLoginForm();
     return;
   }
 
   try {
-    // 1. 尝试从父页面获取 token
+    // 1. Try to get token from parent page
     const token = await client.getIframeToken();
     client.setToken(token);
     localStorage.setItem('token', token);
 
-    // 2. 验证 token 并获取用户信息
+    // 2. Validate token and get user info
     const user = await client.getCurrentUser();
-    console.log('已登录:', user);
+    console.log('Logged in:', user);
 
-    // 3. 继续应用逻辑
+    // 3. Continue app logic
     startApp(user);
   } catch (error) {
-    // 4. 如果获取失败，通知父页面需要登录
+    // 4. If failed, notify parent page that login is needed
     window.parent.postMessage({
       type: 'seaverse:need_login',
     }, '*');
@@ -235,9 +235,9 @@ initIframeApp();
 ```
 
 ```typescript
-// 父页面
+// Parent page
 window.addEventListener('message', (event) => {
-  // 处理 token 请求
+  // Handle token request
   if (event.data.type === 'seaverse:get_token') {
     const requestId = event.data.requestId;
     const token = localStorage.getItem('token');
@@ -252,23 +252,23 @@ window.addEventListener('message', (event) => {
         },
       }, '*');
     } else {
-      // 如果没有 token，唤起登录
+      // If no token, trigger login
       showLoginModal();
     }
   }
 
-  // 处理需要登录的消息
+  // Handle need login message
   if (event.data.type === 'seaverse:need_login') {
     showLoginModal();
   }
 });
 
-// 登录成功后，通知 iframe
+// After successful login, notify iframe
 function onLoginSuccess(newToken) {
   const iframe = document.querySelector('iframe');
   iframe.contentWindow.postMessage({
     type: 'seaverse:token',
-    requestId: 'auto', // 自动登录时可以使用固定 ID
+    requestId: 'auto', // Can use fixed ID for auto-login
     payload: {
       accessToken: newToken,
       expiresIn: 3600,
@@ -277,9 +277,9 @@ function onLoginSuccess(newToken) {
 }
 ```
 
-#### TypeScript 类型定义
+#### TypeScript Type Definitions
 
-SDK 提供了完整的 TypeScript 类型支持:
+The SDK provides complete TypeScript type support:
 
 ```typescript
 import type {
@@ -288,13 +288,13 @@ import type {
   IframeTokenErrorMessage,
 } from '@seaverse/auth-sdk';
 
-// Token 请求消息
+// Token request message
 const request: IframeTokenRequestMessage = {
   type: 'seaverse:get_token',
   requestId: 'unique-id',
 };
 
-// Token 响应消息
+// Token response message
 const response: IframeTokenResponseMessage = {
   type: 'seaverse:token',
   requestId: 'unique-id',
@@ -304,7 +304,7 @@ const response: IframeTokenResponseMessage = {
   },
 };
 
-// 错误消息
+// Error message
 const error: IframeTokenErrorMessage = {
   type: 'seaverse:token_error',
   requestId: 'unique-id',
@@ -312,328 +312,328 @@ const error: IframeTokenErrorMessage = {
 };
 ```
 
-#### 安全注意事项
+#### Security Considerations
 
-1. **使用特定 origin**: 在生产环境中，建议使用特定的 origin 而不是 `'*'`:
+1. **Use specific origin**: In production, use specific origin instead of `'*'`:
    ```typescript
-   // 父页面
+   // Parent page
    const ALLOWED_ORIGIN = 'https://your-iframe-domain.com';
    event.source.postMessage(message, ALLOWED_ORIGIN);
 
-   // 子页面发送时也可以指定
+   // Child page can also specify when sending
    window.parent.postMessage(message, 'https://parent-domain.com');
    ```
 
-2. **验证消息来源**: 在处理 postMessage 时验证 origin:
+2. **Verify message origin**: Validate origin when handling postMessage:
    ```typescript
    window.addEventListener('message', (event) => {
-     // 验证来源
+     // Verify origin
      if (event.origin !== 'https://trusted-domain.com') {
        return;
      }
-     // 处理消息...
+     // Handle message...
    });
    ```
 
-3. **Token 过期处理**: 记得处理 token 过期的情况:
+3. **Handle token expiration**: Remember to handle token expiration:
    ```typescript
    try {
      const user = await client.getCurrentUser();
    } catch (error) {
      if (error.response?.status === 401) {
-       // Token 过期，重新获取
+       // Token expired, re-retrieve
        const newToken = await client.getIframeToken();
        client.setToken(newToken);
      }
    }
    ```
 
-### 3. 用户认证
+### 3. User Authentication
 
 ```typescript
-// 注册新用户
+// Register new user
 const registerResult = await client.register({
   email: 'user@example.com',
   password: 'SecurePassword123',
-  username: 'johndoe',              // 可选，未提供则从邮箱自动生成
-  invitation_code: 'INVITE123',     // 可选
-  frontend_url: 'https://mygame.com/verify',  // 可选，邮箱验证链接的前端URL，默认为 window.location.href
+  username: 'johndoe',              // Optional, auto-generated from email if not provided
+  invitation_code: 'INVITE123',     // Optional
+  frontend_url: 'https://mygame.com/verify',  // Optional, frontend URL for email verification link, defaults to window.location.href
 });
 
-// 检查注册结果
+// Check registration result
 if (registerResult.success) {
-  console.log('注册成功:', registerResult);
+  console.log('Registration successful:', registerResult);
 } else if (registerResult.code === 'ACCOUNT_EXISTS') {
-  console.log('账户已存在，请直接登录');
-  console.log('错误详情:', registerResult.details);
+  console.log('Account exists, please login directly');
+  console.log('Error details:', registerResult.details);
 }
 
-// 登录
+// Login
 const loginResult = await client.login({
   email: 'user@example.com',
   password: 'SecurePassword123',
 });
 
-// 保存token
+// Save token
 localStorage.setItem('token', loginResult.token);
 
-// ⚠️ 注意：邀请码自动跳转
-// 如果服务器返回 INVITE_CODE_REQUIRED 错误且包含 redirectUrl，
-// SDK 会自动将用户重定向到该 URL（通常是邀请码输入页面）
-// 无需额外处理，页面会自动跳转
+// ⚠️ Note: Automatic invitation code redirect
+// If server returns INVITE_CODE_REQUIRED error and includes redirectUrl,
+// SDK will automatically redirect user to that URL (usually invitation code input page)
+// No extra handling needed, page will redirect automatically
 
-// 获取当前用户信息
+// Get current user info
 const user = await client.getCurrentUser();
 console.log('User:', user);
-console.log('App ID:', user.app_id);           // 多租户应用ID
+console.log('App ID:', user.app_id);           // Multi-tenant application ID
 console.log('Email verified:', user.email_verified);
 
-// 登出
+// Logout
 await client.logout();
 
-// 忘记密码
+// Forgot password
 await client.forgotPassword({
   email: 'user@example.com',
-  frontend_url: 'https://mygame.com/',  // 可选，默认为 window.location.href
+  frontend_url: 'https://mygame.com/',  // Optional, defaults to window.location.href
 });
 
-// 重置密码
+// Reset password
 await client.resetPassword({
   token: 'reset-token-from-email',
   new_password: 'NewSecurePassword123',
 });
 ```
 
-### 4. OAuth 第三方登录 (Backend Proxy Mode)
+### 4. OAuth Third-Party Login (Backend Proxy Mode)
 
-SDK 使用 Backend Proxy Mode，Client Secret 永不暴露给前端，安全性更高。
+The SDK uses Backend Proxy Mode where Client Secret is never exposed to the frontend, providing higher security.
 
-**优势**:
-- ✅ Client Secret 从不暴露给前端
-- ✅ 支持任意开发者域名(无需在 OAuth 平台配置)
-- ✅ 内置 CSRF 防护
-- ✅ 零配置，开箱即用
+**Advantages**:
+- ✅ Client Secret is never exposed to frontend
+- ✅ Supports any developer domain (no need to configure in OAuth platform)
+- ✅ Built-in CSRF protection
+- ✅ Zero configuration, works out of the box
 
-**工作流程**:
-1. 前端调用 `{provider}Authorize()` 获取 OAuth URL
-2. 前端重定向用户到 OAuth 提供商
-3. 用户授权后，OAuth 提供商回调到固定的 account-hub URL
-4. account-hub 处理 OAuth，创建 JWT token
-5. account-hub 302 重定向到 `return_url?token=xxx`
-6. 前端从 URL 提取 token 并存储
+**Workflow**:
+1. Frontend calls `{provider}Authorize()` to get OAuth URL
+2. Frontend redirects user to OAuth provider
+3. After user authorization, OAuth provider callbacks to fixed account-hub URL
+4. account-hub handles OAuth, creates JWT token
+5. account-hub 302 redirects to `return_url?token=xxx`
+6. Frontend extracts token from URL and stores it
 
-#### 使用示例
+#### Usage Examples
 
-**方式1：使用默认 return_url（当前页面）**
+**Method 1: Use default return_url (current page)**
 
 ```typescript
-// Google 登录
+// Google login
 const { authorize_url } = await client.googleAuthorize();
 window.location.href = authorize_url;
 
-// Discord 登录
+// Discord login
 const { authorize_url } = await client.discordAuthorize();
 window.location.href = authorize_url;
 
-// GitHub 登录
+// GitHub login
 const { authorize_url } = await client.githubAuthorize();
 window.location.href = authorize_url;
 ```
 
-**方式2：自定义 return_url**
+**Method 2: Custom return_url**
 
 ```typescript
-// 登录后跳转到 dashboard
+// Redirect to dashboard after login
 const { authorize_url } = await client.googleAuthorize({
   return_url: 'https://mygame.com/dashboard'
 });
 window.location.href = authorize_url;
 ```
 
-**在回调页面提取 token**:
+**Extract token in callback page**:
 
 ```typescript
 // URL: https://mygame.com/?token=eyJhbGc...
 const token = new URLSearchParams(window.location.search).get('token');
 if (token) {
   localStorage.setItem('token', token);
-  // 登录成功，跳转或更新 UI
+  // Login successful, redirect or update UI
 }
 ```
 
-#### OAuth 账号解绑
+#### OAuth Account Unlinking
 
 ```typescript
-// 解绑 Google 账号
+// Unlink Google account
 await client.unlinkGoogle();
 
-// 解绑 Discord 账号
+// Unlink Discord account
 await client.unlinkDiscord();
 
-// 解绑 GitHub 账号
+// Unlink GitHub account
 await client.unlinkGithub();
 ```
 
-### 5. 使用登录UI组件
+### 5. Using Login UI Components
 
-SDK 提供精美的登录弹窗组件，支持深色和浅色两种主题：
+The SDK provides beautiful login modal components with dark and light themes:
 
-#### 主题对比
+#### Theme Comparison
 
-| 主题 | 设计风格 | 适用场景 |
+| Theme | Design Style | Use Cases |
 |------|---------|---------|
-| **Dark** 🌙 | 动态网格渐变 + 玻璃态效果 | 科技感产品、游戏平台、深色界面应用 |
-| **Light** ☀️ | 提升的卡片设计 + 柔和阴影 | 商务应用、内容平台、浅色界面应用 |
+| **Dark** 🌙 | Dynamic grid gradient + glassmorphism | Tech products, gaming platforms, dark interface apps |
+| **Light** ☀️ | Elevated card design + soft shadows | Business apps, content platforms, light interface apps |
 
-#### 基础用法
+#### Basic Usage
 
 ```typescript
 import { SeaVerseBackendAPIClient, AuthModal } from '@seaverse/auth-sdk';
-import '@seaverse/auth-sdk/auth-modal.css'; // 导入样式
+import '@seaverse/auth-sdk/auth-modal.css'; // Import styles
 
 const client = new SeaVerseBackendAPIClient({
-  appId: 'your app id',         // 必需：您的应用ID
+  appId: 'your app id',         // Required: Your application ID
   environment: 'production',
 });
 
-// 创建登录弹窗
+// Create login modal
 const authModal = new AuthModal({
   client,
-  theme: 'dark', // 'dark' | 'light' - 默认为 'dark'
+  theme: 'dark', // 'dark' | 'light' - defaults to 'dark'
 
-  // 登录成功回调
+  // Login success callback
   onLoginSuccess: (token, user) => {
     localStorage.setItem('token', token);
-    console.log('登录成功:', user);
+    console.log('Login successful:', user);
   },
 
-  // 注册成功回调
+  // Signup success callback
   onSignupSuccess: (token, user) => {
     localStorage.setItem('token', token);
-    console.log('注册成功:', user);
+    console.log('Signup successful:', user);
   },
 
-  // 邀请码需求回调（可选）
+  // Invitation code required callback (optional)
   onInviteCodeRequired: (userId, email) => {
-    console.log('需要邀请码激活账户:', userId, email);
-    // AuthModal 会自动显示邀请码输入界面
+    console.log('Need invitation code to activate account:', userId, email);
+    // AuthModal will automatically show invitation code input interface
   },
 
-  // 申请邀请码成功回调（可选）
+  // Apply invite success callback (optional)
   onApplyInviteSuccess: (applicationId, email) => {
-    console.log('邀请码申请已提交:', applicationId, email);
-    // 可以在这里添加自定义逻辑,如显示提示信息
+    console.log('Invitation code application submitted:', applicationId, email);
+    // Can add custom logic here, such as showing notifications
   },
 
-  // 错误回调
+  // Error callback
   onError: (error) => {
-    console.error('认证错误:', error.message);
+    console.error('Authentication error:', error.message);
   },
 
-  // OAuth 配置（可选）
-  returnUrl: 'https://mygame.com/',  // OAuth 登录后返回的 URL，可选，默认为 window.location.href
+  // OAuth configuration (optional)
+  returnUrl: 'https://mygame.com/',  // URL to return after OAuth login, optional, defaults to window.location.href
   enableOAuth: {
-    google: true,   // 启用 Google 登录
-    discord: true,  // 启用 Discord 登录
-    github: true,   // 启用 GitHub 登录
+    google: true,   // Enable Google login
+    discord: true,  // Enable Discord login
+    github: true,   // Enable GitHub login
   },
 });
 
-// 显示登录界面
+// Show login interface
 authModal.show('login');
 
-// 显示注册界面
+// Show signup interface
 authModal.show('signup');
 
-// 隐藏弹窗
+// Hide modal
 authModal.hide();
 
-// 销毁弹窗
+// Destroy modal
 authModal.destroy();
 ```
 
-**✨ 新特性：自动 Toast 通知**
+**✨ New Feature: Auto Toast Notifications**
 
-AuthModal 内置了现代化的 Toast 通知系统，无需额外配置：
+AuthModal has built-in modern Toast notification system, no extra configuration needed:
 
 ```typescript
-// Toast 会自动显示，CSS 自动注入
-// - 注册成功 → 绿色成功提示
-// - 账号已存在 → 黄色警告提示
-// - 登录失败 → 红色错误提示
-// - 重置密码 → 蓝色信息提示
+// Toast displays automatically, CSS auto-injected
+// - Registration success → Green success notification
+// - Account exists → Yellow warning notification
+// - Login failure → Red error notification
+// - Reset password → Blue info notification
 
-// 你也可以单独使用 Toast（CSS 自动注入）
+// You can also use Toast independently (CSS auto-injected)
 import { Toast } from '@seaverse/auth-sdk';
 
-Toast.success('操作成功', '数据已保存');
-Toast.error('操作失败', '请稍后重试');
-Toast.warning('注意', '账号已存在');
-Toast.info('提示', '邮件已发送');
+Toast.success('Success', 'Data saved');
+Toast.error('Failed', 'Please try again later');
+Toast.warning('Notice', 'Account already exists');
+Toast.info('Info', 'Email sent');
 ```
 
-#### 重置密码流程
+#### Password Reset Flow
 
-AuthModal 支持完整的密码重置流程：
+AuthModal supports complete password reset flow:
 
-1. **用户触发忘记密码**：在登录界面点击 "Forgot Password?" 链接
-2. **发送重置邮件**：输入邮箱后，系统发送带有 `reset_token` 的重置链接
-3. **自动唤起重置弹窗**：用户点击邮件中的链接返回网站时，AuthModal 会自动检测 URL 中的 `reset_token` 参数并显示重置密码表单
-4. **设置新密码**：用户输入并确认新密码后提交
-5. **自动清理 URL**：重置成功后自动清除 URL 中的 `reset_token` 参数
+1. **User triggers forgot password**: Click "Forgot Password?" link in login interface
+2. **Send reset email**: After entering email, system sends reset link with `reset_token`
+3. **Auto trigger reset modal**: When user clicks link in email and returns to website, AuthModal automatically detects `reset_token` parameter in URL and shows reset password form
+4. **Set new password**: User enters and confirms new password then submits
+5. **Auto cleanup URL**: After successful reset, automatically clears `reset_token` parameter from URL
 
-整个流程无需额外代码，AuthModal 会自动处理：
+The entire process requires no extra code, AuthModal handles it automatically:
 
 ```typescript
-// 1. 初始化 AuthModal（只需一次）
+// 1. Initialize AuthModal (only once)
 const authModal = new AuthModal({
   client,
-  // ... 其他配置
+  // ... other configuration
 });
 
-// 2. 用户点击邮件中的重置链接后，AuthModal 会自动：
-//    - 检测 URL 中的 ?reset_token=xxx 参数
-//    - 显示重置密码表单
-//    - 用户提交新密码
-//    - 调用 client.resetPassword() API
-//    - 清理 URL 中的 reset_token 参数
-//    - 显示成功消息
+// 2. After user clicks reset link in email, AuthModal automatically:
+//    - Detects ?reset_token=xxx parameter in URL
+//    - Shows reset password form
+//    - User submits new password
+//    - Calls client.resetPassword() API
+//    - Cleans reset_token parameter from URL
+//    - Shows success message
 ```
 
-#### OAuth 配置说明
+#### OAuth Configuration Instructions
 
-`enableOAuth` 参数是**完全可选的**：
+The `enableOAuth` parameter is **completely optional**:
 
-- 如果**不提供** `enableOAuth`，则不会显示任何第三方登录按钮
-- 如果**部分配置**（如只启用 Google），则只显示已启用的按钮
-- 如果**完整配置**所有平台，则显示所有第三方登录按钮
+- If **not provided**, no third-party login buttons will be shown
+- If **partially configured** (e.g., only enable Google), only enabled buttons will be shown
+- If **fully configured** for all platforms, all third-party login buttons will be shown
 
-**配置字段说明**：
-- `returnUrl`：**可选** - OAuth 登录后返回的 URL，不填则默认为 `window.location.href`
-- `enableOAuth.google`：是否启用 Google 登录
-- `enableOAuth.discord`：是否启用 Discord 登录
-- `enableOAuth.github`：是否启用 GitHub 登录
+**Configuration field descriptions**:
+- `returnUrl`: **Optional** - URL to return after OAuth login, defaults to `window.location.href` if not provided
+- `enableOAuth.google`: Whether to enable Google login
+- `enableOAuth.discord`: Whether to enable Discord login
+- `enableOAuth.github`: Whether to enable GitHub login
 
 ```typescript
-// 示例1：无OAuth按钮
+// Example 1: No OAuth buttons
 const authModal1 = new AuthModal({
   client,
   theme: 'dark',
-  // 不传 enableOAuth，不显示任何OAuth按钮
+  // No enableOAuth, no OAuth buttons shown
 });
 
-// 示例2：只显示Google登录
+// Example 2: Only show Google login
 const authModal2 = new AuthModal({
   client,
   theme: 'light',
   returnUrl: 'https://mygame.com/dashboard',
   enableOAuth: {
     google: true,
-    // Discord 和 GitHub 未启用，不会显示这些按钮
+    // Discord and GitHub not enabled, won't show these buttons
   },
 });
 
-// 示例3：显示所有OAuth按钮
+// Example 3: Show all OAuth buttons
 const authModal3 = new AuthModal({
   client,
   theme: 'dark',
@@ -645,58 +645,58 @@ const authModal3 = new AuthModal({
 });
 ```
 
-#### 处理 OAuth 回调
+#### Handling OAuth Callback
 
-在 Backend Proxy Mode 下，OAuth 登录后会重定向到 `returnUrl?token=xxx`。在页面加载时检查并处理token:
+In Backend Proxy Mode, after OAuth login it redirects to `returnUrl?token=xxx`. Check and handle token on page load:
 
 ```typescript
-// 在页面加载时自动处理 OAuth 回调
+// Automatically handle OAuth callback on page load
 const result = AuthModal.handleOAuthCallback({
   client,
   onLoginSuccess: (token) => {
     localStorage.setItem('token', token);
-    console.log('OAuth 登录成功');
+    console.log('OAuth login successful');
 
-    // 现在可以直接调用需要认证的接口
-    // handleOAuthCallback 已自动调用 client.setToken()
+    // Can now call authenticated APIs directly
+    // handleOAuthCallback has automatically called client.setToken()
     client.getCurrentUser()
-      .then(user => console.log('用户信息:', user));
+      .then(user => console.log('User info:', user));
   },
 });
 
 if (result) {
-  console.log('处理了 OAuth 回调，token:', result.token);
+  console.log('Handled OAuth callback, token:', result.token);
 }
 ```
 
-**重要说明**：
-- `handleOAuthCallback()` 会自动调用 `client.setToken(token)` 来更新 client 的认证配置
-- 这意味着在 `onLoginSuccess` 回调之后，所有需要认证的 API（如 `getCurrentUser()`、`logout()` 等）都会自动带上 `Authorization` header
+**Important Note**:
+- `handleOAuthCallback()` automatically calls `client.setToken(token)` to update client authentication configuration
+- This means after the `onLoginSuccess` callback, all authenticated APIs (such as `getCurrentUser()`, `logout()`, etc.) will automatically include the `Authorization` header
 
-#### 手动设置 Token
+#### Manual Token Setting
 
-如果你不使用 `AuthModal.handleOAuthCallback()`，也可以手动设置 token：
+If you don't use `AuthModal.handleOAuthCallback()`, you can also set the token manually:
 
 ```typescript
-// 从 URL 提取 token
+// Extract token from URL
 const token = new URLSearchParams(window.location.search).get('token');
 if (token) {
-  // 手动设置 token
+  // Manually set token
   client.setToken(token);
   localStorage.setItem('token', token);
 
-  // 现在可以调用需要认证的接口
+  // Now can call authenticated APIs
   const user = await client.getCurrentUser();
 }
 ```
 
-### 6. 容器管理
+### 6. Container Management
 
 ```typescript
-// 列出所有容器
+// List all containers
 const containers = await client.listContainers();
 
-// 注册新容器
+// Register new container
 const result = await client.registerContainer({
   containerId: 'container-123',
   metadata: {
@@ -705,226 +705,226 @@ const result = await client.registerContainer({
   },
 });
 
-// 获取容器信息
+// Get container info
 const container = await client.getContainer({
   containerId: 'container-123',
 });
 
-// 容器心跳
+// Container heartbeat
 await client.containerHeartbeat({
   containerId: 'container-123',
   status: 'healthy',
 });
 
-// 注销容器
+// Unregister container
 await client.unregisterContainer({
   containerId: 'container-123',
 });
 
-// 获取容器统计
+// Get container stats
 const stats = await client.getContainerStats();
 ```
 
-### 7. 技能市场
+### 7. Skill Marketplace
 
 ```typescript
-// 列出市场技能
+// List marketplace skills
 const skills = await client.listMarketplaceSkills({
   category: 'productivity',
   page: 1,
   pageSize: 20,
 });
 
-// 获取技能详情
+// Get skill details
 const skill = await client.getMarketplaceSkill({
   skillId: 'skill-123',
 });
 
-// 安装技能
+// Install skill
 await client.installSkill({
   skillId: 'skill-123',
 });
 
-// 列出已安装的技能
+// List installed skills
 const userSkills = await client.listUserSkills();
 
-// 卸载技能
+// Uninstall skill
 await client.uninstallSkill({
   skillId: 'skill-123',
 });
 ```
 
-### 8. 邀请码管理
+### 8. Invitation Code Management
 
 ```typescript
-// 申请邀请码（当用户没有邀请码时）
+// Apply for invitation code (when user doesn't have one)
 const application = await client.applyInvite({
   email: 'player@example.com',
   reason: 'I want to join this amazing platform to build innovative applications and connect with the community.'
 });
 
 if (application.success) {
-  console.log('申请已提交:', application.data);
-  console.log('申请ID:', application.data.id);
-  console.log('状态:', application.data.status); // 'pending'
+  console.log('Application submitted:', application.data);
+  console.log('Application ID:', application.data.id);
+  console.log('Status:', application.data.status); // 'pending'
 } else {
-  // 处理错误
+  // Handle error
   if (application.code === 'APPLICATION_DUPLICATE') {
-    console.log('您在过去24小时内已提交过申请');
+    console.log('You have already submitted an application in the past 24 hours');
   } else {
-    console.error('申请失败:', application.error);
+    console.error('Application failed:', application.error);
   }
 }
 
-// 列出我的邀请码
+// List my invitation codes
 const invites = await client.listInvites({
   status: 'active',
   page: 1,
   page_size: 20,
 });
-console.log('我的邀请码:', invites.data.invites);
+console.log('My invitation codes:', invites.data.invites);
 
-// 获取邀请码统计
+// Get invitation code stats
 const stats = await client.getInviteStats();
-console.log('总邀请码数:', stats.data.total_codes);
-console.log('活跃邀请码:', stats.data.active_codes);
-console.log('总使用次数:', stats.data.total_uses);
+console.log('Total invitation codes:', stats.data.total_codes);
+console.log('Active invitation codes:', stats.data.active_codes);
+console.log('Total usage count:', stats.data.total_uses);
 
-// 获取邀请码详情
+// Get invitation code details
 const invite = await client.getInvite('inv_abc123');
-console.log('邀请码:', invite.data.code);
-console.log('已使用:', invite.data.used_count);
-console.log('最大使用次数:', invite.data.max_uses);
+console.log('Invitation code:', invite.data.code);
+console.log('Used count:', invite.data.used_count);
+console.log('Max uses:', invite.data.max_uses);
 
-// 获取邀请码使用记录
+// Get invitation code usage records
 const usages = await client.getInviteUsages('inv_abc123', {
   page: 1,
   page_size: 20,
 });
-console.log('使用记录:', usages.data.usages);
+console.log('Usage records:', usages.data.usages);
 ```
 
-### 9. 邮箱验证与邀请码绑定
+### 9. Email Verification and Invitation Code Binding
 
-#### 邮箱验证（自动登录）
+#### Email Verification (Auto Login)
 
-用户注册后会收到验证邮件，邮件中包含验证链接，格式为：`frontend_url?verify_token=xxx`
+After registration, users receive a verification email containing a verification link in the format: `frontend_url?verify_token=xxx`
 
-**方式一：使用 AuthModal 自动处理（推荐）**
+**Method 1: Use AuthModal Auto-Handling (Recommended)**
 
 ```typescript
 import { AuthModal } from '@seaverse/auth-sdk';
 
-// 创建 AuthModal 实例
+// Create AuthModal instance
 const modal = new AuthModal({
   client,
   onLoginSuccess: (token, user) => {
     localStorage.setItem('token', token);
-    console.log('邮箱验证并登录成功:', user);
+    console.log('Email verified and logged in successfully:', user);
   },
   onError: (error) => {
-    console.error('邮箱验证失败:', error);
+    console.error('Email verification failed:', error);
   }
 });
 
-// AuthModal 会自动检测 URL 中的 verify_token 参数
-// 检测到后会自动：
-// 1. 调用 verifyEmail() API 验证邮箱
-// 2. 获取返回的 JWT token 并自动登录
-// 3. 触发 onLoginSuccess 回调
-// 4. 清理 URL 中的 verify_token 参数
-// 5. 显示成功消息
+// AuthModal will automatically detect verify_token parameter in URL
+// After detection, it will automatically:
+// 1. Call verifyEmail() API to verify email
+// 2. Get returned JWT token and auto-login
+// 3. Trigger onLoginSuccess callback
+// 4. Clean verify_token parameter from URL
+// 5. Show success message
 ```
 
-**调试提示**：
+**Debugging Tips**:
 
-如果邮箱验证出现问题，请检查浏览器控制台日志：
+If email verification has issues, check browser console logs:
 
 ```javascript
-// 正常情况应该看到：
+// Normal case should show:
 [AuthModal] Detected verify_token, starting email verification...
 [AuthModal] Email verification successful: { id: "xxx", email: "user@example.com", ... }
 
-// 如果验证失败，会看到：
+// If verification fails, will show:
 [AuthModal] Email verification failed: Error: ...
 ```
 
-**方式二：手动处理邮箱验证**
+**Method 2: Manual Email Verification Handling**
 
 ```typescript
-// 验证邮箱（从邮件链接中获取 verify_token）
+// Verify email (get verify_token from email link)
 const urlParams = new URLSearchParams(window.location.search);
 const verifyToken = urlParams.get('verify_token');
 
 if (verifyToken) {
   const result = await client.verifyEmail(verifyToken);
 
-  // 自动登录：保存返回的 token
+  // Auto-login: save returned token
   localStorage.setItem('token', result.data.token);
   localStorage.setItem('refreshToken', result.data.refreshToken);
 
-  console.log('邮箱验证成功，已自动登录:', result.data.user);
+  console.log('Email verified successfully, auto-logged in:', result.data.user);
 
-  // 重定向到主页
+  // Redirect to homepage
   window.location.href = '/';
 }
 ```
 
-#### 邀请码绑定（账户激活）
+#### Invitation Code Binding (Account Activation)
 
-当使用外部邮箱注册或 OAuth 登录但未提供邀请码时，会创建临时账户并需要后续绑定邀请码激活。
+When registering with external email or OAuth login without providing invitation code, a temporary account is created and requires subsequent invitation code binding for activation.
 
-**申请邀请码功能**：
+**Apply for Invitation Code Feature**:
 
-如果用户没有邀请码，AuthModal 提供了内置的申请功能：
-1. 在邀请码输入界面，用户可以点击 "Don't have an invitation code? Apply for one" 链接
-2. 自动跳转到申请邀请码表单
-3. 用户填写邮箱和申请原因（10-500字符）
-4. 提交后会调用 `applyInvite()` API，后台审核通过后会通过邮件发送邀请码
+If user doesn't have an invitation code, AuthModal provides built-in application feature:
+1. In invitation code input interface, user can click "Don't have an invitation code? Apply for one" link
+2. Automatically jumps to apply for invitation code form
+3. User fills in email and application reason (10-500 characters)
+4. After submission, calls `applyInvite()` API, after backend approval, invitation code will be sent via email
 
-**自动跳转机制**:
-- 当 `login()` 返回 `INVITE_CODE_REQUIRED` 错误且包含 `redirectUrl` 时，SDK 会自动将页面重定向到该 URL
-- redirectUrl 通常包含 `error_code=INVITE_CODE_REQUIRED&user_id=xxx&email=xxx` 参数
-- 无需手动处理跳转逻辑，SDK 会自动完成
+**Auto Redirect Mechanism**:
+- When `login()` returns `INVITE_CODE_REQUIRED` error and includes `redirectUrl`, SDK automatically redirects page to that URL
+- redirectUrl usually contains `error_code=INVITE_CODE_REQUIRED&user_id=xxx&email=xxx` parameters
+- No need to manually handle redirect logic, SDK completes automatically
 
-对于其他场景(如 OAuth 登录后的重定向)，后端会直接重定向到 `frontend_url?error_code=INVITE_CODE_REQUIRED&user_id=xxx&email=xxx`。
+For other scenarios (such as redirects after OAuth login), backend directly redirects to `frontend_url?error_code=INVITE_CODE_REQUIRED&user_id=xxx&email=xxx`.
 
-**方式一：使用 AuthModal 自动处理（推荐）**
+**Method 1: Use AuthModal Auto-Handling (Recommended)**
 
 ```typescript
 import { AuthModal } from '@seaverse/auth-sdk';
 
-// 创建 AuthModal 实例
+// Create AuthModal instance
 const modal = new AuthModal({
   client,
   onLoginSuccess: (token, user) => {
     localStorage.setItem('token', token);
-    console.log('登录成功:', user);
+    console.log('Login successful:', user);
   },
   onInviteCodeRequired: (userId, email) => {
-    // 可选：当需要邀请码时的自定义处理
-    console.log('需要邀请码激活账户:', userId, email);
+    // Optional: custom handling when invitation code is needed
+    console.log('Need invitation code to activate account:', userId, email);
   }
 });
 
-// AuthModal 会自动检测 URL 中的以下参数组合：
+// AuthModal will automatically detect the following parameter combinations in URL:
 // - error_code=INVITE_CODE_REQUIRED
-// - user_id 或 temp_user_id（用户ID）
-// - email（可选，用户邮箱）
+// - user_id or temp_user_id (user ID)
+// - email (optional, user email)
 //
-// 检测到后会自动：
-// 1. 显示邀请码输入界面
-// 2. 用户输入邀请码后调用 bindInviteCode() API
-// 3. 激活成功后自动登录（保存 token）
-// 4. 清理 URL 中的参数
+// After detection, it will automatically:
+// 1. Show invitation code input interface
+// 2. After user inputs invitation code, call bindInviteCode() API
+// 3. After successful activation, auto-login (save token)
+// 4. Clean parameters from URL
 ```
 
-**调试提示**：
+**Debugging Tips**:
 
-如果邀请码弹窗没有出现，请检查浏览器控制台是否有以下日志：
+If invitation code modal doesn't appear, check browser console for the following logs:
 
 ```javascript
-// 正常情况应该看到：
+// Normal case should show:
 [AuthModal] Detected INVITE_CODE_REQUIRED: {
   errorCode: "INVITE_CODE_REQUIRED",
   userId: "xxx",
@@ -933,50 +933,50 @@ const modal = new AuthModal({
   fullURL: "http://localhost:8001/?error_code=INVITE_CODE_REQUIRED&user_id=xxx&email=xxx"
 }
 
-// 如果 user_id 缺失，会看到错误提示：
+// If user_id is missing, will show error:
 [AuthModal] Missing user_id in URL parameters.
-// 并弹出 alert 显示完整 URL，方便排查后端重定向问题
+// And shows alert with full URL for troubleshooting backend redirect issues
 ```
 
-**方式二：手动处理邀请码绑定**
+**Method 2: Manual Invitation Code Binding Handling**
 
 ```typescript
-// 1. 检查 URL 中是否需要邀请码
+// 1. Check if invitation code is needed in URL
 const urlParams = new URLSearchParams(window.location.search);
 const errorCode = urlParams.get('error_code');
 const userId = urlParams.get('user_id');
 
 if (errorCode === 'INVITE_CODE_REQUIRED' && userId) {
-  // 2. 显示邀请码输入界面（自定义 UI）
-  const inviteCode = await showInviteCodeInput(); // 你的自定义UI
+  // 2. Show invitation code input interface (custom UI)
+  const inviteCode = await showInviteCodeInput(); // Your custom UI
 
-  // 3. 绑定邀请码
+  // 3. Bind invitation code
   const result = await client.bindInviteCode({
     user_id: userId,
     invite_code: inviteCode
   });
 
-  // 4. 激活成功，自动登录
+  // 4. Activation successful, auto-login
   localStorage.setItem('token', result.data.token);
   localStorage.setItem('refreshToken', result.data.refreshToken);
-  console.log('账户激活成功:', result.data.user);
+  console.log('Account activated successfully:', result.data.user);
 
-  // 5. 重定向到主页
+  // 5. Redirect to homepage
   window.location.href = '/';
 }
 ```
 
-**方式三：使用静态方法处理**
+**Method 3: Use Static Method Handling**
 
 ```typescript
 import { AuthModal } from '@seaverse/auth-sdk';
 
-// AuthModal 提供静态方法处理邀请码场景
+// AuthModal provides static method to handle invitation code scenario
 const inviteCodeInfo = AuthModal.handleInviteCodeRequired(
   { client },
   (userId, email) => {
-    // 自定义处理逻辑
-    const code = prompt(`请输入邀请码激活账户 (${email}):`);
+    // Custom handling logic
+    const code = prompt(`Please enter invitation code to activate account (${email}):`);
     if (code) {
       client.bindInviteCode({ user_id: userId, invite_code: code })
         .then(res => {
@@ -988,33 +988,33 @@ const inviteCodeInfo = AuthModal.handleInviteCodeRequired(
 );
 ```
 
-### 10. 其他功能
+### 10. Other Features
 
 ```typescript
-// 获取API Service Token
+// Get API Service Token
 const apiToken = await client.getApiServiceToken();
 
-// 获取对话状态
+// Get conversation status
 const status = await client.getConversationStatus({
   conversationId: 'conv-123',
 });
 
-// 获取语音Token
+// Get speech token
 const speechToken = await client.getSpeechToken();
 ```
 
-## 高级配置
+## Advanced Configuration
 
-### 自定义认证
+### Custom Authentication
 
 ```typescript
 import { AuthFactory } from '@seaverse/auth-sdk';
 
 const client = new SeaVerseBackendAPIClient({
-  appId: 'your app id',         // 必需：应用ID
+  appId: 'your app id',         // Required: Application ID
   environment: 'production',
 
-  // 使用JWT认证
+  // Use JWT authentication
   auth: AuthFactory.create({
     type: 'jwt',
     credentials: {
@@ -1025,28 +1025,28 @@ const client = new SeaVerseBackendAPIClient({
 });
 ```
 
-### 自定义Hooks
+### Custom Hooks
 
 ```typescript
 import { BuiltInHooks } from '@seaverse/auth-sdk';
 
 const client = new SeaVerseBackendAPIClient({
-  appId: 'your app id',         // 必需：应用ID
+  appId: 'your app id',         // Required: Application ID
   environment: 'production',
 
   hooks: {
     hooks: [
-      // 日志Hook
+      // Logger Hook
       BuiltInHooks.createLoggerHook({
         logLevel: 'debug',
         logRequestBody: true,
         logResponseBody: true,
       }),
 
-      // 请求ID Hook
+      // Request ID Hook
       BuiltInHooks.createRequestIdHook(),
 
-      // 自定义Hook
+      // Custom Hook
       {
         type: 'beforeRequest',
         name: 'custom-hook',
@@ -1060,22 +1060,22 @@ const client = new SeaVerseBackendAPIClient({
 });
 ```
 
-### 请求重试配置
+### Request Retry Configuration
 
-SDK 支持自定义 HTTP 请求重试策略。**默认情况下重试功能是禁用的（maxRetries: 0）**，以确保请求的可预测性。
+The SDK supports custom HTTP request retry strategies. **By default, retry functionality is disabled (maxRetries: 0)** to ensure request predictability.
 
-#### 默认行为（禁用重试）
+#### Default Behavior (Retry Disabled)
 
 ```typescript
 const client = new SeaVerseBackendAPIClient({
   appId: 'your app id',
-  // retryOptions 未设置，默认不重试
+  // retryOptions not set, no retry by default
 });
 
-// 如果请求失败，会立即返回错误，不会重试
+// If request fails, will return error immediately, no retry
 ```
 
-#### 启用基础重试
+#### Enable Basic Retry
 
 ```typescript
 import { SeaVerseBackendAPIClient } from '@seaverse/auth-sdk';
@@ -1083,25 +1083,25 @@ import { SeaVerseBackendAPIClient } from '@seaverse/auth-sdk';
 const client = new SeaVerseBackendAPIClient({
   appId: 'your app id',
   retryOptions: {
-    maxRetries: 3,        // 最多重试 3 次
-    retryDelay: 1000,     // 初始延迟 1000ms (1秒)
-    // 默认会对以下状态码重试：[408, 429, 500, 502, 503, 504]
+    maxRetries: 3,        // Retry up to 3 times
+    retryDelay: 1000,     // Initial delay 1000ms (1 second)
+    // Defaults to retry on these status codes: [408, 429, 500, 502, 503, 504]
   },
 });
 ```
 
-**重试策略说明**：
-- 采用**指数退避**算法：第1次等待1秒，第2次等待2秒，第3次等待4秒
-- 自动重试的 HTTP 状态码：
-  - `408` - Request Timeout（请求超时）
-  - `429` - Too Many Requests（限流）
-  - `500` - Internal Server Error（服务器内部错误）
-  - `502` - Bad Gateway（网关错误）
-  - `503` - Service Unavailable（服务不可用）
-  - `504` - Gateway Timeout（网关超时）
-- 网络错误（无响应）也会触发重试
+**Retry Strategy Explanation**:
+- Uses **exponential backoff** algorithm: 1st retry waits 1 second, 2nd waits 2 seconds, 3rd waits 4 seconds
+- HTTP status codes that trigger auto-retry:
+  - `408` - Request Timeout
+  - `429` - Too Many Requests (rate limiting)
+  - `500` - Internal Server Error
+  - `502` - Bad Gateway
+  - `503` - Service Unavailable
+  - `504` - Gateway Timeout
+- Network errors (no response) will also trigger retry
 
-#### 自定义重试状态码
+#### Custom Retry Status Codes
 
 ```typescript
 const client = new SeaVerseBackendAPIClient({
@@ -1109,12 +1109,12 @@ const client = new SeaVerseBackendAPIClient({
   retryOptions: {
     maxRetries: 5,
     retryDelay: 2000,
-    retryStatusCodes: [503, 504],  // 只对 503 和 504 重试
+    retryStatusCodes: [503, 504],  // Only retry on 503 and 504
   },
 });
 ```
 
-#### 自定义重试逻辑
+#### Custom Retry Logic
 
 ```typescript
 import type { RetryOptions } from '@seaverse/auth-sdk';
@@ -1122,13 +1122,13 @@ import type { RetryOptions } from '@seaverse/auth-sdk';
 const retryOptions: RetryOptions = {
   maxRetries: 3,
   retryDelay: 1000,
-  // 自定义判断逻辑：只对特定错误重试
+  // Custom judgment logic: only retry on specific errors
   shouldRetry: (error) => {
-    // 只对服务不可用错误重试
+    // Only retry on service unavailable errors
     if (error.response?.status === 503) {
       return true;
     }
-    // 对没有响应的网络错误重试
+    // Retry on network errors with no response
     if (!error.response) {
       return true;
     }
@@ -1142,153 +1142,153 @@ const client = new SeaVerseBackendAPIClient({
 });
 ```
 
-#### RetryOptions 类型定义
+#### RetryOptions Type Definition
 
 ```typescript
 interface RetryOptions {
-  maxRetries?: number;           // 最大重试次数，默认 0（禁用）
-  retryDelay?: number;           // 初始重试延迟（毫秒），默认 1000
-  retryStatusCodes?: number[];   // 触发重试的状态码列表
-  shouldRetry?: (error: AxiosError) => boolean;  // 自定义重试判断函数
+  maxRetries?: number;           // Maximum retry count, default 0 (disabled)
+  retryDelay?: number;           // Initial retry delay (milliseconds), default 1000
+  retryStatusCodes?: number[];   // List of status codes that trigger retry
+  shouldRetry?: (error: AxiosError) => boolean;  // Custom retry judgment function
 }
 ```
 
-**使用建议**：
-- ⚠️ **生产环境建议禁用重试**（默认行为），避免在业务逻辑错误时产生重复请求
-- ✅ 仅在网络不稳定的场景启用重试，如移动端应用、弱网环境
-- ✅ 确保后端 API 支持幂等性操作，避免重试导致的副作用
-- ✅ 对于关键业务（如支付），建议使用自定义 `shouldRetry` 仔细控制重试逻辑
+**Usage Recommendations**:
+- ⚠️ **Recommended to disable retry in production** (default behavior), avoid duplicate requests on business logic errors
+- ✅ Only enable retry in unstable network scenarios, such as mobile apps, weak network environments
+- ✅ Ensure backend APIs support idempotent operations, avoid side effects from retries
+- ✅ For critical business (such as payments), recommended to use custom `shouldRetry` to carefully control retry logic
 
-### 环境配置
+### Environment Configuration
 
-SDK支持以下环境：
+The SDK supports the following environments:
 
-| 环境 | 描述 | BaseURL |
+| Environment | Description | BaseURL |
 |------|------|---------|
-| `production` | 生产环境 | `https://account-hub.seaverse.ai` |
-| `staging` | 测试环境 | `https://api.staging.seaverse.dev` |
-| `development` | 开发环境 | `https://api.dev.seaverse.dev` |
-| `local` | 本地环境 | `http://localhost:3000` |
+| `production` | Production environment | `https://account-hub.seaverse.ai` |
+| `staging` | Staging environment | `https://api.staging.seaverse.dev` |
+| `development` | Development environment | `https://api.dev.seaverse.dev` |
+| `local` | Local environment | `http://localhost:3000` |
 
-自动检测规则：
+Auto-detection rules:
 - `*.seaverse.com` → production
 - `*.staging.seaverse.dev` → staging
 - `*.dev.seaverse.dev` → development
 - `localhost` → local
 
-## API 参考
+## API Reference
 
-### 认证相关
+### Authentication Related
 
-| 方法 | 参数 | 返回值 | 说明 |
+| Method | Parameters | Return Value | Description |
 |------|------|--------|------|
-| `register()` | `{ email, password, username?, invitation_code?, frontend_url? }` | `RegisterResponse` | 注册新用户，frontend_url 为邮箱验证链接的前端URL，默认为 window.location.href |
-| `login()` | `{ email, password, frontend_url? }` | `LoginResponse` | 用户登录，frontend_url 用于未验证邮箱时发送验证邮件，默认为 https://seaverse.ai/。⚠️ 如果返回 INVITE_CODE_REQUIRED 且包含 redirectUrl，会自动跳转 |
-| `getCurrentUser()` | - | `User` | 获取当前用户 |
-| `logout()` | - | `SuccessResponse` | 登出 |
-| `verifyEmail()` | `verifyToken: string` | `EmailVerificationResponse` | 验证邮箱并返回自动登录 token |
-| `bindInviteCode()` | `{ user_id, invite_code }` | `BindInviteCodeResponse` | 绑定邀请码激活临时账户并自动登录 |
-| `forgotPassword()` | `{ email, frontend_url? }` | `SuccessResponse` | 忘记密码，frontend_url 默认为 window.location.href |
-| `resetPassword()` | `{ token, new_password }` | `SuccessResponse` | 重置密码 |
-| `setToken()` | `token: string` | `void` | 设置认证 token（OAuth 登录后使用） |
-| `isInIframe()` | - | `boolean` | 检查应用是否在 iframe 中运行（支持静态方法和实例方法） |
-| `getIframeToken()` | `{ timeout? }` | `Promise<string>` | 从父页面获取 token（仅 iframe 场景），timeout 默认 30000ms |
-| `getApiServiceToken()` | - | `ApiServiceTokenResponse` | 获取API Token |
-
-#### 注册流程说明
-
-`register()` 方法支持三种注册流程，SDK 会根据后端响应自动处理：
-
-**流程 1: 立即激活（默认）**
+| `register()` | `{ email, password, username?, invitation_code?, frontend_url? }` | `RegisterResponse` | Register new user, frontend_url is frontend URL for email verification link, defaults to window.location.href |
+| `login()` | `{ email, password, frontend_url? }` | `LoginResponse` | User login, frontend_url used for sending verification email when email not verified, defaults to https://seaverse.ai/. ⚠️ If returns INVITE_CODE_REQUIRED with redirectUrl, will automatically redirect |
+| `getCurrentUser()` | - | `User` | Get current user |
+| `logout()` | - | `SuccessResponse` | Logout |
+| `verifyEmail()` | `verifyToken: string` | `EmailVerificationResponse` | Verify email and return auto-login token |
+| `bindInviteCode()` | `{ user_id, invite_code }` | `BindInviteCodeResponse` | Bind invitation code to activate temporary account and auto-login |
+| `forgotPassword()` | `{ email, frontend_url? }` | `SuccessResponse` | Forgot password, frontend_url defaults to window.location.href |
+| `resetPassword()` | `{ token, new_password }` | `SuccessResponse` | Reset password |
+| `setToken()` | `token: string` | `void` | Set authentication token (used after OAuth login) |
+| `isInIframe()` | - | `boolean` | Check if application is running in iframe (supports static method and instance method) |
+| `getIframeToken()` | `{ timeout? }` | `Promise<string>` | Get token from parent page (iframe scenario only), timeout defaults to 30000ms |
+| `getApiServiceToken()` | - | `ApiServiceTokenResponse` | Get API Token |
+
+#### Registration Flow Description
+
+The `register()` method supports three registration flows, SDK automatically handles based on backend response:
+
+**Flow 1: Immediate Activation (Default)**
 ```typescript
 const response = await client.register({ email, password });
 // response.success === true
-// response.requiresEmailVerification === undefined (或 false)
-// response.requiresInvitationCode === undefined (或 false)
-// → SDK 自动调用 login() 并触发 onSignupSuccess 回调
+// response.requiresEmailVerification === undefined (or false)
+// response.requiresInvitationCode === undefined (or false)
+// → SDK automatically calls login() and triggers onSignupSuccess callback
 ```
 
-**流程 2: 需要邮箱验证**
+**Flow 2: Requires Email Verification**
 ```typescript
 const response = await client.register({ email, password });
 // response.success === true
 // response.requiresEmailVerification === true
-// → SDK 显示 Toast 提示用户检查邮箱
-// → 不会自动调用 login()，用户需要点击邮件中的验证链接
+// → SDK shows Toast prompting user to check email
+// → Does not auto-call login(), user needs to click verification link in email
 ```
 
-**流程 3: 需要邀请码激活**
+**Flow 3: Requires Invitation Code Activation**
 ```typescript
 const response = await client.register({ email, password });
 // response.success === true
 // response.requiresInvitationCode === true
 // response.tempUserId === "temp_xxx"
-// → SDK 显示邀请码输入表单
-// → 不会自动调用 login()，用户需要输入邀请码
+// → SDK shows invitation code input form
+// → Does not auto-call login(), user needs to input invitation code
 ```
 
-**重要提示**：
-- AuthModal 会自动处理这三种流程，无需手动判断
-- 只有在无需验证或激活的情况下，才会自动调用 `login()`
-- 这避免了在邮箱未验证或账户未激活时产生不必要的登录请求
+**Important Note**:
+- AuthModal automatically handles these three flows, no manual judgment needed
+- Only when no verification or activation is needed, will `login()` be automatically called
+- This avoids unnecessary login requests when email is not verified or account is not activated
 
-### OAuth相关
+### OAuth Related
 
-| 方法 | 参数 | 返回值 | 说明 |
+| Method | Parameters | Return Value | Description |
 |------|------|--------|------|
-| `googleAuthorize()` | `{ return_url? }` | `OAuthAuthorizeResponse` | Google OAuth 授权 URL |
-| `discordAuthorize()` | `{ return_url? }` | `OAuthAuthorizeResponse` | Discord OAuth 授权 URL |
-| `githubAuthorize()` | `{ return_url? }` | `OAuthAuthorizeResponse` | GitHub OAuth 授权 URL |
-| `unlinkGoogle()` | - | `SuccessResponse` | 解绑Google |
-| `unlinkDiscord()` | - | `SuccessResponse` | 解绑Discord |
-| `unlinkGithub()` | - | `SuccessResponse` | 解绑GitHub |
+| `googleAuthorize()` | `{ return_url? }` | `OAuthAuthorizeResponse` | Google OAuth authorization URL |
+| `discordAuthorize()` | `{ return_url? }` | `OAuthAuthorizeResponse` | Discord OAuth authorization URL |
+| `githubAuthorize()` | `{ return_url? }` | `OAuthAuthorizeResponse` | GitHub OAuth authorization URL |
+| `unlinkGoogle()` | - | `SuccessResponse` | Unlink Google |
+| `unlinkDiscord()` | - | `SuccessResponse` | Unlink Discord |
+| `unlinkGithub()` | - | `SuccessResponse` | Unlink GitHub |
 
-### 容器管理
+### Container Management
 
-| 方法 | 参数 | 返回值 | 说明 |
+| Method | Parameters | Return Value | Description |
 |------|------|--------|------|
-| `listContainers()` | - | `ContainerListResponse` | 列出容器 |
-| `registerContainer()` | `{ containerId, metadata }` | `SuccessResponse` | 注册容器 |
-| `getContainer()` | `{ containerId }` | `Container` | 获取容器信息 |
-| `unregisterContainer()` | `{ containerId }` | `SuccessResponse` | 注销容器 |
-| `containerHeartbeat()` | `{ containerId, status }` | `SuccessResponse` | 容器心跳 |
-| `getContainerStats()` | - | `ContainerStatsResponse` | 容器统计 |
+| `listContainers()` | - | `ContainerListResponse` | List containers |
+| `registerContainer()` | `{ containerId, metadata }` | `SuccessResponse` | Register container |
+| `getContainer()` | `{ containerId }` | `Container` | Get container info |
+| `unregisterContainer()` | `{ containerId }` | `SuccessResponse` | Unregister container |
+| `containerHeartbeat()` | `{ containerId, status }` | `SuccessResponse` | Container heartbeat |
+| `getContainerStats()` | - | `ContainerStatsResponse` | Container stats |
 
-### 技能市场
+### Skill Marketplace
 
-| 方法 | 参数 | 返回值 | 说明 |
+| Method | Parameters | Return Value | Description |
 |------|------|--------|------|
-| `listMarketplaceSkills()` | `{ category?, page?, pageSize? }` | `MarketplaceSkillsListResponse` | 列出市场技能 |
-| `getMarketplaceSkill()` | `{ skillId }` | `MarketplaceSkill` | 获取技能详情 |
-| `installSkill()` | `{ skillId }` | `SuccessResponse` | 安装技能 |
-| `listUserSkills()` | - | `UserInstalledSkillsListResponse` | 列出已安装技能 |
-| `uninstallSkill()` | `{ skillId }` | `SuccessResponse` | 卸载技能 |
+| `listMarketplaceSkills()` | `{ category?, page?, pageSize? }` | `MarketplaceSkillsListResponse` | List marketplace skills |
+| `getMarketplaceSkill()` | `{ skillId }` | `MarketplaceSkill` | Get skill details |
+| `installSkill()` | `{ skillId }` | `SuccessResponse` | Install skill |
+| `listUserSkills()` | - | `UserInstalledSkillsListResponse` | List installed skills |
+| `uninstallSkill()` | `{ skillId }` | `SuccessResponse` | Uninstall skill |
 
-### 邀请码管理
+### Invitation Code Management
 
-| 方法 | 参数 | 返回值 | 说明 |
+| Method | Parameters | Return Value | Description |
 |------|------|--------|------|
-| `applyInvite()` | `{ email, reason }` | `ApplyInviteResponse` | 申请邀请码（reason 需10-500字符）|
-| `listInvites()` | `{ page?, page_size?, status? }` | `ListInvitesResponse` | 列出我的邀请码 |
-| `getInviteStats()` | - | `InviteStatsResponse` | 获取邀请码统计 |
-| `getInvite()` | `inviteId: string` | `InviteCodeDetailResponse` | 获取邀请码详情 |
-| `getInviteUsages()` | `inviteId: string, { page?, page_size? }` | `ListInviteUsagesResponse` | 获取邀请码使用记录 |
+| `applyInvite()` | `{ email, reason }` | `ApplyInviteResponse` | Apply for invitation code (reason needs 10-500 characters)|
+| `listInvites()` | `{ page?, page_size?, status? }` | `ListInvitesResponse` | List my invitation codes |
+| `getInviteStats()` | - | `InviteStatsResponse` | Get invitation code stats |
+| `getInvite()` | `inviteId: string` | `InviteCodeDetailResponse` | Get invitation code details |
+| `getInviteUsages()` | `inviteId: string, { page?, page_size? }` | `ListInviteUsagesResponse` | Get invitation code usage records |
 
-### 其他
+### Others
 
-| 方法 | 参数 | 返回值 | 说明 |
+| Method | Parameters | Return Value | Description |
 |------|------|--------|------|
-| `getHealth()` | - | `HealthResponse` | 健康检查 |
-| `getConversationStatus()` | `{ conversationId }` | `ConversationStatusResponse` | 获取对话状态 |
-| `getSpeechToken()` | - | `SpeechTokenResponse` | 获取语音Token |
+| `getHealth()` | - | `HealthResponse` | Health check |
+| `getConversationStatus()` | `{ conversationId }` | `ConversationStatusResponse` | Get conversation status |
+| `getSpeechToken()` | - | `SpeechTokenResponse` | Get speech token |
 
-## 响应格式兼容性
+## Response Format Compatibility
 
-### 自动响应解包
+### Auto Response Unwrapping
 
-从 v0.2.5 开始，SDK 自动兼容两种API响应格式，无需手动处理：
+Starting from v0.2.5, SDK automatically supports two API response formats, no manual handling needed:
 
-**格式 1: 包装格式**（推荐）
+**Format 1: Wrapped Format** (Recommended)
 ```json
 {
   "data": {
@@ -1299,7 +1299,7 @@ const response = await client.register({ email, password });
 }
 ```
 
-**格式 2: 扁平格式**（向后兼容）
+**Format 2: Flat Format** (Backward Compatible)
 ```json
 {
   "token": "eyJhbGc...",
@@ -1307,101 +1307,101 @@ const response = await client.register({ email, password });
 }
 ```
 
-SDK 会自动检测响应格式并提取正确的数据：
+SDK automatically detects response format and extracts correct data:
 
 ```typescript
-// 无论后端返回哪种格式，以下代码都能正常工作
+// Regardless of which format backend returns, the following code works
 const loginResult = await client.login({
   email: 'user@example.com',
   password: 'password123',
 });
 
-console.log(loginResult.token); // ✅ 始终能正确获取 token
-console.log(loginResult.user);  // ✅ 始终能正确获取 user
+console.log(loginResult.token); // ✅ Always gets token correctly
+console.log(loginResult.user);  // ✅ Always gets user correctly
 ```
 
-### 受影响的方法
+### Affected Methods
 
-以下方法已实现自动响应解包：
+The following methods have implemented auto response unwrapping:
 
-- ✅ `login()` - 登录接口
-- ✅ `register()` - 注册接口
-- ✅ `getCurrentUser()` - 获取当前用户
+- ✅ `login()` - Login API
+- ✅ `register()` - Registration API
+- ✅ `getCurrentUser()` - Get current user
 
-### 实现原理
+### Implementation Principle
 
-SDK 内部通过以下逻辑自动处理响应格式：
+SDK internally handles response format through the following logic:
 
 ```typescript
 const response = await httpClient.request(config);
 const responseData = response.data;
 
-// 检测并解包
+// Detect and unwrap
 if (responseData.data && typeof responseData.data === 'object') {
-  // 包装格式: 提取 data 字段
+  // Wrapped format: extract data field
   return responseData.data;
 }
-// 扁平格式: 直接返回
+// Flat format: return directly
 return responseData;
 ```
 
-这意味着：
-- 🔄 **后端格式变更无需前端修改** - 后端可以自由调整响应格式
-- 🔧 **渐进式迁移** - 可以逐步将不同接口迁移到新格式
-- ✅ **向后兼容** - 旧代码无需修改即可继续工作
+This means:
+- 🔄 **Backend format changes don't require frontend modifications** - Backend can freely adjust response format
+- 🔧 **Progressive migration** - Different APIs can be migrated to new format gradually
+- ✅ **Backward compatible** - Old code continues to work without modifications
 
-## 错误处理
+## Error Handling
 
-### 错误响应格式
+### Error Response Format
 
-所有 API 错误都遵循统一的响应格式:
+All API errors follow a unified response format:
 
 ```typescript
 interface ApiError {
-  success: false;           // 错误时始终为 false
-  error: string;            // 人类可读的错误消息
-  code?: string;            // 机器可读的错误码
-  details?: any;            // 额外的错误详情
+  success: false;           // Always false on error
+  error: string;            // Human-readable error message
+  code?: string;            // Machine-readable error code
+  details?: any;            // Additional error details
 }
 ```
 
-### 错误码
+### Error Codes
 
-SDK 提供了标准的错误码枚举:
+SDK provides standard error code enums:
 
 ```typescript
 import { ErrorCode } from '@seaverse/auth-sdk';
 
-// 账户相关错误
-ErrorCode.ACCOUNT_EXISTS         // 账户已存在
-ErrorCode.ACCOUNT_NOT_FOUND      // 账户不存在
-ErrorCode.ACCOUNT_SUSPENDED      // 账户已被暂停
-ErrorCode.INVALID_CREDENTIALS    // 登录凭证无效
-ErrorCode.EMAIL_NOT_VERIFIED     // 邮箱未验证
-
-// 验证相关错误
-ErrorCode.INVALID_EMAIL          // 无效的邮箱地址
-ErrorCode.INVALID_PASSWORD       // 无效的密码
-ErrorCode.PASSWORD_TOO_WEAK      // 密码强度不够
-
-// 邀请码相关错误
-ErrorCode.INVALID_INVITATION_CODE // 无效的邀请码
-ErrorCode.INVITATION_REQUIRED     // 需要邀请码
-ErrorCode.INVITE_CODE_REQUIRED    // 需要邀请码（会自动跳转到 redirectUrl）
-
-// Token 相关错误
-ErrorCode.INVALID_TOKEN          // 无效的 token
-ErrorCode.TOKEN_EXPIRED          // Token 已过期
-
-// 内部错误
-ErrorCode.INTERNAL_ERROR         // 服务器内部错误
+// Account-related errors
+ErrorCode.ACCOUNT_EXISTS         // Account already exists
+ErrorCode.ACCOUNT_NOT_FOUND      // Account not found
+ErrorCode.ACCOUNT_SUSPENDED      // Account suspended
+ErrorCode.INVALID_CREDENTIALS    // Invalid login credentials
+ErrorCode.EMAIL_NOT_VERIFIED     // Email not verified
+
+// Validation-related errors
+ErrorCode.INVALID_EMAIL          // Invalid email address
+ErrorCode.INVALID_PASSWORD       // Invalid password
+ErrorCode.PASSWORD_TOO_WEAK      // Password too weak
+
+// Invitation code-related errors
+ErrorCode.INVALID_INVITATION_CODE // Invalid invitation code
+ErrorCode.INVITATION_REQUIRED     // Invitation code required
+ErrorCode.INVITE_CODE_REQUIRED    // Invitation code required (will auto-redirect to redirectUrl)
+
+// Token-related errors
+ErrorCode.INVALID_TOKEN          // Invalid token
+ErrorCode.TOKEN_EXPIRED          // Token expired
+
+// Internal errors
+ErrorCode.INTERNAL_ERROR         // Server internal error
 ```
 
-### 错误处理最佳实践
+### Error Handling Best Practices
 
-#### 1. 注册时处理重复用户
+#### 1. Handle Duplicate Users During Registration
 
-由于后端在账户已存在时返回 200 OK（成功响应），所以前端不会抛出异常，而是在响应体中包含错误信息。
+Since backend returns 200 OK when account exists (success response), frontend won't throw exception, but includes error info in response body.
 
 ```typescript
 import { ErrorCode } from '@seaverse/auth-sdk';
@@ -1411,27 +1411,27 @@ const result = await client.register({
   password: 'password123',
 });
 
-// 检查响应中的 success 字段
+// Check success field in response
 if (result.success) {
-  console.log('注册成功:', result);
-  // 进行后续操作，如自动登录
+  console.log('Registration successful:', result);
+  // Proceed with follow-up actions, such as auto-login
 } else if (result.code === ErrorCode.ACCOUNT_EXISTS) {
-  // 账户已存在，提示用户
+  // Account exists, prompt user
   const { email, app_id } = result.details;
-  console.log(`账户 ${email} 已存在于应用 ${app_id} 中`);
+  console.log(`Account ${email} already exists in application ${app_id}`);
 
-  // 显示友好的提示信息
+  // Show friendly prompt
   alert('This email is already registered. Please login instead.');
 
-  // 或者引导用户去登录
+  // Or guide user to login
   showLoginModal();
 } else {
-  // 处理其他错误
-  console.error('注册失败:', result.error);
+  // Handle other errors
+  console.error('Registration failed:', result.error);
 }
 ```
 
-#### 2. 登录时处理各种错误
+#### 2. Handle Various Errors During Login
 
 ```typescript
 try {
@@ -1439,28 +1439,28 @@ try {
     email: 'user@example.com',
     password: 'wrong-password',
   });
-  console.log('登录成功:', result);
+  console.log('Login successful:', result);
 } catch (error) {
   const errorCode = error.response?.data?.code;
 
   switch (errorCode) {
     case ErrorCode.INVALID_CREDENTIALS:
-      showError('用户名或密码错误');
+      showError('Incorrect username or password');
       break;
     case ErrorCode.EMAIL_NOT_VERIFIED:
-      showError('请先验证您的邮箱');
+      showError('Please verify your email first');
       showResendVerificationButton();
       break;
     case ErrorCode.ACCOUNT_SUSPENDED:
-      showError('您的账户已被暂停，请联系管理员');
+      showError('Your account has been suspended, please contact administrator');
       break;
     default:
-      showError('登录失败，请稍后重试');
+      showError('Login failed, please try again later');
   }
 }
 ```
 
-#### 3. 通用错误处理函数
+#### 3. Generic Error Handling Function
 
 ```typescript
 import { ErrorCode } from '@seaverse/auth-sdk';
@@ -1469,44 +1469,44 @@ function handleApiError(error: any) {
   const apiError = error.response?.data;
 
   if (!apiError) {
-    // 网络错误或其他未知错误
+    // Network error or other unknown error
     return {
-      title: '网络错误',
-      message: '请检查您的网络连接',
+      title: 'Network Error',
+      message: 'Please check your network connection',
     };
   }
 
-  // 根据错误码返回用户友好的消息
+  // Return user-friendly messages based on error code
   const errorMessages: Record<string, { title: string; message: string }> = {
     [ErrorCode.ACCOUNT_EXISTS]: {
-      title: '账户已存在',
-      message: '该邮箱已注册，请直接登录',
+      title: 'Account Exists',
+      message: 'This email is already registered, please login directly',
     },
     [ErrorCode.INVALID_CREDENTIALS]: {
-      title: '登录失败',
-      message: '用户名或密码错误',
+      title: 'Login Failed',
+      message: 'Incorrect username or password',
     },
     [ErrorCode.EMAIL_NOT_VERIFIED]: {
-      title: '邮箱未验证',
-      message: '请先验证您的邮箱地址',
+      title: 'Email Not Verified',
+      message: 'Please verify your email address first',
     },
     [ErrorCode.INVALID_INVITATION_CODE]: {
-      title: '邀请码无效',
-      message: '请检查您的邀请码是否正确',
+      title: 'Invalid Invitation Code',
+      message: 'Please check if your invitation code is correct',
     },
     [ErrorCode.TOKEN_EXPIRED]: {
-      title: '登录已过期',
-      message: '请重新登录',
+      title: 'Login Expired',
+      message: 'Please login again',
     },
   };
 
   return errorMessages[apiError.code] || {
-    title: '操作失败',
-    message: apiError.error || '发生未知错误',
+    title: 'Operation Failed',
+    message: apiError.error || 'Unknown error occurred',
   };
 }
 
-// 使用示例
+// Usage example
 try {
   await client.register({ email, password });
 } catch (error) {
@@ -1515,7 +1515,7 @@ try {
 }
 ```
 
-#### 4. TypeScript 类型安全的错误处理
+#### 4. TypeScript Type-Safe Error Handling
 
 ```typescript
 import { ErrorCode, models } from '@seaverse/auth-sdk';
@@ -1555,164 +1555,164 @@ if (registerResult.success) {
 }
 ```
 
-### HTTP 状态码对照
+### HTTP Status Code Reference
 
-| HTTP状态码 | 错误码示例 | 说明 |
+| HTTP Status Code | Error Code Example | Description |
 |-----------|----------|------|
-| 200 OK | `ACCOUNT_EXISTS` | 账户已存在（业务错误但返回成功响应） |
-| 400 Bad Request | `INVALID_EMAIL`, `PASSWORD_TOO_WEAK` | 请求参数无效 |
-| 401 Unauthorized | `INVALID_CREDENTIALS`, `TOKEN_EXPIRED` | 认证失败 |
-| 403 Forbidden | `EMAIL_NOT_VERIFIED`, `ACCOUNT_SUSPENDED` | 权限不足 |
-| 500 Internal Server Error | `INTERNAL_ERROR` | 服务器内部错误 |
+| 200 OK | `ACCOUNT_EXISTS` | Account exists (business error but returns success response) |
+| 400 Bad Request | `INVALID_EMAIL`, `PASSWORD_TOO_WEAK` | Invalid request parameters |
+| 401 Unauthorized | `INVALID_CREDENTIALS`, `TOKEN_EXPIRED` | Authentication failed |
+| 403 Forbidden | `EMAIL_NOT_VERIFIED`, `ACCOUNT_SUSPENDED` | Insufficient permissions |
+| 500 Internal Server Error | `INTERNAL_ERROR` | Server internal error |
 
-**注意**：对于注册接口，账户已存在的情况会返回 200 OK，但在响应体中 `success: false` 和 `code: "ACCOUNT_EXISTS"`。这样设计是为了前端能够更容易地处理这种常见的业务场景。
+**Note**: For registration API, account exists case returns 200 OK, but in response body `success: false` and `code: "ACCOUNT_EXISTS"`. This design makes it easier for frontend to handle this common business scenario.
 
-## 类型定义
+## Type Definitions
 
 ```typescript
-// 用户信息
+// User info
 interface User {
   id?: string;
-  app_id?: string | null;           // 应用ID（多租户支持）
+  app_id?: string | null;           // Application ID (multi-tenant support)
   email?: string;
   username?: string;
-  created_at?: number;               // Unix时间戳
-  email_verified?: boolean;          // 邮箱验证状态
-  google_id?: string | null;         // Google账号ID
-  discord_id?: string | null;        // Discord账号ID
-  github_id?: string | null;         // GitHub账号ID
-
-  // 已弃用字段（向后兼容）
-  createdAt?: number;                // @deprecated 使用 created_at
-  emailVerified?: boolean;           // @deprecated 使用 email_verified
-  googleId?: string;                 // @deprecated 使用 google_id
-  discordId?: string;                // @deprecated 使用 discord_id
-  githubId?: string;                 // @deprecated 使用 github_id
+  created_at?: number;               // Unix timestamp
+  email_verified?: boolean;          // Email verification status
+  google_id?: string | null;         // Google account ID
+  discord_id?: string | null;        // Discord account ID
+  github_id?: string | null;         // GitHub account ID
+
+  // Deprecated fields (backward compatible)
+  createdAt?: number;                // @deprecated Use created_at
+  emailVerified?: boolean;           // @deprecated Use email_verified
+  googleId?: string;                 // @deprecated Use google_id
+  discordId?: string;                // @deprecated Use discord_id
+  githubId?: string;                 // @deprecated Use github_id
 }
 
-// 登录响应
+// Login response
 interface LoginResponse {
   token: string;
   user: User;
 }
 
-// 注册响应
+// Registration response
 interface RegisterResponse {
   success: boolean;
   message?: string;
   userId?: string;
-  // 邮箱验证相关
-  requiresEmailVerification?: boolean;  // 是否需要邮箱验证
-  // 邀请码激活相关
-  requiresInvitationCode?: boolean;     // 是否需要邀请码激活
-  tempUserId?: string;                  // 临时用户ID（需要激活）
-  // 错误信息
+  // Email verification related
+  requiresEmailVerification?: boolean;  // Whether email verification is required
+  // Invitation code activation related
+  requiresInvitationCode?: boolean;     // Whether invitation code activation is required
+  tempUserId?: string;                  // Temporary user ID (needs activation)
+  // Error info
   error?: string;
-  code?: string;                        // 如 'ACCOUNT_EXISTS'
+  code?: string;                        // E.g. 'ACCOUNT_EXISTS'
   details?: Record<string, any>;
 }
 
-// AuthModal选项
+// AuthModal options
 interface AuthModalOptions {
   client: SeaVerseBackendAPIClient;
   theme?: 'dark' | 'light';
   onLoginSuccess?: (token: string, user: any) => void;
   onSignupSuccess?: (token: string, user: any) => void;
-  onInviteCodeRequired?: (userId: string, email: string) => void; // 当需要邀请码激活时的回调
-  onApplyInviteSuccess?: (applicationId: string, email: string) => void; // 申请邀请码成功的回调
+  onInviteCodeRequired?: (userId: string, email: string) => void; // Callback when invitation code activation is needed
+  onApplyInviteSuccess?: (applicationId: string, email: string) => void; // Callback when invitation code application succeeds
   onError?: (error: Error) => void;
-  returnUrl?: string;        // OAuth 登录后返回的 URL，可选，默认为 window.location.href
+  returnUrl?: string;        // URL to return after OAuth login, optional, defaults to window.location.href
   enableOAuth?: {
-    google?: boolean;        // 启用 Google 登录
-    discord?: boolean;       // 启用 Discord 登录
-    github?: boolean;        // 启用 GitHub 登录
+    google?: boolean;        // Enable Google login
+    discord?: boolean;       // Enable Discord login
+    github?: boolean;        // Enable GitHub login
   };
 }
 ```
 
-## 完整示例
+## Complete Examples
 
-查看 [examples/auth-sdk-demo](../../examples/auth-sdk-demo) 目录获取完整的可运行示例。
+Check [examples/auth-sdk-demo](../../examples/auth-sdk-demo) directory for complete runnable examples.
 
 ```bash
-# 运行示例
+# Run example
 cd examples/auth-sdk-demo
 pnpm install
 pnpm dev
 ```
 
-## 从旧版本迁移
+## Migration from Old Versions
 
-### v0.1.x → v0.2.0 升级指南
+### v0.1.x → v0.2.0 Upgrade Guide
 
-#### 1. 向后兼容性
-好消息！v0.2.0 完全向后兼容，现有代码**无需修改**即可继续工作。
+#### 1. Backward Compatibility
+Good news! v0.2.0 is fully backward compatible, existing code **works without modifications**.
 
-#### 2. 推荐的迁移步骤
+#### 2. Recommended Migration Steps
 
-虽然不是必须的，但我们建议逐步迁移到新的字段命名规范：
+While not required, we recommend gradually migrating to new field naming conventions:
 
 ```typescript
-// 旧代码（仍然可用）
+// Old code (still works)
 const user = await client.getCurrentUser();
-console.log(user.emailVerified);  // ⚠️ 已弃用但可用
-console.log(user.createdAt);      // ⚠️ 已弃用但可用
+console.log(user.emailVerified);  // ⚠️ Deprecated but works
+console.log(user.createdAt);      // ⚠️ Deprecated but works
 
-// 新代码（推荐）
+// New code (recommended)
 const user = await client.getCurrentUser();
-console.log(user.email_verified); // ✅ 推荐使用
-console.log(user.created_at);     // ✅ 推荐使用
-console.log(user.app_id);         // ✅ 新字段：多租户支持
+console.log(user.email_verified); // ✅ Recommended
+console.log(user.created_at);     // ✅ Recommended
+console.log(user.app_id);         // ✅ New field: multi-tenant support
 ```
 
-#### 3. 注册接口更新
+#### 3. Registration API Update
 
 ```typescript
-// 旧代码（仍然可用）
+// Old code (still works)
 await client.register({
   email: 'user@example.com',
   password: 'password123',
-  invitationCode: 'INVITE123',  // ⚠️ 已弃用但可用
+  invitationCode: 'INVITE123',  // ⚠️ Deprecated but works
 });
 
-// 新代码（推荐）
+// New code (recommended)
 await client.register({
   email: 'user@example.com',
   password: 'password123',
-  username: 'myusername',       // ✨ 新功能
-  invitation_code: 'INVITE123', // ✅ 推荐使用
+  username: 'myusername',       // ✨ New feature
+  invitation_code: 'INVITE123', // ✅ Recommended
 });
 ```
 
-#### 4. 密码重置接口更新
+#### 4. Password Reset API Update
 
 ```typescript
-// 旧代码（需要更新）
+// Old code (needs update)
 await client.resetPassword({
   token: 'reset-token',
-  newPassword: 'NewPass123',    // ⚠️ 已弃用
+  newPassword: 'NewPass123',    // ⚠️ Deprecated
 });
 
-// 新代码（推荐）
+// New code (recommended)
 await client.resetPassword({
   token: 'reset-token',
-  new_password: 'NewPass123',   // ✅ 推荐使用
+  new_password: 'NewPass123',   // ✅ Recommended
 });
 ```
 
-#### 5. TypeScript 类型提示
+#### 5. TypeScript Type Hints
 
-如果你使用 TypeScript，编译器会自动提示已弃用的字段：
+If you use TypeScript, compiler will automatically hint deprecated fields:
 
 ```typescript
 const user = await client.getCurrentUser();
-user.emailVerified;  // TypeScript 会显示删除线和弃用警告
-user.email_verified; // ✅ 无警告
+user.emailVerified;  // TypeScript will show strikethrough and deprecation warning
+user.email_verified; // ✅ No warning
 ```
 
-#### 6. 多租户功能（新增）
+#### 6. Multi-Tenant Feature (New)
 
-如果你的应用需要支持多租户架构，可以使用新的 `app_id` 字段：
+If your application needs multi-tenant architecture support, you can use the new `app_id` field:
 
 ```typescript
 const user = await client.getCurrentUser();
@@ -1720,20 +1720,20 @@ const user = await client.getCurrentUser();
 console.log('your app id:', user.app_id);
 ```
 
-## 常见问题
+## FAQ
 
-### 如何处理认证token？
+### How to Handle Authentication Token?
 
 ```typescript
-// 登录成功后保存token
+// Save token after successful login
 const loginResult = await client.login({ email, password });
 localStorage.setItem('token', loginResult.token);
 
-// 创建带认证的client
+// Create authenticated client
 import { AuthFactory } from '@seaverse/auth-sdk';
 
 const authenticatedClient = new SeaVerseBackendAPIClient({
-  appId: 'your app id',         // 必需：应用ID
+  appId: 'your app id',         // Required: Application ID
   environment: 'production',
   auth: AuthFactory.create({
     type: 'jwt',
@@ -1745,49 +1745,49 @@ const authenticatedClient = new SeaVerseBackendAPIClient({
 });
 ```
 
-### OAuth redirect_uri_mismatch错误？
+### OAuth redirect_uri_mismatch Error?
 
-确保OAuth应用配置中的重定向URI与代码中的`redirectUri`完全一致（包括协议、域名、端口、路径）。
+Ensure the redirect URI in OAuth application configuration exactly matches the `redirectUri` in code (including protocol, domain, port, path).
 
-### 如何自定义请求超时？
+### How to Customize Request Timeout?
 
 ```typescript
 const client = new SeaVerseBackendAPIClient({
-  appId: 'your app id',         // 必需：应用ID
+  appId: 'your app id',         // Required: Application ID
   environment: 'production',
-  timeout: 30000,            // 30秒
+  timeout: 30000,            // 30 seconds
 });
 ```
 
-### 本地开发如何连接到本地API？
+### How to Connect to Local API in Local Development?
 
 ```typescript
 const client = new SeaVerseBackendAPIClient({
-  appId: 'your app id',         // 必需：应用ID
-  environment: 'local',      // 或使用 baseURL: 'http://localhost:3000'
+  appId: 'your app id',         // Required: Application ID
+  environment: 'local',      // Or use baseURL: 'http://localhost:3000'
 });
 ```
 
-## 开发
+## Development
 
 ```bash
-# 安装依赖
+# Install dependencies
 pnpm install
 
-# 构建
+# Build
 pnpm build
 
-# Watch模式
+# Watch mode
 pnpm dev
 
-# 测试
+# Test
 pnpm test
 ```
 
-## 相关链接
+## Related Links
 
 - 📦 [NPM Package](https://www.npmjs.com/package/@seaverse/auth-sdk)
-- 📖 [示例项目](../../examples/auth-sdk-demo)
+- 📖 [Example Project](../../examples/auth-sdk-demo)
 - 🐛 [Issues](https://github.com/seaverseai/sv-sdk/issues)
 - 💬 [Discussions](https://github.com/seaverseai/sv-sdk/discussions)
 
@@ -1795,48 +1795,48 @@ pnpm test
 
 MIT © [SeaVerse Team](mailto:support@seaverse.com)
 
-## 更新日志
+## Changelog
 
-### v0.3.6 (当前版本)
-- 🧹 **代码清理**: 移除桌面应用OAuth回调相关功能
-  - 移除 `oauthDesktopURL` 配置选项
-  - 简化OAuth流程，统一使用 `returnUrl` 参数
-  - 清理相关文档和代码注释
+### v0.3.6 (Current Version)
+- 🧹 **Code Cleanup**: Remove desktop application OAuth callback related functionality
+  - Remove `oauthDesktopURL` configuration option
+  - Simplify OAuth flow, unified use of `returnUrl` parameter
+  - Clean up related documentation and code comments
 
 ### v0.2.5
-- 🔄 **响应格式兼容**: 自动兼容包装格式和扁平格式的API响应
-  - 修复登录时提示 "Invalid response from server" 的问题
-  - `login()`, `register()`, `getCurrentUser()` 方法自动解包 `data` 字段
-  - 支持两种格式: `{ data: {...}, success: true }` 和 `{ ... }`
-- 📝 **文档更新**: 新增响应格式兼容性章节
+- 🔄 **Response Format Compatibility**: Automatic compatibility with wrapped and flat API response formats
+  - Fix "Invalid response from server" prompt during login
+  - `login()`, `register()`, `getCurrentUser()` methods auto-unwrap `data` field
+  - Support two formats: `{ data: {...}, success: true }` and `{ ... }`
+- 📝 **Documentation Update**: Add response format compatibility section
 
 ### v0.2.0
-- 🔄 **API路径更新**: 所有认证API从 `/api/auth/*` 迁移到 `/sdk/v1/auth/*`
-- 🏢 **多租户支持**: User模型新增 `app_id` 字段，支持多应用隔离
-- 🔑 **重要变更**: `appId` 现在是**必需参数**，SDK 自动在所有请求中添加 `X-App-ID` 请求头
-- ✨ **新功能**:
-  - 注册时支持自定义 `username`（可选）
-  - 所有字段标准化为 snake_case（保留 camelCase 向后兼容）
-- 📝 **字段更新**:
-  - `SeaVerseBackendAPIClientOptions`: 新增必需字段 `appId`
-  - `User`: 新增 `app_id`, `created_at`, `email_verified`, `google_id`, `discord_id`, `github_id`
-  - `RegisterRequest`: 新增 `username`, `invitation_code`
+- 🔄 **API Path Update**: All authentication APIs migrated from `/api/auth/*` to `/sdk/v1/auth/*`
+- 🏢 **Multi-Tenant Support**: User model adds `app_id` field, supports multi-application isolation
+- 🔑 **Important Change**: `appId` is now a **required parameter**, SDK automatically adds `X-App-ID` request header to all requests
+- ✨ **New Features**:
+  - Registration supports custom `username` (optional)
+  - All fields standardized to snake_case (retains camelCase backward compatibility)
+- 📝 **Field Updates**:
+  - `SeaVerseBackendAPIClientOptions`: Add required field `appId`
+  - `User`: Add `app_id`, `created_at`, `email_verified`, `google_id`, `discord_id`, `github_id`
+  - `RegisterRequest`: Add `username`, `invitation_code`
   - `ResetPasswordRequest`: `newPassword` → `new_password`
 - ⚠️ **Breaking Changes**:
-  - 必须提供 `appId` 参数才能初始化 client
-  - API 路径变更需要后端支持
-- ✅ **向后兼容**: 除 `appId` 外，所有旧字段仍然可用
+  - Must provide `appId` parameter to initialize client
+  - API path changes require backend support
+- ✅ **Backward Compatible**: Except for `appId`, all old fields still work
 
 ### v0.1.5
-- 修复OAuth state管理，从sessionStorage切换到localStorage
-- 增强API响应处理
+- Fix OAuth state management, switch from sessionStorage to localStorage
+- Enhance API response handling
 
 ### v0.1.4
-- 增强API响应处理
-- 优化错误处理
+- Enhance API response handling
+- Optimize error handling
 
 ### v0.1.2
-- 更新包名为@seaverse/auth-sdk
-- 添加多环境支持
+- Update package name to @seaverse/auth-sdk
+- Add multi-environment support
 
-查看完整更新日志：[CHANGELOG.md](./CHANGELOG.md)
+View complete changelog: [CHANGELOG.md](./CHANGELOG.md)