Merge branch 'main' of https://github.com/TheSmallHanCat/flow2api

.gitignore

@@ -54,3 +54,7 @@ logs.txt
 *.cache
 
 browser_data
+
+data
+config/setting.toml
+config/setting_warp.toml

Dockerfile

@@ -2,6 +2,10 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
+# 使用清华镜像源加速 apt (Debian bookworm)
+RUN sed -i 's|deb.debian.org|mirrors.tuna.tsinghua.edu.cn|g' /etc/apt/sources.list.d/debian.sources \
+    && sed -i 's|security.debian.org|mirrors.tuna.tsinghua.edu.cn|g' /etc/apt/sources.list.d/debian.sources
+
 # 安装 Playwright 所需的系统依赖
 RUN apt-get update && apt-get install -y \
     libnss3 \
@@ -21,9 +25,14 @@ RUN apt-get update && apt-get install -y \
     libcairo2 \
     && rm -rf /var/lib/apt/lists/*
 
-# 安装 Python 依赖
+# 安装 Python 依赖（使用清华 PyPI 镜像）
 COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt \
+    -i https://pypi.tuna.tsinghua.edu.cn/simple/ \
+    --trusted-host pypi.tuna.tsinghua.edu.cn
+
+# 设置 Playwright 下载镜像（使用 npmmirror）
+ENV PLAYWRIGHT_DOWNLOAD_HOST=https://registry.npmmirror.com/-/binary/playwright
 
 # 安装 Playwright 浏览器
 RUN playwright install chromium

README.md

@@ -16,7 +16,7 @@
 - 🎨 **文生图** / **图生图**
 - 🎬 **文生视频** / **图生视频**
 - 🎞️ **首尾帧视频**
-- 🔄 **AT自动刷新**
+- 🔄 **AT/ST自动刷新** - AT 过期自动刷新，ST 过期时自动通过浏览器更新（personal 模式）
 - 📊 **余额显示** - 实时查询和显示 VideoFX Credits
 - 🚀 **负载均衡** - 多 Token 轮询和并发控制
 - 🌐 **代理支持** - 支持 HTTP/SOCKS5 代理
@@ -119,7 +119,11 @@ python main.py
 | `veo_2_0_t2v_landscape` | 文生视频 | 横屏 |
 
 #### 首尾帧模型 (I2V - Image to Video)
-📸 **支持1-2张图片：首尾帧**
+📸 **支持1-2张图片：1张作为首帧，2张作为首尾帧**
+
+> 💡 **自动适配**：系统会根据图片数量自动选择对应的 model_key
+> - **单帧模式**（1张图）：使用首帧生成视频
+> - **双帧模式**（2张图）：使用首帧+尾帧生成过渡视频
 
 | 模型名称 | 说明| 尺寸 |
 |---------|---------|--------|

config/setting.toml

@@ -12,7 +12,7 @@ max_poll_attempts = 200
 
 [server]
 host = "0.0.0.0"
-port = 8000
+port = 18282
 
 [debug]
 enabled = false
@@ -21,8 +21,8 @@ log_responses = true
 mask_token = true
 
 [proxy]
-proxy_enabled = false
-proxy_url = ""
+proxy_enabled = true
+proxy_url = "http://localhost:7897"
 
 [generation]
 image_timeout = 300

config/setting_example.toml

@@ -0,0 +1,42 @@
+[global]
+api_key = "han1234"
+admin_username = "admin"
+admin_password = "admin"
+
+[flow]
+labs_base_url = "https://labs.google/fx/api"
+api_base_url = "https://aisandbox-pa.googleapis.com/v1"
+timeout = 120
+poll_interval = 3.0
+max_poll_attempts = 200
+
+[server]
+host = "0.0.0.0"
+port = 18282
+
+[debug]
+enabled = false
+log_requests = true
+log_responses = true
+mask_token = true
+
+[proxy]
+proxy_enabled = true
+proxy_url = "http://localhost:7897"
+
+[generation]
+image_timeout = 300
+video_timeout = 1500
+
+[admin]
+error_ban_threshold = 3
+
+[cache]
+enabled = false
+timeout = 7200  # 缓存超时时间(秒), 默认2小时
+base_url = ""   # 缓存文件访问的基础URL, 留空则使用服务器地址
+
+[captcha]
+captcha_method = "browser"  # 打码方式: yescaptcha 或 browser
+yescaptcha_api_key = ""  # YesCaptcha API密钥
+yescaptcha_base_url = "https://api.yescaptcha.com"

config/setting_warp_example.toml

@@ -0,0 +1,42 @@
+[global]
+api_key = "han1234"
+admin_username = "admin"
+admin_password = "admin"
+
+[flow]
+labs_base_url = "https://labs.google/fx/api"
+api_base_url = "https://aisandbox-pa.googleapis.com/v1"
+timeout = 120
+poll_interval = 3.0
+max_poll_attempts = 200
+
+[server]
+host = "0.0.0.0"
+port = 8000
+
+[debug]
+enabled = false
+log_requests = true
+log_responses = true
+mask_token = true
+
+[proxy]
+proxy_enabled = true
+proxy_url = "socks5://warp:1080"
+
+[generation]
+image_timeout = 300
+video_timeout = 1500
+
+[admin]
+error_ban_threshold = 3
+
+[cache]
+enabled = false
+timeout = 7200  # 缓存超时时间(秒), 默认2小时
+base_url = ""   # 缓存文件访问的基础URL, 留空则使用服务器地址
+
+[captcha]
+captcha_method = "browser"  # 打码方式: yescaptcha 或 browser
+yescaptcha_api_key = ""  # YesCaptcha API密钥
+yescaptcha_base_url = "https://api.yescaptcha.com"

docker-compose.local.yml

@@ -0,0 +1,17 @@
+version: '3.8'
+
+services:
+  flow2api:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: flow2api:local
+    container_name: flow2api
+    ports:
+      - "38000:8000"
+    volumes:
+      - ./data:/app/data
+      - ./config/setting.toml:/app/config/setting.toml
+    environment:
+      - PYTHONUNBUFFERED=1
+    restart: unless-stopped

docker-compose.proxy.yml

@@ -5,7 +5,7 @@ services:
     image: thesmallhancat/flow2api:latest
     container_name: flow2api
     ports:
-      - "8000:8000"
+      - "38000:8000"
     volumes:
       - ./data:/app/data
       - ./config/setting_warp.toml:/app/config/setting.toml
@@ -22,7 +22,7 @@ services:
     devices:
       - /dev/net/tun:/dev/net/tun
     ports:
-      - "1080:1080"
+      - "31080:1080"
     environment:
       - WARP_SLEEP=2
     cap_add:
@@ -33,4 +33,4 @@ services:
       - net.ipv6.conf.all.disable_ipv6=0
       - net.ipv4.conf.all.src_valid_mark=1
     volumes:
-      - ./data:/var/lib/cloudflare-warp
+      - ./data:/var/lib/cloudflare-warp

docker-compose.yml

@@ -5,7 +5,7 @@ services:
     image: thesmallhancat/flow2api:latest
     container_name: flow2api
     ports:
-      - "8000:8000"
+      - "38000:8000"
     volumes:
       - ./data:/app/data
       - ./config/setting.toml:/app/config/setting.toml

requirements.txt

@@ -8,3 +8,4 @@ bcrypt==4.2.1
 python-multipart==0.0.20
 python-dateutil==2.8.2
 playwright==1.53.0
+nodriver>=0.48.0

src/api/admin.py

@@ -354,17 +354,32 @@ async def refresh_at(
     token_id: int,
     token: str = Depends(verify_admin_token)
 ):
-    """手动刷新Token的AT (使用ST转换) 🆕"""
+    """手动刷新Token的AT (使用ST转换) 🆕
+    
+    如果 AT 刷新失败且处于 personal 模式，会自动尝试通过浏览器刷新 ST
+    """
+    from ..core.logger import debug_logger
+    from ..core.config import config
+    
+    debug_logger.log_info(f"[API] 手动刷新 AT 请求: token_id={token_id}, captcha_method={config.captcha_method}")
+    
     try:
-        # 调用token_manager的内部刷新方法
+        # 调用token_manager的内部刷新方法（包含 ST 自动刷新逻辑）
         success = await token_manager._refresh_at(token_id)
 
         if success:
             # 获取更新后的token信息
             updated_token = await token_manager.get_token(token_id)
+            
+            message = "AT刷新成功"
+            if config.captcha_method == "personal":
+                message += "（支持ST自动刷新）"
+            
+            debug_logger.log_info(f"[API] AT 刷新成功: token_id={token_id}")
+            
             return {
                 "success": True,
-                "message": "AT刷新成功",
+                "message": message,
                 "token": {
                     "id": updated_token.id,
                     "email": updated_token.email,
@@ -372,8 +387,17 @@ async def refresh_at(
                 }
             }
         else:
-            raise HTTPException(status_code=500, detail="AT刷新失败")
+            debug_logger.log_error(f"[API] AT 刷新失败: token_id={token_id}")
+            
+            error_detail = "AT刷新失败"
+            if config.captcha_method != "personal":
+                error_detail += f"（当前打码模式: {config.captcha_method}，ST自动刷新仅在 personal 模式下可用）"
+            
+            raise HTTPException(status_code=500, detail=error_detail)
+    except HTTPException:
+        raise
     except Exception as e:
+        debug_logger.log_error(f"[API] 刷新AT异常: {str(e)}")
         raise HTTPException(status_code=500, detail=f"刷新AT失败: {str(e)}")
 
 

src/api/routes.py

@@ -111,7 +111,7 @@ async def create_chat_completion(
                 if item.get("type") == "text":
                     prompt = item.get("text", "")
                 elif item.get("type") == "image_url":
-                    # Extract base64 image
+                    # Extract image from URL or base64
                     image_url = item.get("image_url", {}).get("url", "")
                     if image_url.startswith("data:image"):
                         # Parse base64
@@ -120,6 +120,18 @@ async def create_chat_completion(
                             image_base64 = match.group(1)
                             image_bytes = base64.b64decode(image_base64)
                             images.append(image_bytes)
+                    elif image_url.startswith("http://") or image_url.startswith("https://"):
+                        # Download remote image URL
+                        debug_logger.log_info(f"[IMAGE_URL] 下载远程图片: {image_url}")
+                        try:
+                            downloaded_bytes = await retrieve_image_data(image_url)
+                            if downloaded_bytes and len(downloaded_bytes) > 0:
+                                images.append(downloaded_bytes)
+                                debug_logger.log_info(f"[IMAGE_URL] ✅ 远程图片下载成功: {len(downloaded_bytes)} 字节")
+                            else:
+                                debug_logger.log_warning(f"[IMAGE_URL] ⚠️ 远程图片下载失败或为空: {image_url}")
+                        except Exception as e:
+                            debug_logger.log_error(f"[IMAGE_URL] ❌ 远程图片下载异常: {str(e)}")
 
         # Fallback to deprecated image parameter
         if request.image and not images:

src/main.py

@@ -68,6 +68,7 @@ async def lifespan(app: FastAPI):
 
     # Load captcha configuration from database
     captcha_config = await db.get_captcha_config()
+    
     config.set_captcha_method(captcha_config.captcha_method)
     config.set_yescaptcha_api_key(captcha_config.yescaptcha_api_key)
     config.set_yescaptcha_base_url(captcha_config.yescaptcha_base_url)
@@ -83,8 +84,24 @@ async def lifespan(app: FastAPI):
     if captcha_config.captcha_method == "personal":
         from .services.browser_captcha_personal import BrowserCaptchaService
         browser_service = await BrowserCaptchaService.get_instance(db)
-        await browser_service.open_login_window()
-        print("✓ Browser captcha service initialized (webui mode)")
+        print("✓ Browser captcha service initialized (nodriver mode)")
+        
+        # 启动常驻模式：从第一个可用token获取project_id
+        tokens = await token_manager.get_all_tokens()
+        resident_project_id = None
+        for t in tokens:
+            if t.current_project_id and t.is_active:
+                resident_project_id = t.current_project_id
+                break
+        
+        if resident_project_id:
+            # 直接启动常驻模式（会自动导航到项目页面，cookie已持久化）
+            await browser_service.start_resident_mode(resident_project_id)
+            print(f"✓ Browser captcha resident mode started (project: {resident_project_id[:8]}...)")
+        else:
+            # 没有可用的project_id时，打开登录窗口供用户手动操作
+            await browser_service.open_login_window()
+            print("⚠ No active token with project_id found, opened login window for manual setup")
     elif captcha_config.captcha_method == "browser":
         from .services.browser_captcha import BrowserCaptchaService
         browser_service = await BrowserCaptchaService.get_instance(db)
@@ -92,6 +109,7 @@ async def lifespan(app: FastAPI):
 
     # Initialize concurrency manager
     tokens = await token_manager.get_all_tokens()
+
     await concurrency_manager.initialize(tokens)
 
     # Start file cache cleanup task
@@ -141,7 +159,7 @@ async def lifespan(app: FastAPI):
 # Initialize components
 db = Database()
 proxy_manager = ProxyManager(db)
-flow_client = FlowClient(proxy_manager)
+flow_client = FlowClient(proxy_manager, db)
 token_manager = TokenManager(db, flow_client)
 concurrency_manager = ConcurrencyManager()
 load_balancer = LoadBalancer(token_manager, concurrency_manager)

src/services/browser_captcha_personal.py

@@ -1,197 +1,677 @@
+"""
+浏览器自动化获取 reCAPTCHA token
+使用 nodriver (undetected-chromedriver 继任者) 实现反检测浏览器
+支持常驻模式：为每个 project_id 自动创建常驻标签页，即时生成 token
+"""
 import asyncio
 import time
-import re
 import os
-from typing import Optional, Dict
-from playwright.async_api import async_playwright, BrowserContext, Page
+from typing import Optional
+
+import nodriver as uc
 
 from ..core.logger import debug_logger
 
-# ... (保持原来的 parse_proxy_url 和 validate_browser_proxy_url 函数不变) ...
-def parse_proxy_url(proxy_url: str) -> Optional[Dict[str, str]]:
-    """解析代理URL，分离协议、主机、端口、认证信息"""
-    proxy_pattern = r'^(socks5|http|https)://(?:([^:]+):([^@]+)@)?([^:]+):(\d+)$'
-    match = re.match(proxy_pattern, proxy_url)
-    if match:
-        protocol, username, password, host, port = match.groups()
-        proxy_config = {'server': f'{protocol}://{host}:{port}'}
-        if username and password:
-            proxy_config['username'] = username
-            proxy_config['password'] = password
-        return proxy_config
-    return None
+
+class ResidentTabInfo:
+    """常驻标签页信息结构"""
+    def __init__(self, tab, project_id: str):
+        self.tab = tab
+        self.project_id = project_id
+        self.recaptcha_ready = False
+        self.created_at = time.time()
+
 
 class BrowserCaptchaService:
-    """浏览器自动化获取 reCAPTCHA token（持久化有头模式）"""
+    """浏览器自动化获取 reCAPTCHA token（nodriver 有头模式）
+    
+    支持两种模式：
+    1. 常驻模式 (Resident Mode): 为每个 project_id 保持常驻标签页，即时生成 token
+    2. 传统模式 (Legacy Mode): 每次请求创建新标签页 (fallback)
+    """
 
     _instance: Optional['BrowserCaptchaService'] = None
     _lock = asyncio.Lock()
 
     def __init__(self, db=None):
         """初始化服务"""
-        # === 修改点 1: 设置为有头模式 ===
-        self.headless = False 
-        self.playwright = None
-        # 注意: 持久化模式下，我们操作的是 context 而不是 browser
-        self.context: Optional[BrowserContext] = None 
+        self.headless = False  # nodriver 有头模式
+        self.browser = None
         self._initialized = False
         self.website_key = "6LdsFiUsAAAAAIjVDZcuLhaHiDn5nnHVXVRQGeMV"
         self.db = db
-        
-        # === 修改点 2: 指定本地数据存储目录 ===
-        # 这会在脚本运行目录下生成 browser_data 文件夹，用于保存你的登录状态
+        # 持久化 profile 目录
         self.user_data_dir = os.path.join(os.getcwd(), "browser_data")
+        
+        # 常驻模式相关属性 (支持多 project_id)
+        self._resident_tabs: dict[str, 'ResidentTabInfo'] = {}  # project_id -> 常驻标签页信息
+        self._resident_lock = asyncio.Lock()  # 保护常驻标签页操作
+        
+        # 兼容旧 API（保留 single resident 属性作为别名）
+        self.resident_project_id: Optional[str] = None  # 向后兼容
+        self.resident_tab = None                         # 向后兼容
+        self._running = False                            # 向后兼容
+        self._recaptcha_ready = False                    # 向后兼容
 
     @classmethod
     async def get_instance(cls, db=None) -> 'BrowserCaptchaService':
+        """获取单例实例"""
         if cls._instance is None:
             async with cls._lock:
                 if cls._instance is None:
                     cls._instance = cls(db)
-                    # 首次调用不强制初始化，等待 get_token 时懒加载，或者可以在这里await
         return cls._instance
 
     async def initialize(self):
-        """初始化持久化浏览器上下文"""
-        if self._initialized and self.context:
-            return
+        """初始化 nodriver 浏览器"""
+        if self._initialized and self.browser:
+            # 检查浏览器是否仍然存活
+            try:
+                # 尝试获取浏览器信息验证存活
+                if self.browser.stopped:
+                    debug_logger.log_warning("[BrowserCaptcha] 浏览器已停止，重新初始化...")
+                    self._initialized = False
+                else:
+                    return
+            except Exception:
+                debug_logger.log_warning("[BrowserCaptcha] 浏览器无响应，重新初始化...")
+                self._initialized = False
 
         try:
-            proxy_url = None
-            if self.db:
-                captcha_config = await self.db.get_captcha_config()
-                if captcha_config.browser_proxy_enabled and captcha_config.browser_proxy_url:
-                    proxy_url = captcha_config.browser_proxy_url
-
-            debug_logger.log_info(f"[BrowserCaptcha] 正在启动浏览器 (用户数据目录: {self.user_data_dir})...")
-            self.playwright = await async_playwright().start()
-
-            # 配置��动参数
-            launch_options = {
-                'headless': self.headless,
-                'user_data_dir': self.user_data_dir, # 指定数据目录
-                'viewport': {'width': 1280, 'height': 720}, # 设置默认窗口大小
-                'args': [
-                    '--disable-blink-features=AutomationControlled',
-                    '--disable-infobars',
+            debug_logger.log_info(f"[BrowserCaptcha] 正在启动 nodriver 浏览器 (用户数据目录: {self.user_data_dir})...")
+
+            # 确保 user_data_dir 存在
+            os.makedirs(self.user_data_dir, exist_ok=True)
+
+            # 启动 nodriver 浏览器
+            self.browser = await uc.start(
+                headless=self.headless,
+                user_data_dir=self.user_data_dir,
+                sandbox=False,  # nodriver 需要此参数来禁用 sandbox
+                browser_args=[
                     '--no-sandbox',
+                    '--disable-dev-shm-usage',
                     '--disable-setuid-sandbox',
+                    '--disable-gpu',
+                    '--window-size=1280,720',
+                    '--profile-directory=Default',  # 跳过 Profile 选择器页面
                 ]
-            }
-
-            # 代理配置
-            if proxy_url:
-                proxy_config = parse_proxy_url(proxy_url)
-                if proxy_config:
-                    launch_options['proxy'] = proxy_config
-                    debug_logger.log_info(f"[BrowserCaptcha] 使用代理: {proxy_config['server']}")
-
-            # === 修改点 3: 使用 launch_persistent_context ===
-            # 这会启动一个带有状态的浏览器窗口
-            self.context = await self.playwright.chromium.launch_persistent_context(**launch_options)
-            
-            # 设置默认超时
-            self.context.set_default_timeout(30000)
+            )
 
             self._initialized = True
-            debug_logger.log_info(f"[BrowserCaptcha] ✅ 浏览器已启动 (Profile: {self.user_data_dir})")
-            
+            debug_logger.log_info(f"[BrowserCaptcha] ✅ nodriver 浏览器已启动 (Profile: {self.user_data_dir})")
+
         except Exception as e:
             debug_logger.log_error(f"[BrowserCaptcha] ❌ 浏览器启动失败: {str(e)}")
             raise
 
+    # ========== 常驻模式 API ==========
+
+    async def start_resident_mode(self, project_id: str):
+        """启动常驻模式
+        
+        Args:
+            project_id: 用于常驻的项目 ID
+        """
+        if self._running:
+            debug_logger.log_warning("[BrowserCaptcha] 常驻模式已在运行")
+            return
+        
+        await self.initialize()
+        
+        self.resident_project_id = project_id
+        website_url = f"https://labs.google/fx/tools/flow/project/{project_id}"
+        
+        debug_logger.log_info(f"[BrowserCaptcha] 启动常驻模式，访问页面: {website_url}")
+        
+        # 创建一个独立的新标签页（不使用 main_tab，避免被回收）
+        self.resident_tab = await self.browser.get(website_url, new_tab=True)
+        
+        debug_logger.log_info("[BrowserCaptcha] 标签页已创建，等待页面加载...")
+        
+        # 等待页面加载完成（带重试机制）
+        page_loaded = False
+        for retry in range(60):
+            try:
+                await asyncio.sleep(1)
+                ready_state = await self.resident_tab.evaluate("document.readyState")
+                debug_logger.log_info(f"[BrowserCaptcha] 页面状态: {ready_state} (重试 {retry + 1}/60)")
+                if ready_state == "complete":
+                    page_loaded = True
+                    break
+            except ConnectionRefusedError as e:
+                debug_logger.log_warning(f"[BrowserCaptcha] 标签页连接丢失: {e}，尝试重新获取...")
+                # 标签页可能已关闭，尝试重新创建
+                try:
+                    self.resident_tab = await self.browser.get(website_url, new_tab=True)
+                    debug_logger.log_info("[BrowserCaptcha] 已重新创建标签页")
+                except Exception as e2:
+                    debug_logger.log_error(f"[BrowserCaptcha] 重新创建标签页失败: {e2}")
+                await asyncio.sleep(2)
+            except Exception as e:
+                debug_logger.log_warning(f"[BrowserCaptcha] 等待页面异常: {e}，重试 {retry + 1}/15...")
+                await asyncio.sleep(2)
+        
+        if not page_loaded:
+            debug_logger.log_error("[BrowserCaptcha] 页面加载超时，常驻模式启动失败")
+            return
+        
+        # 等待 reCAPTCHA 加载
+        self._recaptcha_ready = await self._wait_for_recaptcha(self.resident_tab)
+        
+        if not self._recaptcha_ready:
+            debug_logger.log_error("[BrowserCaptcha] reCAPTCHA 加载失败，常驻模式启动失败")
+            return
+        
+        self._running = True
+        debug_logger.log_info(f"[BrowserCaptcha] ✅ 常驻模式已启动 (project: {project_id})")
+
+    async def stop_resident_mode(self, project_id: Optional[str] = None):
+        """停止常驻模式
+        
+        Args:
+            project_id: 指定要关闭的 project_id，如果为 None 则关闭所有常驻标签页
+        """
+        async with self._resident_lock:
+            if project_id:
+                # 关闭指定的常驻标签页
+                await self._close_resident_tab(project_id)
+                debug_logger.log_info(f"[BrowserCaptcha] 已关闭 project_id={project_id} 的常驻模式")
+            else:
+                # 关闭所有常驻标签页
+                project_ids = list(self._resident_tabs.keys())
+                for pid in project_ids:
+                    resident_info = self._resident_tabs.pop(pid, None)
+                    if resident_info and resident_info.tab:
+                        try:
+                            await resident_info.tab.close()
+                        except Exception:
+                            pass
+                debug_logger.log_info(f"[BrowserCaptcha] 已关闭所有常驻标签页 (共 {len(project_ids)} 个)")
+        
+        # 向后兼容：清理旧属性
+        if not self._running:
+            return
+        
+        self._running = False
+        if self.resident_tab:
+            try:
+                await self.resident_tab.close()
+            except Exception:
+                pass
+            self.resident_tab = None
+        
+        self.resident_project_id = None
+        self._recaptcha_ready = False
+
+    async def _wait_for_recaptcha(self, tab) -> bool:
+        """等待 reCAPTCHA 加载
+        
+        Returns:
+            True if reCAPTCHA loaded successfully
+        """
+        debug_logger.log_info("[BrowserCaptcha] 检测 reCAPTCHA...")
+        
+        # 检查 grecaptcha.enterprise.execute
+        is_enterprise = await tab.evaluate(
+            "typeof grecaptcha !== 'undefined' && typeof grecaptcha.enterprise !== 'undefined' && typeof grecaptcha.enterprise.execute === 'function'"
+        )
+        
+        if is_enterprise:
+            debug_logger.log_info("[BrowserCaptcha] reCAPTCHA Enterprise 已加载")
+            return True
+        
+        # 尝试注入脚本
+        debug_logger.log_info("[BrowserCaptcha] 未检测到 reCAPTCHA，注入脚本...")
+        
+        await tab.evaluate(f"""
+            (() => {{
+                if (document.querySelector('script[src*="recaptcha"]')) return;
+                const script = document.createElement('script');
+                script.src = 'https://www.google.com/recaptcha/api.js?render={self.website_key}';
+                script.async = true;
+                document.head.appendChild(script);
+            }})()
+        """)
+        
+        # 等待脚本加载
+        await tab.sleep(3)
+        
+        # 轮询等待 reCAPTCHA 加载
+        for i in range(20):
+            is_enterprise = await tab.evaluate(
+                "typeof grecaptcha !== 'undefined' && typeof grecaptcha.enterprise !== 'undefined' && typeof grecaptcha.enterprise.execute === 'function'"
+            )
+            
+            if is_enterprise:
+                debug_logger.log_info(f"[BrowserCaptcha] reCAPTCHA Enterprise 已加载（等待了 {i * 0.5} 秒）")
+                return True
+            await tab.sleep(0.5)
+        
+        debug_logger.log_warning("[BrowserCaptcha] reCAPTCHA 加载超时")
+        return False
+
+    async def _execute_recaptcha_on_tab(self, tab) -> Optional[str]:
+        """在指定标签页执行 reCAPTCHA 获取 token
+        
+        Args:
+            tab: nodriver 标签页对象
+            
+        Returns:
+            reCAPTCHA token 或 None
+        """
+        # 生成唯一变量名避免冲突
+        ts = int(time.time() * 1000)
+        token_var = f"_recaptcha_token_{ts}"
+        error_var = f"_recaptcha_error_{ts}"
+        
+        execute_script = f"""
+            (() => {{
+                window.{token_var} = null;
+                window.{error_var} = null;
+                
+                try {{
+                    grecaptcha.enterprise.ready(function() {{
+                        grecaptcha.enterprise.execute('{self.website_key}', {{action: 'FLOW_GENERATION'}})
+                            .then(function(token) {{
+                                window.{token_var} = token;
+                            }})
+                            .catch(function(err) {{
+                                window.{error_var} = err.message || 'execute failed';
+                            }});
+                    }});
+                }} catch (e) {{
+                    window.{error_var} = e.message || 'exception';
+                }}
+            }})()
+        """
+        
+        # 注入执行脚本
+        await tab.evaluate(execute_script)
+        
+        # 轮询等待结果（最多 15 秒）
+        token = None
+        for i in range(30):
+            await tab.sleep(0.5)
+            token = await tab.evaluate(f"window.{token_var}")
+            if token:
+                break
+            error = await tab.evaluate(f"window.{error_var}")
+            if error:
+                debug_logger.log_error(f"[BrowserCaptcha] reCAPTCHA 错误: {error}")
+                break
+        
+        # 清理临时变量
+        try:
+            await tab.evaluate(f"delete window.{token_var}; delete window.{error_var};")
+        except:
+            pass
+        
+        return token
+
+    # ========== 主要 API ==========
+
     async def get_token(self, project_id: str) -> Optional[str]:
-        """获取 reCAPTCHA token"""
+        """获取 reCAPTCHA token
+        
+        自动常驻模式：如果该 project_id 没有常驻标签页，则自动创建并常驻
+        
+        Args:
+            project_id: Flow项目ID
+
+        Returns:
+            reCAPTCHA token字符串，如果获取失败返回None
+        """
+        # 确保浏览器已初始化
+        await self.initialize()
+        
+        # 尝试从常驻标签页获取 token
+        async with self._resident_lock:
+            resident_info = self._resident_tabs.get(project_id)
+            
+            # 如果该 project_id 没有常驻标签页，则自动创建
+            if resident_info is None:
+                debug_logger.log_info(f"[BrowserCaptcha] project_id={project_id} 没有常驻标签页，正在创建...")
+                resident_info = await self._create_resident_tab(project_id)
+                if resident_info is None:
+                    debug_logger.log_warning(f"[BrowserCaptcha] 无法为 project_id={project_id} 创建常驻标签页，fallback 到传统模式")
+                    return await self._get_token_legacy(project_id)
+                self._resident_tabs[project_id] = resident_info
+                debug_logger.log_info(f"[BrowserCaptcha] ✅ 已为 project_id={project_id} 创建常驻标签页 (当前共 {len(self._resident_tabs)} 个)")
+        
+        # 使用常驻标签页生成 token
+        if resident_info and resident_info.recaptcha_ready and resident_info.tab:
+            start_time = time.time()
+            debug_logger.log_info(f"[BrowserCaptcha] 从常驻标签页即时生成 token (project: {project_id})...")
+            try:
+                token = await self._execute_recaptcha_on_tab(resident_info.tab)
+                duration_ms = (time.time() - start_time) * 1000
+                if token:
+                    debug_logger.log_info(f"[BrowserCaptcha] ✅ Token生成成功（耗时 {duration_ms:.0f}ms）")
+                    return token
+                else:
+                    debug_logger.log_warning(f"[BrowserCaptcha] 常驻标签页生成失败 (project: {project_id})，尝试重建...")
+            except Exception as e:
+                debug_logger.log_warning(f"[BrowserCaptcha] 常驻标签页异常: {e}，尝试重建...")
+            
+            # 常驻标签页失效，尝试重建
+            async with self._resident_lock:
+                await self._close_resident_tab(project_id)
+                resident_info = await self._create_resident_tab(project_id)
+                if resident_info:
+                    self._resident_tabs[project_id] = resident_info
+                    # 重建后立即尝试生成
+                    try:
+                        token = await self._execute_recaptcha_on_tab(resident_info.tab)
+                        if token:
+                            debug_logger.log_info(f"[BrowserCaptcha] ✅ 重建后 Token生成成功")
+                            return token
+                    except Exception:
+                        pass
+        
+        # 最终 Fallback: 使用传统模式
+        debug_logger.log_warning(f"[BrowserCaptcha] 所有常驻方式失败，fallback 到传统模式 (project: {project_id})")
+        return await self._get_token_legacy(project_id)
+
+    async def _create_resident_tab(self, project_id: str) -> Optional[ResidentTabInfo]:
+        """为指定 project_id 创建常驻标签页
+        
+        Args:
+            project_id: 项目 ID
+            
+        Returns:
+            ResidentTabInfo 对象，或 None（创建失败）
+        """
+        try:
+            website_url = f"https://labs.google/fx/tools/flow/project/{project_id}"
+            debug_logger.log_info(f"[BrowserCaptcha] 为 project_id={project_id} 创建常驻标签页，访问: {website_url}")
+            
+            # 创建新标签页
+            tab = await self.browser.get(website_url, new_tab=True)
+            
+            # 等待页面加载完成
+            page_loaded = False
+            for retry in range(60):
+                try:
+                    await asyncio.sleep(1)
+                    ready_state = await tab.evaluate("document.readyState")
+                    if ready_state == "complete":
+                        page_loaded = True
+                        break
+                except ConnectionRefusedError as e:
+                    debug_logger.log_warning(f"[BrowserCaptcha] 标签页连接丢失: {e}")
+                    return None
+                except Exception as e:
+                    debug_logger.log_warning(f"[BrowserCaptcha] 等待页面异常: {e}，重试 {retry + 1}/60...")
+                    await asyncio.sleep(1)
+            
+            if not page_loaded:
+                debug_logger.log_error(f"[BrowserCaptcha] 页面加载超时 (project: {project_id})")
+                try:
+                    await tab.close()
+                except:
+                    pass
+                return None
+            
+            # 等待 reCAPTCHA 加载
+            recaptcha_ready = await self._wait_for_recaptcha(tab)
+            
+            if not recaptcha_ready:
+                debug_logger.log_error(f"[BrowserCaptcha] reCAPTCHA 加载失败 (project: {project_id})")
+                try:
+                    await tab.close()
+                except:
+                    pass
+                return None
+            
+            # 创建常驻信息对象
+            resident_info = ResidentTabInfo(tab, project_id)
+            resident_info.recaptcha_ready = True
+            
+            debug_logger.log_info(f"[BrowserCaptcha] ✅ 常驻标签页创建成功 (project: {project_id})")
+            return resident_info
+            
+        except Exception as e:
+            debug_logger.log_error(f"[BrowserCaptcha] 创建常驻标签页异常: {e}")
+            return None
+
+    async def _close_resident_tab(self, project_id: str):
+        """关闭指定 project_id 的常驻标签页
+        
+        Args:
+            project_id: 项目 ID
+        """
+        resident_info = self._resident_tabs.pop(project_id, None)
+        if resident_info and resident_info.tab:
+            try:
+                await resident_info.tab.close()
+                debug_logger.log_info(f"[BrowserCaptcha] 已关闭 project_id={project_id} 的常驻标签页")
+            except Exception as e:
+                debug_logger.log_warning(f"[BrowserCaptcha] 关闭标签页时异常: {e}")
+
+    async def _get_token_legacy(self, project_id: str) -> Optional[str]:
+        """传统模式获取 reCAPTCHA token（每次创建新标签页）
+
+        Args:
+            project_id: Flow项目ID
+
+        Returns:
+            reCAPTCHA token字符串，如果获取失败返回None
+        """
         # 确保浏览器已启动
-        if not self._initialized or not self.context:
+        if not self._initialized or not self.browser:
             await self.initialize()
 
         start_time = time.time()
-        page: Optional[Page] = None
+        tab = None
 
         try:
-            # === 修改点 4: 在现有上下文中新建标签页，而不是新建上下文 ===
-            # 这样可以复用该上下文中已保存的 Cookie (你的登录状态)
-            page = await self.context.new_page()
-
             website_url = f"https://labs.google/fx/tools/flow/project/{project_id}"
-            debug_logger.log_info(f"[BrowserCaptcha] 访问页面: {website_url}")
+            debug_logger.log_info(f"[BrowserCaptcha] [Legacy] 访问页面: {website_url}")
 
-            # 访问页面
-            try:
-                await page.goto(website_url, wait_until="domcontentloaded")
-            except Exception as e:
-                debug_logger.log_warning(f"[BrowserCaptcha] 页面加载警告: {str(e)}")
-
-            # --- 关键点：如果需要人工介入 ---
-            # 你可以在这里加入一段逻辑，如果是第一次运行，或者检测到未登录，
-            # 可以暂停脚本，等你手动操作完再继续。
-            # 例如: await asyncio.sleep(30) 
-            
-            # ... (中间注入脚本和执行 reCAPTCHA 的代码逻辑与原版完全一致，此处省略以节省篇幅) ...
-            # ... 请将原代码中从 "检查并注入 reCAPTCHA v3 脚本" 到 token 获取部分的代码复制到这里 ...
-            
-            # 这里为了演示，简写注入逻辑（请保留你原有的完整注入逻辑）:
-            script_loaded = await page.evaluate("() => { return !!(window.grecaptcha && window.grecaptcha.execute); }")
-            if not script_loaded:
-                await page.evaluate(f"""
-                    () => {{
-                        const script = document.createElement('script');
-                        script.src = 'https://www.google.com/recaptcha/api.js?render={self.website_key}';
-                        script.async = true; script.defer = true;
-                        document.head.appendChild(script);
-                    }}
-                """)
-                # 等待加载... (保留你原有的等待循环)
-                await page.wait_for_timeout(2000) 
-
-            # 执行获取 Token (保留你原有的 execute 逻辑)
-            token = await page.evaluate(f"""
-                async () => {{
-                    try {{
-                        return await window.grecaptcha.execute('{self.website_key}', {{ action: 'FLOW_GENERATION' }});
-                    }} catch (e) {{ return null; }}
-                }}
-            """)
+            # 新建标签页并访问页面
+            tab = await self.browser.get(website_url)
+
+            # 等待页面完全加载（增加等待时间）
+            debug_logger.log_info("[BrowserCaptcha] [Legacy] 等待页面加载...")
+            await tab.sleep(3)
             
+            # 等待页面 DOM 完成
+            for _ in range(10):
+                ready_state = await tab.evaluate("document.readyState")
+                if ready_state == "complete":
+                    break
+                await tab.sleep(0.5)
+
+            # 等待 reCAPTCHA 加载
+            recaptcha_ready = await self._wait_for_recaptcha(tab)
+
+            if not recaptcha_ready:
+                debug_logger.log_error("[BrowserCaptcha] [Legacy] reCAPTCHA 无法加载")
+                return None
+
+            # 执行 reCAPTCHA
+            debug_logger.log_info("[BrowserCaptcha] [Legacy] 执行 reCAPTCHA 验证...")
+            token = await self._execute_recaptcha_on_tab(tab)
+
+            duration_ms = (time.time() - start_time) * 1000
+
             if token:
-                debug_logger.log_info(f"[BrowserCaptcha] ✅ Token获取成功")
+                debug_logger.log_info(f"[BrowserCaptcha] [Legacy] ✅ Token获取成功（耗时 {duration_ms:.0f}ms）")
                 return token
             else:
-                debug_logger.log_error("[BrowserCaptcha] Token获取失败")
+                debug_logger.log_error("[BrowserCaptcha] [Legacy] Token获取失败（返回null）")
                 return None
 
         except Exception as e:
-            debug_logger.log_error(f"[BrowserCaptcha] 异常: {str(e)}")
+            debug_logger.log_error(f"[BrowserCaptcha] [Legacy] 获取token异常: {str(e)}")
             return None
         finally:
-            # === 修改点 5: 只关闭 Page (标签页)，不关闭 Context (浏览器窗口) ===
-            if page:
+            # 关闭标签页（但保留浏览器）
+            if tab:
                 try:
-                    await page.close()
-                except:
+                    await tab.close()
+                except Exception:
                     pass
 
     async def close(self):
-        """完全关闭浏览器（清理资源时调用）"""
+        """关闭浏览器"""
+        # 先停止所有常驻模式（关闭所有常驻标签页）
+        await self.stop_resident_mode()
+        
         try:
-            if self.context:
-                await self.context.close() # 这会关闭整个浏览器窗口
-                self.context = None
-            
-            if self.playwright:
-                await self.playwright.stop()
-                self.playwright = None
-                
+            if self.browser:
+                try:
+                    self.browser.stop()
+                except Exception as e:
+                    debug_logger.log_warning(f"[BrowserCaptcha] 关闭浏览器时出现异常: {str(e)}")
+                finally:
+                    self.browser = None
+
             self._initialized = False
-            debug_logger.log_info("[BrowserCaptcha] 浏览器服务已关闭")
+            self._resident_tabs.clear()  # 确保清空常驻字典
+            debug_logger.log_info("[BrowserCaptcha] 浏览器已关闭")
         except Exception as e:
-            debug_logger.log_error(f"[BrowserCaptcha] 关闭异常: {str(e)}")
+            debug_logger.log_error(f"[BrowserCaptcha] 关闭浏览器异常: {str(e)}")
 
-    # 增加一个辅助方法，用于手动登录
     async def open_login_window(self):
-        """调用此方法打开一个永久窗口供你登录Google"""
+        """打开登录窗口供用户手动登录 Google"""
         await self.initialize()
-        page = await self.context.new_page()
-        await page.goto("https://accounts.google.com/")
-        print("请在打开的浏览器中登录账号。登录完成后，无需关闭浏览器，脚本下次运行时会自动使用此状态。")
+        tab = await self.browser.get("https://accounts.google.com/")
+        debug_logger.log_info("[BrowserCaptcha] 请在打开的浏览器中登录账号。登录完成后，无需关闭浏览器，脚本下次运行时会自动使用此状态。")
+        print("请在打开的浏览器中登录账号。登录完成后，无需关闭浏览器，脚本下次运行时会自动使用此状态。")
+
+    # ========== Session Token 刷新 ==========
+
+    async def refresh_session_token(self, project_id: str) -> Optional[str]:
+        """从常驻标签页获取最新的 Session Token
+        
+        复用 reCAPTCHA 常驻标签页，通过刷新页面并从 cookies 中提取
+        __Secure-next-auth.session-token
+        
+        Args:
+            project_id: 项目ID，用于定位常驻标签页
+            
+        Returns:
+            新的 Session Token，如果获取失败返回 None
+        """
+        # 确保浏览器已初始化
+        await self.initialize()
+        
+        start_time = time.time()
+        debug_logger.log_info(f"[BrowserCaptcha] 开始刷新 Session Token (project: {project_id})...")
+        
+        # 尝试获取或创建常驻标签页
+        async with self._resident_lock:
+            resident_info = self._resident_tabs.get(project_id)
+            
+            # 如果该 project_id 没有常驻标签页，则创建
+            if resident_info is None:
+                debug_logger.log_info(f"[BrowserCaptcha] project_id={project_id} 没有常驻标签页，正在创建...")
+                resident_info = await self._create_resident_tab(project_id)
+                if resident_info is None:
+                    debug_logger.log_warning(f"[BrowserCaptcha] 无法为 project_id={project_id} 创建常驻标签页")
+                    return None
+                self._resident_tabs[project_id] = resident_info
+        
+        if not resident_info or not resident_info.tab:
+            debug_logger.log_error(f"[BrowserCaptcha] 无法获取常驻标签页")
+            return None
+        
+        tab = resident_info.tab
+        
+        try:
+            # 刷新页面以获取最新的 cookies
+            debug_logger.log_info(f"[BrowserCaptcha] 刷新常驻标签页以获取最新 cookies...")
+            await tab.reload()
+            
+            # 等待页面加载完成
+            for i in range(30):
+                await asyncio.sleep(1)
+                try:
+                    ready_state = await tab.evaluate("document.readyState")
+                    if ready_state == "complete":
+                        break
+                except Exception:
+                    pass
+            
+            # 额外等待确保 cookies 已设置
+            await asyncio.sleep(2)
+            
+            # 从 cookies 中提取 __Secure-next-auth.session-token
+            # nodriver 可以通过 browser 获取 cookies
+            session_token = None
+            
+            try:
+                # 使用 nodriver 的 cookies API 获取所有 cookies
+                cookies = await self.browser.cookies.get_all()
+                
+                for cookie in cookies:
+                    if cookie.name == "__Secure-next-auth.session-token":
+                        session_token = cookie.value
+                        break
+                        
+            except Exception as e:
+                debug_logger.log_warning(f"[BrowserCaptcha] 通过 cookies API 获取失败: {e}，尝试从 document.cookie 获取...")
+                
+                # 备选方案：通过 JavaScript 获取 (注意：HttpOnly cookies 可能无法通过此方式获取)
+                try:
+                    all_cookies = await tab.evaluate("document.cookie")
+                    if all_cookies:
+                        for part in all_cookies.split(";"):
+                            part = part.strip()
+                            if part.startswith("__Secure-next-auth.session-token="):
+                                session_token = part.split("=", 1)[1]
+                                break
+                except Exception as e2:
+                    debug_logger.log_error(f"[BrowserCaptcha] document.cookie 获取失败: {e2}")
+            
+            duration_ms = (time.time() - start_time) * 1000
+            
+            if session_token:
+                debug_logger.log_info(f"[BrowserCaptcha] ✅ Session Token 获取成功（耗时 {duration_ms:.0f}ms）")
+                return session_token
+            else:
+                debug_logger.log_error(f"[BrowserCaptcha] ❌ 未找到 __Secure-next-auth.session-token cookie")
+                return None
+                
+        except Exception as e:
+            debug_logger.log_error(f"[BrowserCaptcha] 刷新 Session Token 异常: {str(e)}")
+            
+            # 常驻标签页可能已失效，尝试重建
+            async with self._resident_lock:
+                await self._close_resident_tab(project_id)
+                resident_info = await self._create_resident_tab(project_id)
+                if resident_info:
+                    self._resident_tabs[project_id] = resident_info
+                    # 重建后再次尝试获取
+                    try:
+                        cookies = await self.browser.cookies.get_all()
+                        for cookie in cookies:
+                            if cookie.name == "__Secure-next-auth.session-token":
+                                debug_logger.log_info(f"[BrowserCaptcha] ✅ 重建后 Session Token 获取成功")
+                                return cookie.value
+                    except Exception:
+                        pass
+            
+            return None
+
+    # ========== 状态查询 ==========
+
+    def is_resident_mode_active(self) -> bool:
+        """检查是否有任何常驻标签页激活"""
+        return len(self._resident_tabs) > 0 or self._running
+
+    def get_resident_count(self) -> int:
+        """获取当前常驻标签页数量"""
+        return len(self._resident_tabs)
+
+    def get_resident_project_ids(self) -> list[str]:
+        """获取所有当前常驻的 project_id 列表"""
+        return list(self._resident_tabs.keys())
+
+    def get_resident_project_id(self) -> Optional[str]:
+        """获取当前常驻的 project_id（向后兼容，返回第一个）"""
+        if self._resident_tabs:
+            return next(iter(self._resident_tabs.keys()))
+        return self.resident_project_id

src/services/flow_client.py

@@ -12,11 +12,86 @@ from ..core.config import config
 class FlowClient:
     """VideoFX API客户端"""
 
-    def __init__(self, proxy_manager):
+    def __init__(self, proxy_manager, db=None):
         self.proxy_manager = proxy_manager
+        self.db = db  # Database instance for captcha config
         self.labs_base_url = config.flow_labs_base_url  # https://labs.google/fx/api
         self.api_base_url = config.flow_api_base_url    # https://aisandbox-pa.googleapis.com/v1
         self.timeout = config.flow_timeout
+        # 缓存每个账号的 User-Agent
+        self._user_agent_cache = {}
+
+    def _generate_user_agent(self, account_id: str = None) -> str:
+        """基于账号ID生成固定的 User-Agent
+        
+        Args:
+            account_id: 账号标识（如 email 或 token_id），相同账号返回相同 UA
+            
+        Returns:
+            User-Agent 字符串
+        """
+        # 如果没有提供账号ID，生成随机UA
+        if not account_id:
+            account_id = f"random_{random.randint(1, 999999)}"
+        
+        # 如果已缓存，直接返回
+        if account_id in self._user_agent_cache:
+            return self._user_agent_cache[account_id]
+        
+        # 使用账号ID作为随机种子，确保同一账号生成相同的UA
+        import hashlib
+        seed = int(hashlib.md5(account_id.encode()).hexdigest()[:8], 16)
+        rng = random.Random(seed)
+        
+        # Chrome 版本池
+        chrome_versions = ["130.0.0.0", "131.0.0.0", "132.0.0.0", "129.0.0.0"]
+        # Firefox 版本池
+        firefox_versions = ["133.0", "132.0", "131.0", "134.0"]
+        # Safari 版本池
+        safari_versions = ["18.2", "18.1", "18.0", "17.6"]
+        # Edge 版本池
+        edge_versions = ["130.0.0.0", "131.0.0.0", "132.0.0.0"]
+
+        # 操作系统配置
+        os_configs = [
+            # Windows
+            {
+                "platform": "Windows NT 10.0; Win64; x64",
+                "browsers": [
+                    lambda r: f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{r.choice(chrome_versions)} Safari/537.36",
+                    lambda r: f"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:{r.choice(firefox_versions).split('.')[0]}.0) Gecko/20100101 Firefox/{r.choice(firefox_versions)}",
+                    lambda r: f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{r.choice(chrome_versions)} Safari/537.36 Edg/{r.choice(edge_versions)}",
+                ]
+            },
+            # macOS
+            {
+                "platform": "Macintosh; Intel Mac OS X 10_15_7",
+                "browsers": [
+                    lambda r: f"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{r.choice(chrome_versions)} Safari/537.36",
+                    lambda r: f"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/{r.choice(safari_versions)} Safari/605.1.15",
+                    lambda r: f"Mozilla/5.0 (Macintosh; Intel Mac OS X 14.{r.randint(0, 7)}; rv:{r.choice(firefox_versions).split('.')[0]}.0) Gecko/20100101 Firefox/{r.choice(firefox_versions)}",
+                ]
+            },
+            # Linux
+            {
+                "platform": "X11; Linux x86_64",
+                "browsers": [
+                    lambda r: f"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{r.choice(chrome_versions)} Safari/537.36",
+                    lambda r: f"Mozilla/5.0 (X11; Linux x86_64; rv:{r.choice(firefox_versions).split('.')[0]}.0) Gecko/20100101 Firefox/{r.choice(firefox_versions)}",
+                    lambda r: f"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:{r.choice(firefox_versions).split('.')[0]}.0) Gecko/20100101 Firefox/{r.choice(firefox_versions)}",
+                ]
+            }
+        ]
+
+        # 使用固定种子随机选择操作系统和浏览器
+        os_config = rng.choice(os_configs)
+        browser_generator = rng.choice(os_config["browsers"])
+        user_agent = browser_generator(rng)
+        
+        # 缓存结果
+        self._user_agent_cache[account_id] = user_agent
+        
+        return user_agent
 
     async def _make_request(
         self,
@@ -54,10 +129,17 @@ class FlowClient:
         if use_at and at_token:
             headers["authorization"] = f"Bearer {at_token}"
 
-        # 通用请求头
+        # 确定账号标识（优先使用 token 的前16个字符作为标识）
+        account_id = None
+        if st_token:
+            account_id = st_token[:16]  # 使用 ST 的前16个字符
+        elif at_token:
+            account_id = at_token[:16]  # 使用 AT 的前16个字符
+
+        # 通用请求头 - 基于账号生成固定的 User-Agent
         headers.update({
             "Content-Type": "application/json",
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+            "User-Agent": self._generate_user_agent(account_id)
         })
 
         # Log request
@@ -571,7 +653,7 @@ class FlowClient:
         Returns:
             同 generate_video_text
         """
-        url = f"{self.api_base_url}/video:batchAsyncGenerateVideoStartAndEndImage"
+        url = f"{self.api_base_url}/video:batchAsyncGenerateVideoStartImage"
 
         # 获取 reCAPTCHA token
         recaptcha_token = await self._get_recaptcha_token(project_id) or ""
@@ -691,7 +773,7 @@ class FlowClient:
         if captcha_method == "personal":
             try:
                 from .browser_captcha_personal import BrowserCaptchaService
-                service = await BrowserCaptchaService.get_instance(self.proxy_manager)
+                service = await BrowserCaptchaService.get_instance(self.db)
                 return await service.get_token(project_id)
             except Exception as e:
                 debug_logger.log_error(f"[reCAPTCHA Browser] error: {str(e)}")
@@ -700,7 +782,7 @@ class FlowClient:
         elif captcha_method == "browser":
             try:
                 from .browser_captcha import BrowserCaptchaService
-                service = await BrowserCaptchaService.get_instance(self.proxy_manager)
+                service = await BrowserCaptchaService.get_instance(self.db)
                 return await service.get_token(project_id)
             except Exception as e:
                 debug_logger.log_error(f"[reCAPTCHA Browser] error: {str(e)}")

src/services/generation_handler.py

@@ -136,7 +136,7 @@ MODEL_CONFIG = {
     "veo_3_1_i2v_s_fast_fl_portrait": {
         "type": "video",
         "video_type": "i2v",
-        "model_key": "veo_3_1_i2v_s_fast_fl",
+        "model_key": "veo_3_1_i2v_s_fast_portrait_fl_ultra_relaxed",
         "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
         "supports_images": True,
         "min_images": 1,
@@ -145,7 +145,7 @@ MODEL_CONFIG = {
     "veo_3_1_i2v_s_fast_fl_landscape": {
         "type": "video",
         "video_type": "i2v",
-        "model_key": "veo_3_1_i2v_s_fast_fl",
+        "model_key": "veo_3_1_i2v_s_fast_fl_ultra_relaxed",
         "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
         "supports_images": True,
         "min_images": 1,
@@ -259,7 +259,7 @@ MODEL_CONFIG = {
     "veo_3_0_r2v_fast_portrait": {
         "type": "video",
         "video_type": "r2v",
-        "model_key": "veo_3_0_r2v_fast",
+        "model_key": "veo_3_0_r2v_fast_portrait_ultra_relaxed",
         "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
         "supports_images": True,
         "min_images": 0,
@@ -268,7 +268,7 @@ MODEL_CONFIG = {
     "veo_3_0_r2v_fast_landscape": {
         "type": "video",
         "video_type": "r2v",
-        "model_key": "veo_3_0_r2v_fast",
+        "model_key": "veo_3_0_r2v_fast_ultra_relaxed",
         "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
         "supports_images": True,
         "min_images": 0,
@@ -644,6 +644,44 @@ class GenerationHandler:
             min_images = model_config.get("min_images", 0)
             max_images = model_config.get("max_images", 0)
 
+            # 根据账号tier自动调整模型 key
+            model_key = model_config["model_key"]
+            user_tier = token.user_paygate_tier or "PAYGATE_TIER_ONE"
+
+            # TIER_TWO 账号需要使用 ultra 版本的模型
+            if user_tier == "PAYGATE_TIER_TWO":
+                # 如果模型 key 不包含 ultra，自动添加
+                if "ultra" not in model_key:
+                    # veo_3_1_i2v_s_fast_fl -> veo_3_1_i2v_s_fast_ultra_fl
+                    # veo_3_1_t2v_fast -> veo_3_1_t2v_fast_ultra
+                    # veo_3_0_r2v_fast -> veo_3_0_r2v_fast_ultra
+                    if "_fl" in model_key:
+                        model_key = model_key.replace("_fl", "_ultra_fl")
+                    elif model_key.endswith("_fast"):
+                        model_key = model_key + "_ultra"
+                    elif "_fast_" in model_key:
+                        model_key = model_key.replace("_fast_", "_fast_ultra_")
+                    
+                    if stream:
+                        yield self._create_stream_chunk(f"TIER_TWO 账号自动切换到 ultra 模型: {model_key}\n")
+                    debug_logger.log_info(f"[VIDEO] TIER_TWO 账号，模型自动调整: {model_config['model_key']} -> {model_key}")
+
+            # TIER_ONE 账号需要使用非 ultra 版本
+            elif user_tier == "PAYGATE_TIER_ONE":
+                # 如果模型 key 包含 ultra，需要移除（避免用户误用）
+                if "ultra" in model_key:
+                    # veo_3_1_i2v_s_fast_ultra_fl -> veo_3_1_i2v_s_fast_fl
+                    # veo_3_1_t2v_fast_ultra -> veo_3_1_t2v_fast
+                    model_key = model_key.replace("_ultra_fl", "_fl").replace("_ultra", "")
+                    
+                    if stream:
+                        yield self._create_stream_chunk(f"TIER_ONE 账号自动切换到标准模型: {model_key}\n")
+                    debug_logger.log_info(f"[VIDEO] TIER_ONE 账号，模型自动调整: {model_config['model_key']} -> {model_key}")
+
+            # 更新 model_config 中的 model_key
+            model_config = dict(model_config)  # 创建副本避免修改原配置
+            model_config["model_key"] = model_key
+
             # 图片数量
             image_count = len(images) if images else 0
 
@@ -734,12 +772,16 @@ class GenerationHandler:
                         user_paygate_tier=token.user_paygate_tier or "PAYGATE_TIER_ONE"
                     )
                 else:
-                    # 只有首帧
+                    # 只有首帧 - 需要将 model_key 中的 _fl_ 替换为 _
+                    # 例如: veo_3_1_i2v_s_fast_fl_ultra_relaxed -> veo_3_1_i2v_s_fast_ultra_relaxed
+                    #       veo_3_1_i2v_s_fast_portrait_fl_ultra_relaxed -> veo_3_1_i2v_s_fast_portrait_ultra_relaxed
+                    actual_model_key = model_config["model_key"].replace("_fl_", "_")
+                    debug_logger.log_info(f"[I2V] 单帧模式，model_key: {model_config['model_key']} -> {actual_model_key}")
                     result = await self.flow_client.generate_video_start_image(
                         at=token.at,
                         project_id=project_id,
                         prompt=prompt,
-                        model_key=model_config["model_key"],
+                        model_key=actual_model_key,
                         aspect_ratio=model_config["aspect_ratio"],
                         start_media_id=start_media_id,
                         user_paygate_tier=token.user_paygate_tier or "PAYGATE_TIER_ONE"
@@ -888,8 +930,30 @@ class GenerationHandler:
                         )
                     return
 
+                elif status == "MEDIA_GENERATION_STATUS_FAILED":
+                    # 生成失败 - 提取错误信息
+                    error_info = operation.get("operation", {}).get("error", {})
+                    error_code = error_info.get("code", "unknown")
+                    error_message = error_info.get("message", "未知错误")
+                    
+                    # 更新数据库任务状态
+                    task_id = operation["operation"]["name"]
+                    await self.db.update_task(
+                        task_id,
+                        status="failed",
+                        error_message=f"{error_message} (code: {error_code})",
+                        completed_at=time.time()
+                    )
+                    
+                    # 返回友好的错误消息，提示用户重试
+                    friendly_error = f"视频生成失败: {error_message}，请重试"
+                    if stream:
+                        yield self._create_stream_chunk(f"❌ {friendly_error}\n")
+                    yield self._create_error_response(friendly_error)
+                    return
+
                 elif status.startswith("MEDIA_GENERATION_STATUS_ERROR"):
-                    # 失败
+                    # 其他错误状态
                     yield self._create_error_response(f"视频生成失败: {status}")
                     return
 

src/services/token_manager.py

@@ -268,9 +268,13 @@ class TokenManager:
         # AT有效
         return True
 
+
     async def _refresh_at(self, token_id: int) -> bool:
         """内部方法: 刷新AT
 
+        如果 AT 刷新失败（ST 可能过期），会尝试通过浏览器自动刷新 ST，
+        然后重试 AT 刷新。
+
         Returns:
             True if refresh successful, False otherwise
         """
@@ -279,49 +283,132 @@ class TokenManager:
             if not token:
                 return False
 
-            try:
-                debug_logger.log_info(f"[AT_REFRESH] Token {token_id}: 开始刷新AT...")
-
-                # 使用ST转AT
-                result = await self.flow_client.st_to_at(token.st)
-                new_at = result["access_token"]
-                expires = result.get("expires")
-
-                # 解析过期时间
-                new_at_expires = None
-                if expires:
-                    try:
-                        new_at_expires = datetime.fromisoformat(expires.replace('Z', '+00:00'))
-                    except:
-                        pass
-
-                # 更新数据库
-                await self.db.update_token(
-                    token_id,
-                    at=new_at,
-                    at_expires=new_at_expires
-                )
+            # 第一次尝试刷新 AT
+            result = await self._do_refresh_at(token_id, token.st)
+            if result:
+                return True
 
-                debug_logger.log_info(f"[AT_REFRESH] Token {token_id}: AT刷新成功")
-                debug_logger.log_info(f"  - 新过期时间: {new_at_expires}")
+            # AT 刷新失败，尝试自动更新 ST
+            debug_logger.log_info(f"[AT_REFRESH] Token {token_id}: 第一次 AT 刷新失败，尝试自动更新 ST...")
+            
+            new_st = await self._try_refresh_st(token_id, token)
+            if new_st:
+                # ST 更新成功，重试 AT 刷新
+                debug_logger.log_info(f"[AT_REFRESH] Token {token_id}: ST 已更新，重试 AT 刷新...")
+                result = await self._do_refresh_at(token_id, new_st)
+                if result:
+                    return True
+
+            # 所有刷新尝试都失败，禁用 Token
+            debug_logger.log_error(f"[AT_REFRESH] Token {token_id}: 所有刷新尝试失败，禁用 Token")
+            await self.disable_token(token_id)
+            return False
+
+    async def _do_refresh_at(self, token_id: int, st: str) -> bool:
+        """执行 AT 刷新的核心逻辑
+
+        Args:
+            token_id: Token ID
+            st: Session Token
 
-                # 同时刷新credits
+        Returns:
+            True if refresh successful AND AT is valid, False otherwise
+        """
+        try:
+            debug_logger.log_info(f"[AT_REFRESH] Token {token_id}: 开始刷新AT...")
+
+            # 使用ST转AT
+            result = await self.flow_client.st_to_at(st)
+            new_at = result["access_token"]
+            expires = result.get("expires")
+
+            # 解析过期时间
+            new_at_expires = None
+            if expires:
                 try:
-                    credits_result = await self.flow_client.get_credits(new_at)
-                    await self.db.update_token(
-                        token_id,
-                        credits=credits_result.get("credits", 0)
-                    )
+                    new_at_expires = datetime.fromisoformat(expires.replace('Z', '+00:00'))
                 except:
                     pass
 
+            # 更新数据库
+            await self.db.update_token(
+                token_id,
+                at=new_at,
+                at_expires=new_at_expires
+            )
+
+            debug_logger.log_info(f"[AT_REFRESH] Token {token_id}: AT刷新成功")
+            debug_logger.log_info(f"  - 新过期时间: {new_at_expires}")
+
+            # 验证 AT 有效性：通过 get_credits 测试
+            try:
+                credits_result = await self.flow_client.get_credits(new_at)
+                await self.db.update_token(
+                    token_id,
+                    credits=credits_result.get("credits", 0)
+                )
+                debug_logger.log_info(f"[AT_REFRESH] Token {token_id}: AT 验证成功（余额: {credits_result.get('credits', 0)}）")
                 return True
+            except Exception as verify_err:
+                # AT 验证失败（可能返回 401），说明 ST 已过期
+                error_msg = str(verify_err)
+                if "401" in error_msg or "UNAUTHENTICATED" in error_msg:
+                    debug_logger.log_warning(f"[AT_REFRESH] Token {token_id}: AT 验证失败 (401)，ST 可能已过期")
+                    return False
+                else:
+                    # 其他错误（如网络问题），仍视为成功
+                    debug_logger.log_warning(f"[AT_REFRESH] Token {token_id}: AT 验证时发生非认证错误: {error_msg}")
+                    return True
 
-            except Exception as e:
-                debug_logger.log_error(f"[AT_REFRESH] Token {token_id}: AT刷新失败 - {str(e)}")
-                # 刷新失败,禁用Token
-                await self.disable_token(token_id)
-                return False
+        except Exception as e:
+            debug_logger.log_error(f"[AT_REFRESH] Token {token_id}: AT刷新失败 - {str(e)}")
+            return False
+
+    async def _try_refresh_st(self, token_id: int, token) -> Optional[str]:
+        """尝试通过浏览器刷新 Session Token
+
+        使用常驻 tab 获取新的 __Secure-next-auth.session-token
+
+        Args:
+            token_id: Token ID
+            token: Token 对象
+
+        Returns:
+            新的 ST 字符串，如果失败返回 None
+        """
+        try:
+            from ..core.config import config
+
+            # 仅在 personal 模式下支持 ST 自动刷新
+            if config.captcha_method != "personal":
+                debug_logger.log_info(f"[ST_REFRESH] 非 personal 模式，跳过 ST 自动刷新")
+                return None
+
+            if not token.current_project_id:
+                debug_logger.log_warning(f"[ST_REFRESH] Token {token_id} 没有 project_id，无法刷新 ST")
+                return None
+
+            debug_logger.log_info(f"[ST_REFRESH] Token {token_id}: 尝试通过浏览器刷新 ST...")
+
+            from .browser_captcha_personal import BrowserCaptchaService
+            service = await BrowserCaptchaService.get_instance(self.db)
+
+            new_st = await service.refresh_session_token(token.current_project_id)
+            if new_st and new_st != token.st:
+                # 更新数据库中的 ST
+                await self.db.update_token(token_id, st=new_st)
+                debug_logger.log_info(f"[ST_REFRESH] Token {token_id}: ST 已自动更新")
+                return new_st
+            elif new_st == token.st:
+                debug_logger.log_warning(f"[ST_REFRESH] Token {token_id}: 获取到的 ST 与原 ST 相同，可能登录已失效")
+                return None
+            else:
+                debug_logger.log_warning(f"[ST_REFRESH] Token {token_id}: 无法获取新 ST")
+                return None
+
+        except Exception as e:
+            debug_logger.log_error(f"[ST_REFRESH] Token {token_id}: 刷新 ST 失败 - {str(e)}")
+            return None
 
     async def ensure_project_exists(self, token_id: int) -> str:
         """确保Token有可用的Project