Upload 7 files

browser_utils/__init__.py

@@ -0,0 +1,47 @@
+# --- browser_utils/__init__.py ---
+# 浏览器操作工具模块
+from .initialization import _initialize_page_logic, _close_page_logic, signal_camoufox_shutdown
+from .operations import (
+    _handle_model_list_response,
+    detect_and_extract_page_error,
+    save_error_snapshot,
+    get_response_via_edit_button,
+    get_response_via_copy_button,
+    _wait_for_response_completion,
+    _get_final_response_content,
+    get_raw_text_content
+)
+from .model_management import (
+    switch_ai_studio_model,
+    load_excluded_models,
+    _handle_initial_model_state_and_storage,
+    _set_model_from_page_display
+)
+from .script_manager import ScriptManager, script_manager
+
+__all__ = [
+    # 初始化相关
+    '_initialize_page_logic',
+    '_close_page_logic', 
+    'signal_camoufox_shutdown',
+    
+    # 页面操作相关
+    '_handle_model_list_response',
+    'detect_and_extract_page_error',
+    'save_error_snapshot',
+    'get_response_via_edit_button',
+    'get_response_via_copy_button',
+    '_wait_for_response_completion',
+    '_get_final_response_content',
+    'get_raw_text_content',
+    
+    # 模型管理相关
+    'switch_ai_studio_model',
+    'load_excluded_models',
+    '_handle_initial_model_state_and_storage',
+    '_set_model_from_page_display',
+
+    # 脚本管理相关
+    'ScriptManager',
+    'script_manager'
+]

browser_utils/initialization.py

@@ -0,0 +1,589 @@
+# --- browser_utils/initialization.py ---
+# 浏览器初始化相关功能模块
+
+import asyncio
+import os
+import time
+import json
+import logging
+from typing import Optional, Any, Dict, Tuple
+
+from playwright.async_api import Page as AsyncPage, Browser as AsyncBrowser, BrowserContext as AsyncBrowserContext, Error as PlaywrightAsyncError, expect as expect_async
+
+# 导入配置和模型
+from config import *
+from models import ClientDisconnectedError
+
+logger = logging.getLogger("AIStudioProxyServer")
+
+
+async def _setup_network_interception_and_scripts(context: AsyncBrowserContext):
+    """设置网络拦截和脚本注入"""
+    try:
+        from config.settings import ENABLE_SCRIPT_INJECTION
+
+        if not ENABLE_SCRIPT_INJECTION:
+            logger.info("脚本注入功能已禁用")
+            return
+
+        # 设置网络拦截
+        await _setup_model_list_interception(context)
+
+        # 可选：仍然注入脚本作为备用方案
+        await _add_init_scripts_to_context(context)
+
+    except Exception as e:
+        logger.error(f"设置网络拦截和脚本注入时发生错误: {e}")
+
+
+async def _setup_model_list_interception(context: AsyncBrowserContext):
+    """设置模型列表网络拦截"""
+    try:
+        async def handle_model_list_route(route):
+            """处理模型列表请求的路由"""
+            request = route.request
+
+            # 检查是否是模型列表请求
+            if 'alkalimakersuite' in request.url and 'ListModels' in request.url:
+                logger.info(f"🔍 拦截到模型列表请求: {request.url}")
+
+                # 继续原始请求
+                response = await route.fetch()
+
+                # 获取原始响应
+                original_body = await response.body()
+
+                # 修改响应
+                modified_body = await _modify_model_list_response(original_body, request.url)
+
+                # 返回修改后的响应
+                await route.fulfill(
+                    response=response,
+                    body=modified_body
+                )
+            else:
+                # 对于其他请求，直接继续
+                await route.continue_()
+
+        # 注册路由拦截器
+        await context.route("**/*", handle_model_list_route)
+        logger.info("✅ 已设置模型列表网络拦截")
+
+    except Exception as e:
+        logger.error(f"设置模型列表网络拦截时发生错误: {e}")
+
+
+async def _modify_model_list_response(original_body: bytes, url: str) -> bytes:
+    """修改模型列表响应"""
+    try:
+        # 解码响应体
+        original_text = original_body.decode('utf-8')
+
+        # 处理反劫持前缀
+        ANTI_HIJACK_PREFIX = ")]}'\n"
+        has_prefix = False
+        if original_text.startswith(ANTI_HIJACK_PREFIX):
+            original_text = original_text[len(ANTI_HIJACK_PREFIX):]
+            has_prefix = True
+
+        # 解析JSON
+        import json
+        json_data = json.loads(original_text)
+
+        # 注入模型
+        modified_data = await _inject_models_to_response(json_data, url)
+
+        # 序列化回JSON
+        modified_text = json.dumps(modified_data, separators=(',', ':'))
+
+        # 重新添加前缀
+        if has_prefix:
+            modified_text = ANTI_HIJACK_PREFIX + modified_text
+
+        logger.info("✅ 成功修改模型列表响应")
+        return modified_text.encode('utf-8')
+
+    except Exception as e:
+        logger.error(f"修改模型列表响应时发生错误: {e}")
+        return original_body
+
+
+async def _inject_models_to_response(json_data: dict, url: str) -> dict:
+    """向响应中注入模型"""
+    try:
+        from .operations import _get_injected_models
+
+        # 获取要注入的模型
+        injected_models = _get_injected_models()
+        if not injected_models:
+            logger.info("没有要注入的模型")
+            return json_data
+
+        # 查找模型数组
+        models_array = _find_model_list_array(json_data)
+        if not models_array:
+            logger.warning("未找到模型数组结构")
+            return json_data
+
+        # 找到模板模型
+        template_model = _find_template_model(models_array)
+        if not template_model:
+            logger.warning("未找到模板模型")
+            return json_data
+
+        # 注入模型
+        for model in reversed(injected_models):  # 反向以保持顺序
+            model_name = model['raw_model_path']
+
+            # 检查模型是否已存在
+            if not any(m[0] == model_name for m in models_array if isinstance(m, list) and len(m) > 0):
+                # 创建新模型条目
+                new_model = json.loads(json.dumps(template_model))  # 深拷贝
+                new_model[0] = model_name  # name
+                new_model[3] = model['display_name']  # display name
+                new_model[4] = model['description']  # description
+
+                # 添加到开头
+                models_array.insert(0, new_model)
+                logger.info(f"✅ 注入模型: {model['display_name']}")
+
+        return json_data
+
+    except Exception as e:
+        logger.error(f"注入模型到响应时发生错误: {e}")
+        return json_data
+
+
+def _find_model_list_array(obj):
+    """递归查找模型列表数组"""
+    if not obj:
+        return None
+
+    # 检查是否是模型数组
+    if isinstance(obj, list) and len(obj) > 0:
+        if all(isinstance(item, list) and len(item) > 0 and
+               isinstance(item[0], str) and item[0].startswith('models/')
+               for item in obj):
+            return obj
+
+    # 递归搜索
+    if isinstance(obj, dict):
+        for value in obj.values():
+            result = _find_model_list_array(value)
+            if result:
+                return result
+    elif isinstance(obj, list):
+        for item in obj:
+            result = _find_model_list_array(item)
+            if result:
+                return result
+
+    return None
+
+
+def _find_template_model(models_array):
+    """查找模板模型"""
+    if not models_array:
+        return None
+
+    # 寻找包含 'flash' 或 'pro' 的模型作为模板
+    for model in models_array:
+        if isinstance(model, list) and len(model) > 7:
+            model_name = model[0] if len(model) > 0 else ""
+            if 'flash' in model_name.lower() or 'pro' in model_name.lower():
+                return model
+
+    # 如果没找到，返回第一个有效模型
+    for model in models_array:
+        if isinstance(model, list) and len(model) > 7:
+            return model
+
+    return None
+
+
+async def _add_init_scripts_to_context(context: AsyncBrowserContext):
+    """在浏览器上下文中添加初始化脚本（备用方案）"""
+    try:
+        from config.settings import USERSCRIPT_PATH
+
+        # 检查脚本文件是否存在
+        if not os.path.exists(USERSCRIPT_PATH):
+            logger.info(f"脚本文件不存在，跳过脚本注入: {USERSCRIPT_PATH}")
+            return
+
+        # 读取脚本内容
+        with open(USERSCRIPT_PATH, 'r', encoding='utf-8') as f:
+            script_content = f.read()
+
+        # 清理UserScript头部
+        cleaned_script = _clean_userscript_headers(script_content)
+
+        # 添加到上下文的初始化脚本
+        await context.add_init_script(cleaned_script)
+        logger.info(f"✅ 已将脚本添加到浏览器上下文初始化脚本: {os.path.basename(USERSCRIPT_PATH)}")
+
+    except Exception as e:
+        logger.error(f"添加初始化脚本到上下文时发生错误: {e}")
+
+
+def _clean_userscript_headers(script_content: str) -> str:
+    """清理UserScript头部信息"""
+    lines = script_content.split('\n')
+    cleaned_lines = []
+    in_userscript_block = False
+
+    for line in lines:
+        if line.strip().startswith('// ==UserScript=='):
+            in_userscript_block = True
+            continue
+        elif line.strip().startswith('// ==/UserScript=='):
+            in_userscript_block = False
+            continue
+        elif in_userscript_block:
+            continue
+        else:
+            cleaned_lines.append(line)
+
+    return '\n'.join(cleaned_lines)
+
+
+async def _initialize_page_logic(browser: AsyncBrowser):
+    """初始化页面逻辑，连接到现有浏览器"""
+    logger.info("--- 初始化页面逻辑 (连接到现有浏览器) ---")
+    temp_context: Optional[AsyncBrowserContext] = None
+    storage_state_path_to_use: Optional[str] = None
+    launch_mode = os.environ.get('LAUNCH_MODE', 'debug')
+    logger.info(f"   检测到启动模式: {launch_mode}")
+    loop = asyncio.get_running_loop()
+    
+    if launch_mode == 'headless' or launch_mode == 'virtual_headless':
+        auth_filename = os.environ.get('ACTIVE_AUTH_JSON_PATH')
+        if auth_filename:
+            constructed_path = auth_filename
+            if os.path.exists(constructed_path):
+                storage_state_path_to_use = constructed_path
+                logger.info(f"   无头模式将使用的认证文件: {constructed_path}")
+            else:
+                logger.error(f"{launch_mode} 模式认证文件无效或不存在: '{constructed_path}'")
+                raise RuntimeError(f"{launch_mode} 模式认证文件无效: '{constructed_path}'")
+        else:
+            logger.error(f"{launch_mode} 模式需要 ACTIVE_AUTH_JSON_PATH 环境变量，但未设置或为空。")
+            raise RuntimeError(f"{launch_mode} 模式需要 ACTIVE_AUTH_JSON_PATH。")
+    elif launch_mode == 'debug':
+        logger.info(f"   调试模式: 尝试从环境变量 ACTIVE_AUTH_JSON_PATH 加载认证文件...")
+        auth_filepath_from_env = os.environ.get('ACTIVE_AUTH_JSON_PATH')
+        if auth_filepath_from_env and os.path.exists(auth_filepath_from_env):
+            storage_state_path_to_use = auth_filepath_from_env
+            logger.info(f"   调试模式将使用的认证文件 (来自环境变量): {storage_state_path_to_use}")
+        elif auth_filepath_from_env:
+            logger.warning(f"   调试模式下环境变量 ACTIVE_AUTH_JSON_PATH 指向的文件不存在: '{auth_filepath_from_env}'。不加载认证文件。")
+        else:
+            logger.info("   调试模式下未通过环境变量提供认证文件。将使用浏览器当前状态。")
+    elif launch_mode == "direct_debug_no_browser":
+        logger.info("   direct_debug_no_browser 模式：不加载 storage_state，不进行浏览器操作。")
+    else:
+        logger.warning(f"   ⚠️ 警告: 未知的启动模式 '{launch_mode}'。不加载 storage_state。")
+    
+    try:
+        logger.info("创建新的浏览器上下文...")
+        context_options: Dict[str, Any] = {'viewport': {'width': 460, 'height': 800}}
+        if storage_state_path_to_use:
+            context_options['storage_state'] = storage_state_path_to_use
+            logger.info(f"   (使用 storage_state='{os.path.basename(storage_state_path_to_use)}')")
+        else:
+            logger.info("   (不使用 storage_state)")
+        
+        # 代理设置需要从server模块中获取
+        import server
+        if server.PLAYWRIGHT_PROXY_SETTINGS:
+            context_options['proxy'] = server.PLAYWRIGHT_PROXY_SETTINGS
+            logger.info(f"   (浏览器上下文将使用代理: {server.PLAYWRIGHT_PROXY_SETTINGS['server']})")
+        else:
+            logger.info("   (浏览器上下文不使用显式代理配置)")
+        
+        context_options['ignore_https_errors'] = True
+        logger.info("   (浏览器上下文将忽略 HTTPS 错误)")
+        
+        temp_context = await browser.new_context(**context_options)
+
+        # 设置网络拦截和脚本注入
+        await _setup_network_interception_and_scripts(temp_context)
+
+        found_page: Optional[AsyncPage] = None
+        pages = temp_context.pages
+        target_url_base = f"https://{AI_STUDIO_URL_PATTERN}"
+        target_full_url = f"{target_url_base}prompts/new_chat"
+        login_url_pattern = 'accounts.google.com'
+        current_url = ""
+        
+        # 导入_handle_model_list_response - 需要延迟导入避免循环引用
+        from .operations import _handle_model_list_response
+        
+        for p_iter in pages:
+            try:
+                page_url_to_check = p_iter.url
+                if not p_iter.is_closed() and target_url_base in page_url_to_check and "/prompts/" in page_url_to_check:
+                    found_page = p_iter
+                    current_url = page_url_to_check
+                    logger.info(f"   找到已打开的 AI Studio 页面: {current_url}")
+                    if found_page:
+                        logger.info(f"   为已存在的页面 {found_page.url} 添加模型列表响应监听器。")
+                        found_page.on("response", _handle_model_list_response)
+                    break
+            except PlaywrightAsyncError as pw_err_url:
+                logger.warning(f"   检查页面 URL 时出现 Playwright 错误: {pw_err_url}")
+            except AttributeError as attr_err_url:
+                logger.warning(f"   检查页面 URL 时出现属性错误: {attr_err_url}")
+            except Exception as e_url_check:
+                logger.warning(f"   检查页面 URL 时出现其他未预期错误: {e_url_check} (类型: {type(e_url_check).__name__})")
+        
+        if not found_page:
+            logger.info(f"-> 未找到合适的现有页面，正在打开新页面并导航到 {target_full_url}...")
+            found_page = await temp_context.new_page()
+            if found_page:
+                logger.info(f"   为新创建的页面添加模型列表响应监听器 (导航前)。")
+                found_page.on("response", _handle_model_list_response)
+            try:
+                await found_page.goto(target_full_url, wait_until="domcontentloaded", timeout=90000)
+                current_url = found_page.url
+                logger.info(f"-> 新页面导航尝试完成。当前 URL: {current_url}")
+            except Exception as new_page_nav_err:
+                # 导入save_error_snapshot函数
+                from .operations import save_error_snapshot
+                await save_error_snapshot("init_new_page_nav_fail")
+                error_str = str(new_page_nav_err)
+                if "NS_ERROR_NET_INTERRUPT" in error_str:
+                    logger.error("\n" + "="*30 + " 网络导航错误提示 " + "="*30)
+                    logger.error(f"❌ 导航到 '{target_full_url}' 失败，出现网络中断错误 (NS_ERROR_NET_INTERRUPT)。")
+                    logger.error("   这通常表示浏览器在尝试加载页面时连接被意外断开。")
+                    logger.error("   可能的原因及排查建议:")
+                    logger.error("     1. 网络连接: 请检查你的本地网络连接是否稳定，并尝试在普通浏览器中访问目标网址。")
+                    logger.error("     2. AI Studio 服务: 确认 aistudio.google.com 服务本身是否可用。")
+                    logger.error("     3. 防火墙/代理/VPN: 检查本地防火墙、杀毒软件、代理或 VPN 设置。")
+                    logger.error("     4. Camoufox 服务: 确认 launch_camoufox.py 脚本是否正常运行。")
+                    logger.error("     5. 系统资源问题: 确保系统有足够的内存和 CPU 资源。")
+                    logger.error("="*74 + "\n")
+                raise RuntimeError(f"导航新页面失败: {new_page_nav_err}") from new_page_nav_err
+        
+        if login_url_pattern in current_url:
+            if launch_mode == 'headless':
+                logger.error("无头模式下检测到重定向至登录页面，认证可能已失效。请更新认证文件。")
+                raise RuntimeError("无头模式认证失败，需要更新认证文件。")
+            else:
+                print(f"\n{'='*20} 需要操作 {'='*20}", flush=True)
+                login_prompt = "   检测到可能需要登录。如果浏览器显示登录页面，请在浏览器窗口中完成 Google 登录，然后在此处按 Enter 键继续..."
+                print(USER_INPUT_START_MARKER_SERVER, flush=True)
+                await loop.run_in_executor(None, input, login_prompt)
+                print(USER_INPUT_END_MARKER_SERVER, flush=True)
+                logger.info("   用户已操作，正在检查登录状态...")
+                try:
+                    await found_page.wait_for_url(f"**/{AI_STUDIO_URL_PATTERN}**", timeout=180000)
+                    current_url = found_page.url
+                    if login_url_pattern in current_url:
+                        logger.error("手动登录尝试后，页面似乎仍停留在登录页面。")
+                        raise RuntimeError("手动登录尝试后仍在登录页面。")
+                    logger.info("   ✅ 登录成功！请不要操作浏览器窗口，等待后续提示。")
+
+                    # 等待模型列表响应，确认登录成功
+                    await _wait_for_model_list_and_handle_auth_save(temp_context, launch_mode, loop)
+                except Exception as wait_login_err:
+                    from .operations import save_error_snapshot
+                    await save_error_snapshot("init_login_wait_fail")
+                    logger.error(f"登录提示后未能检测到 AI Studio URL 或保存状态时出错: {wait_login_err}", exc_info=True)
+                    raise RuntimeError(f"登录提示后未能检测到 AI Studio URL: {wait_login_err}") from wait_login_err
+        elif target_url_base not in current_url or "/prompts/" not in current_url:
+            from .operations import save_error_snapshot
+            await save_error_snapshot("init_unexpected_page")
+            logger.error(f"初始导航后页面 URL 意外: {current_url}。期望包含 '{target_url_base}' 和 '/prompts/'。")
+            raise RuntimeError(f"初始导航后出现意外页面: {current_url}。")
+        
+        logger.info(f"-> 确认当前位于 AI Studio 对话页面: {current_url}")
+        await found_page.bring_to_front()
+        
+        try:
+            input_wrapper_locator = found_page.locator('ms-prompt-input-wrapper')
+            await expect_async(input_wrapper_locator).to_be_visible(timeout=35000)
+            await expect_async(found_page.locator(INPUT_SELECTOR)).to_be_visible(timeout=10000)
+            logger.info("-> ✅ 核心输入区域可见。")
+            
+            model_name_locator = found_page.locator('mat-select[data-test-ms-model-selector] div.model-option-content span.gmat-body-medium')
+            try:
+                model_name_on_page = await model_name_locator.first.inner_text(timeout=5000)
+                logger.info(f"-> 🤖 页面检测到的当前模型: {model_name_on_page}")
+            except PlaywrightAsyncError as e:
+                logger.error(f"获取模型名称时出错 (model_name_locator): {e}")
+                raise
+            
+            result_page_instance = found_page
+            result_page_ready = True
+
+            # 脚本注入已在上下文创建时完成，无需在此处重复注入
+
+            logger.info(f"✅ 页面逻辑初始化成功。")
+            return result_page_instance, result_page_ready
+        except Exception as input_visible_err:
+            from .operations import save_error_snapshot
+            await save_error_snapshot("init_fail_input_timeout")
+            logger.error(f"页面初始化失败：核心输入区域未在预期时间内变为可见。最后的 URL 是 {found_page.url}", exc_info=True)
+            raise RuntimeError(f"页面初始化失败��核心输入区域未在预期时间内变为可见。最后的 URL 是 {found_page.url}") from input_visible_err
+    except Exception as e_init_page:
+        logger.critical(f"❌ 页面逻辑初始化期间发生严重意外错误: {e_init_page}", exc_info=True)
+        if temp_context:
+            try:
+                logger.info(f"   尝试关闭临时的浏览器上下文 due to initialization error.")
+                await temp_context.close()
+                logger.info("   ✅ 临时浏览器上下文已关闭。")
+            except Exception as close_err:
+                 logger.warning(f"   ⚠️ 关闭临时浏览器上下文时出错: {close_err}")
+        from .operations import save_error_snapshot
+        await save_error_snapshot("init_unexpected_error")
+        raise RuntimeError(f"页面初始化意外错误: {e_init_page}") from e_init_page
+
+
+async def _close_page_logic():
+    """关闭页面逻辑"""
+    # 需要访问全局变量
+    import server
+    logger.info("--- 运行页面逻辑关闭 --- ")
+    if server.page_instance and not server.page_instance.is_closed():
+        try:
+            await server.page_instance.close()
+            logger.info("   ✅ 页面已关闭")
+        except PlaywrightAsyncError as pw_err:
+            logger.warning(f"   ⚠️ 关闭页面时出现Playwright错误: {pw_err}")
+        except asyncio.TimeoutError as timeout_err:
+            logger.warning(f"   ⚠️ 关闭页面时超时: {timeout_err}")
+        except Exception as other_err:
+            logger.error(f"   ⚠️ 关闭页面时出现意外错误: {other_err} (类型: {type(other_err).__name__})", exc_info=True)
+    server.page_instance = None
+    server.is_page_ready = False
+    logger.info("页面逻辑状态已重置。")
+    return None, False
+
+
+async def signal_camoufox_shutdown():
+    """发送关闭信号到Camoufox服务器"""
+    logger.info("   尝试发送关闭信号到 Camoufox 服务器 (此功能可能已由父进程处理)...")
+    ws_endpoint = os.environ.get('CAMOUFOX_WS_ENDPOINT')
+    if not ws_endpoint:
+        logger.warning("   ⚠️ 无法发送关闭信号：未找到 CAMOUFOX_WS_ENDPOINT 环境变量。")
+        return
+
+    # 需要访问全局浏览器实例
+    import server
+    if not server.browser_instance or not server.browser_instance.is_connected():
+        logger.warning("   ⚠️ 浏览器实例已断开或未初始化，跳过关闭信号发送。")
+        return
+    try:
+        await asyncio.sleep(0.2)
+        logger.info("   ✅ (模拟) 关闭信号已处理。")
+    except Exception as e:
+        logger.error(f"   ⚠️ 发送关闭信号过程中捕获异常: {e}", exc_info=True)
+
+
+async def _wait_for_model_list_and_handle_auth_save(temp_context, launch_mode, loop):
+    """等待模型列表响应并处理认证保存"""
+    import server
+
+    # 等待模型列表响应，确认登录成功
+    logger.info("   等待模型列表响应以确认登录成功...")
+    try:
+        # 等待模型列表事件，最多等待30秒
+        await asyncio.wait_for(server.model_list_fetch_event.wait(), timeout=30.0)
+        logger.info("   ✅ 检测到模型列表响应，登录确认成功！")
+    except asyncio.TimeoutError:
+        logger.warning("   ⚠️ 等待模型列表响应超时，但继续处理认证保存...")
+
+    # 检查是否启用自动确认
+    if AUTO_CONFIRM_LOGIN:
+        print("\n" + "="*50, flush=True)
+        print("   ✅ 登录成功！检测到模型列表响应。", flush=True)
+        print("   🤖 自动确认模式已启用，将自动保存认证状态...", flush=True)
+
+        # 自动保存认证状态
+        await _handle_auth_file_save_auto(temp_context)
+        print("="*50 + "\n", flush=True)
+        return
+
+    # 手动确认模式
+    print("\n" + "="*50, flush=True)
+    print("   【用户交互】需要您的输入!", flush=True)
+    print("   ✅ 登录成功！检测到模型列表响应。", flush=True)
+
+    should_save_auth_choice = ''
+    if AUTO_SAVE_AUTH and launch_mode == 'debug':
+        logger.info("   自动保存认证模式已启用，将自动保存认证状态...")
+        should_save_auth_choice = 'y'
+    else:
+        save_auth_prompt = "   是否要将当前的浏览器认证状态保存到文件？ (y/N): "
+        print(USER_INPUT_START_MARKER_SERVER, flush=True)
+        try:
+            auth_save_input_future = loop.run_in_executor(None, input, save_auth_prompt)
+            should_save_auth_choice = await asyncio.wait_for(auth_save_input_future, timeout=AUTH_SAVE_TIMEOUT)
+        except asyncio.TimeoutError:
+            print(f"   输入等待超时({AUTH_SAVE_TIMEOUT}秒)。默认不保存认证状态。", flush=True)
+            should_save_auth_choice = 'n'
+        finally:
+            print(USER_INPUT_END_MARKER_SERVER, flush=True)
+
+    if should_save_auth_choice.strip().lower() == 'y':
+        await _handle_auth_file_save(temp_context, loop)
+    else:
+        print("   好的，不保存认证状态。", flush=True)
+
+    print("="*50 + "\n", flush=True)
+
+
+async def _handle_auth_file_save(temp_context, loop):
+    """处理认证文件保存（手动模式）"""
+    os.makedirs(SAVED_AUTH_DIR, exist_ok=True)
+    default_auth_filename = f"auth_state_{int(time.time())}.json"
+
+    print(USER_INPUT_START_MARKER_SERVER, flush=True)
+    filename_prompt_str = f"   请输入保存的文件名 (默认为: {default_auth_filename}，输入 'cancel' 取消保存): "
+    chosen_auth_filename = ''
+
+    try:
+        filename_input_future = loop.run_in_executor(None, input, filename_prompt_str)
+        chosen_auth_filename = await asyncio.wait_for(filename_input_future, timeout=AUTH_SAVE_TIMEOUT)
+    except asyncio.TimeoutError:
+        print(f"   输入文件名等待超时({AUTH_SAVE_TIMEOUT}秒)。将使用默认文件名: {default_auth_filename}", flush=True)
+        chosen_auth_filename = default_auth_filename
+    finally:
+        print(USER_INPUT_END_MARKER_SERVER, flush=True)
+
+    # 检查用户是否选择取消
+    if chosen_auth_filename.strip().lower() == 'cancel':
+        print("   用户选择取消保存认证状态。", flush=True)
+        return
+
+    final_auth_filename = chosen_auth_filename.strip() or default_auth_filename
+    if not final_auth_filename.endswith(".json"):
+        final_auth_filename += ".json"
+
+    auth_save_path = os.path.join(SAVED_AUTH_DIR, final_auth_filename)
+
+    try:
+        await temp_context.storage_state(path=auth_save_path)
+        print(f"   ✅ 认证状态已成功保存到: {auth_save_path}", flush=True)
+    except Exception as save_state_err:
+        logger.error(f"   ❌ 保存认证状态失败: {save_state_err}", exc_info=True)
+        print(f"   ❌ 保存认证状态失败: {save_state_err}", flush=True)
+
+
+async def _handle_auth_file_save_auto(temp_context):
+    """处理认证文件保存（自动模式）"""
+    os.makedirs(SAVED_AUTH_DIR, exist_ok=True)
+
+    # 生成基于时间戳的文件名
+    timestamp = int(time.time())
+    auto_auth_filename = f"auth_auto_{timestamp}.json"
+    auth_save_path = os.path.join(SAVED_AUTH_DIR, auto_auth_filename)
+
+    try:
+        await temp_context.storage_state(path=auth_save_path)
+        print(f"   ✅ 认证状态已自动保存到: {auth_save_path}", flush=True)
+        logger.info(f"   自动保存认证状态成功: {auth_save_path}")
+    except Exception as save_state_err:
+        logger.error(f"   ❌ 自动保存认证状态失败: {save_state_err}", exc_info=True)
+        print(f"   ❌ 自动保存认证状态失败: {save_state_err}", flush=True)

browser_utils/model_management.py

@@ -0,0 +1,392 @@
+# --- browser_utils/model_management.py ---
+# 浏览器模型管理相关功能模块
+
+import asyncio
+import json
+import os
+import logging
+import time
+from typing import Optional, Set
+
+from playwright.async_api import Page as AsyncPage, expect as expect_async, Error as PlaywrightAsyncError
+
+# 导入配置和模型
+from config import *
+from models import ClientDisconnectedError
+
+logger = logging.getLogger("AIStudioProxyServer")
+
+async def switch_ai_studio_model(page: AsyncPage, model_id: str, req_id: str) -> bool:
+    """切换AI Studio模型"""
+    logger.info(f"[{req_id}] 开始切换模型到: {model_id}")
+    original_prefs_str: Optional[str] = None
+    original_prompt_model: Optional[str] = None
+    new_chat_url = f"https://{AI_STUDIO_URL_PATTERN}prompts/new_chat"
+    
+    try:
+        original_prefs_str = await page.evaluate("() => localStorage.getItem('aiStudioUserPreference')")
+        if original_prefs_str:
+            try:
+                original_prefs_obj = json.loads(original_prefs_str)
+                original_prompt_model = original_prefs_obj.get("promptModel")
+                logger.info(f"[{req_id}] 切换前 localStorage.promptModel 为: {original_prompt_model or '未设置'}")
+            except json.JSONDecodeError:
+                logger.warning(f"[{req_id}] 无法解析原始的 aiStudioUserPreference JSON 字符串。")
+                original_prefs_str = None
+        
+        current_prefs_for_modification = json.loads(original_prefs_str) if original_prefs_str else {}
+        full_model_path = f"models/{model_id}"
+        
+        if current_prefs_for_modification.get("promptModel") == full_model_path:
+            logger.info(f"[{req_id}] 模型已经设置为 {model_id} (localStorage 中已是目标值)，无需切换")
+            if page.url != new_chat_url:
+                 logger.info(f"[{req_id}] 当前 URL 不是 new_chat ({page.url})，导航到 {new_chat_url}")
+                 await page.goto(new_chat_url, wait_until="domcontentloaded", timeout=30000)
+                 await expect_async(page.locator(INPUT_SELECTOR)).to_be_visible(timeout=30000)
+            return True
+        
+        logger.info(f"[{req_id}] 从 {current_prefs_for_modification.get('promptModel', '未知')} 更新 localStorage.promptModel 为 {full_model_path}")
+        current_prefs_for_modification["promptModel"] = full_model_path
+        await page.evaluate("(prefsStr) => localStorage.setItem('aiStudioUserPreference', prefsStr)", json.dumps(current_prefs_for_modification))
+        
+        # 强制设置配置选项
+        logger.info(f"[{req_id}] 强制设置配置选项：isAdvancedOpen=true, areToolsOpen=false")
+        current_prefs_for_modification["isAdvancedOpen"] = True
+        current_prefs_for_modification["areToolsOpen"] = False
+        await page.evaluate("(prefsStr) => localStorage.setItem('aiStudioUserPreference', prefsStr)", json.dumps(current_prefs_for_modification))
+
+        logger.info(f"[{req_id}] localStorage 已更新，导航到 '{new_chat_url}' 应用新模型...")
+        await page.goto(new_chat_url, wait_until="domcontentloaded", timeout=30000)
+
+        input_field = page.locator(INPUT_SELECTOR)
+        await expect_async(input_field).to_be_visible(timeout=30000)
+        logger.info(f"[{req_id}] 页面已导航到新聊天并加载完成，输入框可见")
+        
+        final_prefs_str = await page.evaluate("() => localStorage.getItem('aiStudioUserPreference')")
+        final_prompt_model_in_storage: Optional[str] = None
+        if final_prefs_str:
+            try:
+                final_prefs_obj = json.loads(final_prefs_str)
+                final_prompt_model_in_storage = final_prefs_obj.get("promptModel")
+            except json.JSONDecodeError:
+                logger.warning(f"[{req_id}] 无法解析刷新后的 aiStudioUserPreference JSON 字符串。")
+        
+        if final_prompt_model_in_storage == full_model_path:
+            logger.info(f"[{req_id}] ✅ AI Studio localStorage 中模型已成功设置为: {full_model_path}")
+            
+            page_display_match = False
+            expected_display_name_for_target_id = None
+            actual_displayed_model_name_on_page = "无法读取"
+            
+            # 获取parsed_model_list
+            import server
+            parsed_model_list = getattr(server, 'parsed_model_list', [])
+            
+            if parsed_model_list:
+                for m_obj in parsed_model_list:
+                    if m_obj.get("id") == model_id:
+                        expected_display_name_for_target_id = m_obj.get("display_name")
+                        break
+            
+            if not expected_display_name_for_target_id:
+                logger.warning(f"[{req_id}] 无法在parsed_model_list中找到目标ID '{model_id}' 的显示名称，跳过页面显示名称验证。这可能不准确。")
+                page_display_match = True
+            else:
+                try:
+                    model_name_locator = page.locator('mat-select[data-test-ms-model-selector] div.model-option-content span.gmat-body-medium')
+                    actual_displayed_model_name_on_page_raw = await model_name_locator.first.inner_text(timeout=5000)
+                    actual_displayed_model_name_on_page = actual_displayed_model_name_on_page_raw.strip()
+                    normalized_actual_display = actual_displayed_model_name_on_page.lower()
+                    normalized_expected_display = expected_display_name_for_target_id.strip().lower()
+                    
+                    if normalized_actual_display == normalized_expected_display:
+                        page_display_match = True
+                        logger.info(f"[{req_id}] ✅ 页面显示模型 ('{actual_displayed_model_name_on_page}') 与期望 ('{expected_display_name_for_target_id}') 一致。")
+                    else:
+                        logger.error(f"[{req_id}] ❌ 页面显示模型 ('{actual_displayed_model_name_on_page}') 与期望 ('{expected_display_name_for_target_id}') 不一致。(Raw page: '{actual_displayed_model_name_on_page_raw}')")
+                except Exception as e_disp:
+                    logger.warning(f"[{req_id}] 读取页面显示的当前模型名称时出错: {e_disp}。将无法验证页面显示。")
+            
+            if page_display_match:
+                return True
+            else:
+                logger.error(f"[{req_id}] ❌ 模型切换失败，因为页面显示的模型与期望不符 (即使localStorage可能已更改)。")
+        else:
+            logger.error(f"[{req_id}] ❌ AI Studio 未接受模型更改 (localStorage)。期望='{full_model_path}', 实际='{final_prompt_model_in_storage or '未设置或无效'}'.")
+        
+        logger.info(f"[{req_id}] 模型切换失败。尝试恢复到页面当前实际显示的模型的状态...")
+        current_displayed_name_for_revert_raw = "无法读取"
+        current_displayed_name_for_revert_stripped = "无法读取"
+        
+        try:
+            model_name_locator_revert = page.locator('mat-select[data-test-ms-model-selector] div.model-option-content span.gmat-body-medium')
+            current_displayed_name_for_revert_raw = await model_name_locator_revert.first.inner_text(timeout=5000)
+            current_displayed_name_for_revert_stripped = current_displayed_name_for_revert_raw.strip()
+            logger.info(f"[{req_id}] 恢复：页面当前显示的模型名称 (原始: '{current_displayed_name_for_revert_raw}', 清理后: '{current_displayed_name_for_revert_stripped}')")
+        except Exception as e_read_disp_revert:
+            logger.warning(f"[{req_id}] 恢复：读取页面当前显示模型名称失败: {e_read_disp_revert}。将尝试回退到原始localStorage。")
+            if original_prefs_str:
+                logger.info(f"[{req_id}] 恢复：由于无法读取当前页面显示，尝试将 localStorage 恢复到原始状态: '{original_prompt_model or '未设置'}'")
+                await page.evaluate("(origPrefs) => localStorage.setItem('aiStudioUserPreference', origPrefs)", original_prefs_str)
+                logger.info(f"[{req_id}] 恢复：导航到 '{new_chat_url}' 以应用恢复的原始 localStorage 设置...")
+                await page.goto(new_chat_url, wait_until="domcontentloaded", timeout=20000)
+                await expect_async(page.locator(INPUT_SELECTOR)).to_be_visible(timeout=20000)
+                logger.info(f"[{req_id}] 恢复：页面已导航到新聊天并加载，已尝试应用原始 localStorage。")
+            else:
+                logger.warning(f"[{req_id}] 恢复：无有效的原始 localStorage 状态可恢复，也无法读取当前页面显示。")
+            return False
+        
+        model_id_to_revert_to = None
+        if parsed_model_list and current_displayed_name_for_revert_stripped != "无法读取":
+            normalized_current_display_for_revert = current_displayed_name_for_revert_stripped.lower()
+            for m_obj in parsed_model_list:
+                parsed_list_display_name = m_obj.get("display_name", "").strip().lower()
+                if parsed_list_display_name == normalized_current_display_for_revert:
+                    model_id_to_revert_to = m_obj.get("id")
+                    logger.info(f"[{req_id}] 恢复：页面显示名称 '{current_displayed_name_for_revert_stripped}' 对应模型ID: {model_id_to_revert_to}")
+                    break
+            
+            if not model_id_to_revert_to:
+                logger.warning(f"[{req_id}] 恢复：无法在 parsed_model_list 中找到与页面显示名称 '{current_displayed_name_for_revert_stripped}' 匹配的模型ID。")
+        else:
+            if current_displayed_name_for_revert_stripped == "无法读取":
+                 logger.warning(f"[{req_id}] 恢复：因无法读取页面显示名称，故不能从 parsed_model_list ���换ID。")
+            else:
+                 logger.warning(f"[{req_id}] 恢复：parsed_model_list 为空，无法从显示名称 '{current_displayed_name_for_revert_stripped}' 转换模型ID。")
+        
+        if model_id_to_revert_to:
+            base_prefs_for_final_revert = {}
+            try:
+                current_ls_content_str = await page.evaluate("() => localStorage.getItem('aiStudioUserPreference')")
+                if current_ls_content_str:
+                    base_prefs_for_final_revert = json.loads(current_ls_content_str)
+                elif original_prefs_str:
+                    base_prefs_for_final_revert = json.loads(original_prefs_str)
+            except json.JSONDecodeError:
+                logger.warning(f"[{req_id}] 恢复：解析现有 localStorage 以构建恢复偏好失败。")
+            
+            path_to_revert_to = f"models/{model_id_to_revert_to}"
+            base_prefs_for_final_revert["promptModel"] = path_to_revert_to
+            # 强制设置配置选项
+            base_prefs_for_final_revert["isAdvancedOpen"] = True
+            base_prefs_for_final_revert["areToolsOpen"] = False
+            logger.info(f"[{req_id}] 恢复：准备将 localStorage.promptModel 设置回页面实际显示的模型的路径: '{path_to_revert_to}'，并强制设置配置选项")
+            await page.evaluate("(prefsStr) => localStorage.setItem('aiStudioUserPreference', prefsStr)", json.dumps(base_prefs_for_final_revert))
+            logger.info(f"[{req_id}] 恢复：导航到 '{new_chat_url}' 以应用恢复到 '{model_id_to_revert_to}' 的 localStorage 设置...")
+            await page.goto(new_chat_url, wait_until="domcontentloaded", timeout=30000)
+            await expect_async(page.locator(INPUT_SELECTOR)).to_be_visible(timeout=30000)
+            logger.info(f"[{req_id}] 恢复：页面已导航到新聊天并加载。localStorage 应已设置为反映模型 '{model_id_to_revert_to}'。")
+        else:
+            logger.error(f"[{req_id}] 恢复：无法将模型恢复到页面显示的状态，因为未能从显示名称 '{current_displayed_name_for_revert_stripped}' 确定有效模型ID。")
+            if original_prefs_str:
+                logger.warning(f"[{req_id}] 恢复：作为最终后备，尝试恢复到原始 localStorage: '{original_prompt_model or '未设置'}'")
+                await page.evaluate("(origPrefs) => localStorage.setItem('aiStudioUserPreference', origPrefs)", original_prefs_str)
+                logger.info(f"[{req_id}] 恢复：导航到 '{new_chat_url}' 以应用最终后备的原始 localStorage。")
+                await page.goto(new_chat_url, wait_until="domcontentloaded", timeout=20000)
+                await expect_async(page.locator(INPUT_SELECTOR)).to_be_visible(timeout=20000)
+                logger.info(f"[{req_id}] 恢复：页面已导航到新聊天并加载，已应用最终后备的原始 localStorage。")
+            else:
+                logger.warning(f"[{req_id}] 恢复：无有效的原始 localStorage 状态可作为最终后备。")
+        
+        return False
+        
+    except Exception as e:
+        logger.exception(f"[{req_id}] ❌ 切换模型过程中发生严重错误")
+        # 导入save_error_snapshot函数
+        from .operations import save_error_snapshot
+        await save_error_snapshot(f"model_switch_error_{req_id}")
+        try:
+            if original_prefs_str:
+                logger.info(f"[{req_id}] 发生异常，尝试恢复 localStorage 至: {original_prompt_model or '未设置'}")
+                await page.evaluate("(origPrefs) => localStorage.setItem('aiStudioUserPreference', origPrefs)", original_prefs_str)
+                logger.info(f"[{req_id}] 异常恢复：导航到 '{new_chat_url}' 以应用恢复的 localStorage。")
+                await page.goto(new_chat_url, wait_until="domcontentloaded", timeout=15000)
+                await expect_async(page.locator(INPUT_SELECTOR)).to_be_visible(timeout=15000)
+        except Exception as recovery_err:
+            logger.error(f"[{req_id}] 异常后恢复 localStorage 失败: {recovery_err}")
+        return False
+
+def load_excluded_models(filename: str):
+    """加载排除的模型列表"""
+    import server
+    excluded_model_ids = getattr(server, 'excluded_model_ids', set())
+    
+    excluded_file_path = os.path.join(os.path.dirname(__file__), '..', filename)
+    try:
+        if os.path.exists(excluded_file_path):
+            with open(excluded_file_path, 'r', encoding='utf-8') as f:
+                loaded_ids = {line.strip() for line in f if line.strip()}
+            if loaded_ids:
+                excluded_model_ids.update(loaded_ids)
+                server.excluded_model_ids = excluded_model_ids
+                logger.info(f"✅ 从 '{filename}' 加载了 {len(loaded_ids)} 个模型到排除列表: {excluded_model_ids}")
+            else:
+                logger.info(f"'{filename}' 文件为空或不包含有效的模型 ID，排除列表未更改。")
+        else:
+            logger.info(f"模型排除列表文件 '{filename}' 未找到，排除列表为空。")
+    except Exception as e:
+        logger.error(f"❌ 从 '{filename}' 加载排除模型列表时出错: {e}", exc_info=True)
+
+async def _handle_initial_model_state_and_storage(page: AsyncPage):
+    """处理初始模型状态和存储"""
+    import server
+    current_ai_studio_model_id = getattr(server, 'current_ai_studio_model_id', None)
+    parsed_model_list = getattr(server, 'parsed_model_list', [])
+    model_list_fetch_event = getattr(server, 'model_list_fetch_event', None)
+    
+    logger.info("--- (新) 处理初始模型状态, localStorage 和 isAdvancedOpen ---")
+    needs_reload_and_storage_update = False
+    reason_for_reload = ""
+    
+    try:
+        initial_prefs_str = await page.evaluate("() => localStorage.getItem('aiStudioUserPreference')")
+        if not initial_prefs_str:
+            needs_reload_and_storage_update = True
+            reason_for_reload = "localStorage.aiStudioUserPreference 未找到。"
+            logger.info(f"   判定需要刷新和存储更新: {reason_for_reload}")
+        else:
+            logger.info("   localStorage 中找到 'aiStudioUserPreference'。正在解析...")
+            try:
+                pref_obj = json.loads(initial_prefs_str)
+                prompt_model_path = pref_obj.get("promptModel")
+                is_advanced_open_in_storage = pref_obj.get("isAdvancedOpen")
+                is_prompt_model_valid = isinstance(prompt_model_path, str) and prompt_model_path.strip()
+                
+                if not is_prompt_model_valid:
+                    needs_reload_and_storage_update = True
+                    reason_for_reload = "localStorage.promptModel 无效或未设置。"
+                    logger.info(f"   判定需要刷新和存储更新: {reason_for_reload}")
+                elif is_advanced_open_in_storage is not True:
+                    needs_reload_and_storage_update = True
+                    reason_for_reload = f"localStorage.isAdvancedOpen ({is_advanced_open_in_storage}) 不为 True。"
+                    logger.info(f"   判定需要刷新和存储更新: {reason_for_reload}")
+                else:
+                    server.current_ai_studio_model_id = prompt_model_path.split('/')[-1]
+                    logger.info(f"   ✅ localStorage 有效且 isAdvancedOpen=true。初始模型 ID 从 localStorage 设置为: {server.current_ai_studio_model_id}")
+            except json.JSONDecodeError:
+                needs_reload_and_storage_update = True
+                reason_for_reload = "解析 localStorage.aiStudioUserPreference JSON 失败。"
+                logger.error(f"   判定需要刷新和存储更新: {reason_for_reload}")
+        
+        if needs_reload_and_storage_update:
+            logger.info(f"   执行刷新和存储更新流程，原因: {reason_for_reload}")
+            logger.info("   步骤 1: 调用 _set_model_from_page_display(set_storage=True) 更新 localStorage 和全局模型 ID...")
+            await _set_model_from_page_display(page, set_storage=True)
+            
+            current_page_url = page.url
+            logger.info(f"   步骤 2: 重新加载页面 ({current_page_url}) 以应用 isAdvancedOpen=true...")
+            max_retries = 3
+            for attempt in range(max_retries):
+                try:
+                    logger.info(f"   尝试重新加载页面 (第 {attempt + 1}/{max_retries} 次): {current_page_url}")
+                    await page.goto(current_page_url, wait_until="domcontentloaded", timeout=40000)
+                    await expect_async(page.locator(INPUT_SELECTOR)).to_be_visible(timeout=30000)
+                    logger.info(f"   ✅ 页面已成功重新加载到: {page.url}")
+                    break  # 成功则跳出循环
+                except Exception as reload_err:
+                    logger.warning(f"   ⚠️ 页面重新加载尝试 {attempt + 1}/{max_retries} 失败: {reload_err}")
+                    if attempt < max_retries - 1:
+                        logger.info(f"   将在5秒后重试...")
+                        await asyncio.sleep(5)
+                    else:
+                        logger.error(f"   ❌ 页面重新加载在 {max_retries} 次尝试后最终失败: {reload_err}. 后续模型状态可能不准确。", exc_info=True)
+                        from .operations import save_error_snapshot
+                        await save_error_snapshot(f"initial_storage_reload_fail_attempt_{attempt+1}")
+            
+            logger.info("   步骤 3: 重新加载后，再次调用 _set_model_from_page_display(set_storage=False) 以同步全局模型 ID...")
+            await _set_model_from_page_display(page, set_storage=False)
+            logger.info(f"   ✅ 刷新和存储更新流程完成。最终全局模型 ID: {server.current_ai_studio_model_id}")
+        else:
+            logger.info("   localStorage 状态良好 (isAdvancedOpen=true, promptModel有效)，无需刷新页面。")
+    except Exception as e:
+        logger.error(f"❌ (新) 处理初始模型状态和 localStorage 时发生严重错误: {e}", exc_info=True)
+        try:
+            logger.warning("   由于发生错误，尝试回退仅从页面显示设置全局模型 ID (不写入localStorage)...")
+            await _set_model_from_page_display(page, set_storage=False)
+        except Exception as fallback_err:
+            logger.error(f"   回退设置模型ID也失败: {fallback_err}")
+
+async def _set_model_from_page_display(page: AsyncPage, set_storage: bool = False):
+    """从页面显示设置模型"""
+    import server
+    current_ai_studio_model_id = getattr(server, 'current_ai_studio_model_id', None)
+    parsed_model_list = getattr(server, 'parsed_model_list', [])
+    model_list_fetch_event = getattr(server, 'model_list_fetch_event', None)
+    
+    try:
+        logger.info("   尝试从页面显示元素读取当前模型名称...")
+        model_name_locator = page.locator('mat-select[data-test-ms-model-selector] div.model-option-content span.gmat-body-medium')
+        displayed_model_name_from_page_raw = await model_name_locator.first.inner_text(timeout=7000)
+        displayed_model_name = displayed_model_name_from_page_raw.strip()
+        logger.info(f"   页面当前显示模型名称 (原始: '{displayed_model_name_from_page_raw}', 清理后: '{displayed_model_name}')")
+        
+        found_model_id_from_display = None
+        if model_list_fetch_event and not model_list_fetch_event.is_set():
+            logger.info("   等待模型列表数据 (最多5秒) 以便转换显示名称...")
+            try: 
+                await asyncio.wait_for(model_list_fetch_event.wait(), timeout=5.0)
+            except asyncio.TimeoutError: 
+                logger.warning("   等待模型列表超时，可能无法准确转换显示名称为ID。")
+        
+        if parsed_model_list:
+            for model_obj in parsed_model_list:
+                if model_obj.get("display_name") and model_obj.get("display_name").strip() == displayed_model_name:
+                    found_model_id_from_display = model_obj.get("id")
+                    logger.info(f"   显示名称 '{displayed_model_name}' 对应模型 ID: {found_model_id_from_display}")
+                    break
+            
+            if not found_model_id_from_display:
+                 logger.warning(f"   未在已知模型列表中找到与显示名称 '{displayed_model_name}' 匹配的 ID。")
+        else:
+            logger.warning("   模型列表尚不可用，无法将显示名称转换为ID。")
+        
+        new_model_value = found_model_id_from_display if found_model_id_from_display else displayed_model_name
+        if server.current_ai_studio_model_id != new_model_value:
+            server.current_ai_studio_model_id = new_model_value
+            logger.info(f"   全局 current_ai_studio_model_id 已更新为: {server.current_ai_studio_model_id}")
+        else:
+            logger.info(f"   全局 current_ai_studio_model_id ('{server.current_ai_studio_model_id}') 与从页面获取的值一致，未更改。")
+        
+        if set_storage:
+            logger.info(f"   准备为页面状态设置 localStorage (确保 isAdvancedOpen=true)...")
+            existing_prefs_for_update_str = await page.evaluate("() => localStorage.getItem('aiStudioUserPreference')")
+            prefs_to_set = {}
+            if existing_prefs_for_update_str:
+                try:
+                    prefs_to_set = json.loads(existing_prefs_for_update_str)
+                except json.JSONDecodeError:
+                    logger.warning("   解析现有 localStorage.aiStudioUserPreference 失败，将创建新的偏好设置。")
+            
+            prefs_to_set["isAdvancedOpen"] = True
+            logger.info(f"     强制 isAdvancedOpen: true")
+            prefs_to_set["areToolsOpen"] = False
+            logger.info(f"     强制 areToolsOpen: false")
+            
+            if found_model_id_from_display:
+                new_prompt_model_path = f"models/{found_model_id_from_display}"
+                prefs_to_set["promptModel"] = new_prompt_model_path
+                logger.info(f"     设置 promptModel 为: {new_prompt_model_path} (基于找到的ID)")
+            elif "promptModel" not in prefs_to_set:
+                logger.warning(f"     无法从页面显示 '{displayed_model_name}' 找到模型ID，且 localStorage 中无现有 promptModel。promptModel 将不会被主动设置以避免潜在问题。")
+            
+            default_keys_if_missing = {
+                "bidiModel": "models/gemini-1.0-pro-001",
+                "isSafetySettingsOpen": False,
+                "hasShownSearchGroundingTos": False,
+                "autosaveEnabled": True,
+                "theme": "system",
+                "bidiOutputFormat": 3,
+                "isSystemInstructionsOpen": False,
+                "warmWelcomeDisplayed": True,
+                "getCodeLanguage": "Node.js",
+                "getCodeHistoryToggle": False,
+                "fileCopyrightAcknowledged": True
+            }
+            for key, val_default in default_keys_if_missing.items():
+                if key not in prefs_to_set:
+                    prefs_to_set[key] = val_default
+            
+            await page.evaluate("(prefsStr) => localStorage.setItem('aiStudioUserPreference', prefsStr)", json.dumps(prefs_to_set))
+            logger.info(f"   ✅ localStorage.aiStudioUserPreference 已更新。isAdvancedOpen: {prefs_to_set.get('isAdvancedOpen')}, areToolsOpen: {prefs_to_set.get('areToolsOpen')}, promptModel: '{prefs_to_set.get('promptModel', '未设置/保留原样')}'。")
+    except Exception as e_set_disp:
+        logger.error(f"   尝试从页面显示设置模型时出错: {e_set_disp}", exc_info=True) 

browser_utils/more_modles.js

@@ -0,0 +1,305 @@
+// ==UserScript==
+// @name         Google AI Studio Model Injector (Multi-Model) - XHR+Fetch+ArrayStructure
+// @namespace    http://tampermonkey.net/
+// @version      1.6
+// @description  Inject multiple custom models with themed emojis (Kingfall, Gemini, Goldmane, etc.) into the model list on Google AI Studio. Intercepts XHR/fetch, handles array-of-arrays JSON structure.
+// @author       Generated by AI / HCPTangHY / Mozi
+// @match        https://aistudio.google.com/*
+// @icon         https://www.google.com/s2/favicons?sz=64&domain=aistudio.google.com
+// @grant        none
+// @run-at       document-start
+// @license      MIT
+// ==/UserScript==
+
+(function() {
+    'use strict';
+
+     // ================== 定义要注入的模型列表 =====================
+    // ↓↓↓↓↓↓ 版本号 / EMOJIS 更新 ↓↓↓↓↓↓
+    const SCRIPT_VERSION = "v1.6";
+     // ↓↓↓↓↓↓ 模型列表 EMOJIS 已更新 ↓↓↓↓↓↓
+    const MODELS_TO_INJECT = [
+       {
+          name: 'models/kingfall-ab-test',
+          displayName: `👑 Kingfall (Script ${SCRIPT_VERSION})`, // 👑 King
+          description: `Model injected by script ${SCRIPT_VERSION}`
+       },
+        {
+          name: 'models/gemini-2.5-pro-preview-03-25',
+          displayName: `✨ Gemini 2.5 Pro 03-25 (Script ${SCRIPT_VERSION})`, // ✨ Magic/AI
+           description: `Model injected by script ${SCRIPT_VERSION}`
+       },
+        {
+          name: 'models/goldmane-ab-test',
+          displayName: `🦁 Goldmane (Script ${SCRIPT_VERSION})`, // 🦁 Gold Mane
+           description: `Model injected by script ${SCRIPT_VERSION}`
+       },
+        {
+          name: 'models/claybrook-ab-test',
+          displayName: `💧 Claybrook (Script ${SCRIPT_VERSION})`, // 💧 Brook
+           description: `Model injected by script ${SCRIPT_VERSION}`
+       },
+       {
+           name: 'models/frostwind-ab-test',
+          displayName: `❄️ Frostwind (Script ${SCRIPT_VERSION})`, // ❄️ Frost
+           description: `Model injected by script ${SCRIPT_VERSION}`
+       },
+        {
+           name: 'models/calmriver-ab-test',
+           displayName: `🌊 Calmriver (Script ${SCRIPT_VERSION})`, // 🌊 River
+           description: `Model injected by script ${SCRIPT_VERSION}`
+       },
+        // 可以在此按格式继续添加更多模型
+    ];
+      // ↑↑↑↑↑↑ 模型列表 EMOJIS 已更新 ↑↑↑↑↑↑
+     // ==========================================================
+
+    const LOG_PREFIX = `[AI Studio Injector ${SCRIPT_VERSION}]:`;
+    const ANTI_HIJACK_PREFIX = ")]}'\n";
+
+    // --- 关键索引定义 (基于您的JSON结构) ---
+     const NAME_IDX = 0;
+     const DISPLAY_NAME_IDX = 3;
+     const DESC_IDX = 4;
+     const METHODS_IDX = 7;
+    // ------------------------------------
+
+    console.log(LOG_PREFIX, 'Script active. Patching Fetch and XHR...');
+
+    function isTargetURL(url) {
+       return url && typeof url === 'string' && url.includes('alkalimakersuite') && url.includes('/ListModels');
+    }
+
+    // 递归查找包含模型数组的数组: 寻找 `[ [model1_array], [model2_array], ... ]`
+    function findModelListArray(obj) {
+      if (!obj) return null;
+       // 检查 obj 是否是我们寻找的那个包含多个模型数组的数组
+      if (Array.isArray(obj) && obj.length > 0 && obj.every(
+          item => Array.isArray(item) && typeof item[NAME_IDX] === 'string' && String(item[NAME_IDX]).startsWith('models/')
+      )) {
+        // console.log(LOG_PREFIX, "Target model list array FOUND."); // Reduce log noise
+         return obj;
+      }
+       // 递归搜索
+      if (typeof obj === 'object') {
+          for (const key in obj) {
+             if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                if(typeof obj[key] === 'object' && obj[key] !== null){ // check not null
+                   const result = findModelListArray(obj[key]);
+                   if (result) return result;
+                }
+             }
+          }
+      }
+      return null;
+    }
+
+
+    // 核心：处理并修改 JSON 数据 - 使用索引访问，遍历多个模型
+    function processJsonData(jsonData, url) {
+         let modificationMade = false;
+         const modelsArray = findModelListArray(jsonData); // [ [模型1数组], [模型2数组], ...]
+
+         if(modelsArray && Array.isArray(modelsArray)){
+           // console.log(LOG_PREFIX, 'Processing models array (length:', modelsArray.length, ") for URL:", url); // Reduce log noise
+
+             // *** 只寻找一次模板 ***
+             const templateModel = modelsArray.find(m => Array.isArray(m) && m[NAME_IDX] && String(m[NAME_IDX]).includes('flash') && Array.isArray(m[METHODS_IDX]) )
+                                     || modelsArray.find(m => Array.isArray(m) && m[NAME_IDX] && String(m[NAME_IDX]).includes('pro') && Array.isArray(m[METHODS_IDX]) )
+                                     || modelsArray.find(m => Array.isArray(m) && m[NAME_IDX] && Array.isArray(m[METHODS_IDX]) ); // 找第一个有方法的
+
+             const templateName = (templateModel && templateModel[NAME_IDX]) ? templateModel[NAME_IDX] : 'unknown';
+              if(templateModel){
+                 // console.log(LOG_PREFIX, `Using template: ${templateName}`); // Reduce log noise
+              } else {
+                   console.warn(LOG_PREFIX, 'Could not find a suitable template model array. Cannot inject new models, but can update existing ones.');
+              }
+
+             // *** 遍历所有需要注入的模型 ***
+             // 使用 reverse, 使得 MODELS_TO_INJECT 数组中的顺序和最终显示在顶部的顺序一致
+             [...MODELS_TO_INJECT].reverse().forEach(modelToInject => {
+                  const modelExists = modelsArray.some(model => Array.isArray(model) && model[NAME_IDX] === modelToInject.name);
+
+                   if (!modelExists) {
+                        if(!templateModel) {
+                           console.warn(LOG_PREFIX, `Cannot inject ${modelToInject.name}: No template found.`);
+                           return; // Skip this model if no template
+                        }
+                         // ！！！关键: 必须深拷贝数组！！！
+                         const newModel = JSON.parse(JSON.stringify(templateModel)); // Deep Clone from template
+
+                         // ！！！关键: 使用索引修改 ！！！
+                         newModel[NAME_IDX] = modelToInject.name;
+                         newModel[DISPLAY_NAME_IDX] = modelToInject.displayName;
+                         newModel[DESC_IDX] = `${modelToInject.description} (Structure based on ${templateName})`;
+                          if(!Array.isArray(newModel[METHODS_IDX])){
+                             newModel[METHODS_IDX] = ["generateContent", "countTokens","createCachedContent","batchGenerateContent"];
+                          }
+                         modelsArray.unshift(newModel); // 添加到开头
+                         modificationMade = true;
+                         console.log(LOG_PREFIX, `Successfully INJECTED: ${modelToInject.displayName}`);
+
+                   } else {
+                      // console.log(LOG_PREFIX, `Model ALREADY EXISTS: ${modelToInject.name}. Checking displayName.`); // Reduce log noise
+                       const existing = modelsArray.find(model => Array.isArray(model) && model[NAME_IDX] === modelToInject.name);
+                        // 如果存在，但名字不是脚本设定的名字，且不包含当前版本号，则更新名字
+                        // 如果模型已存在，且名字就是我们设定的（例如刷新页面），我们也更新一下，确保emoji和版本号是最新的
+                         if(existing && existing[DISPLAY_NAME_IDX] !== modelToInject.displayName) {
+                            // 检查是否只是版本号或emoji不同
+                            const baseExistingName = String(existing[DISPLAY_NAME_IDX]).replace(/ \(Script v\d+\.\d+(-beta\d*)?\)/, '').replace(/^[👑✨🦁💧❄️🌊]\s*/,'').trim();
+                            const baseInjectName = modelToInject.displayName.replace(/ \(Script v\d+\.\d+(-beta\d*)?\)/, '').replace(/^[👑✨🦁💧❄️🌊]\s*/,'').trim();
+
+                             if (baseExistingName === baseInjectName) {
+                                  // 基础名字相同，只更新emoji和版本号
+                                  existing[DISPLAY_NAME_IDX] = modelToInject.displayName;
+                                  console.log(LOG_PREFIX, `Updated Emoji/Version for ${modelToInject.displayName}.`);
+                             } else {
+                                 // 基础名字不同，说明是官方自带的或其他来源，加上 (Orig)
+                                  existing[DISPLAY_NAME_IDX] = modelToInject.displayName + " (Orig)";
+                                  console.log(LOG_PREFIX, `Updated displayName for existing official ${modelToInject.name} to (Orig).`);
+                             }
+                             modificationMade = true;
+                        }
+                   }
+             }); // End forEach
+
+       } else {
+            console.warn(LOG_PREFIX, 'URL matched, but no valid model list array structure found in JSON for:', url);
+       }
+       return { data: jsonData, modified: modificationMade };
+    }
+
+     // 统一处理响应体文本 (解析, 处理, 序列化)
+    function modifyResponseBody(originalText, url) {
+         if (!originalText || typeof originalText !== 'string') return originalText; // Add type check
+          try {
+             let textBody = originalText;
+             let hasPrefix = false;
+             if (textBody.startsWith(ANTI_HIJACK_PREFIX)) {
+                 textBody = textBody.substring(ANTI_HIJACK_PREFIX.length);
+                 hasPrefix = true;
+             }
+             if(!textBody.trim()) return originalText;
+             const jsonData = JSON.parse(textBody);
+             const result = processJsonData(jsonData, url);
+             if (result.modified) {
+                 let newBody = JSON.stringify(result.data);
+                 if(hasPrefix){
+                    newBody = ANTI_HIJACK_PREFIX + newBody;
+                 }
+                // console.log(LOG_PREFIX, "Returning MODIFIED response body."); // Reduce log noise
+                 return newBody;
+             }
+         } catch (error) {
+             console.error(LOG_PREFIX, 'Error processing response body for:', url, error, "\nOriginal Text snippet:", String(originalText).substring(0, 300) + "...");
+         }
+          // console.log(LOG_PREFIX, "Returning ORIGINAL response body (no modification or error)."); // Reduce log noise
+         return originalText;
+     }
+
+    //==================================
+    // 拦截 Fetch (保留)
+    //==================================
+    const originalFetch = window.fetch;
+    window.fetch = async function(...args) {
+       const resource = args[0];
+       const url = (resource instanceof Request) ? resource.url : String(resource);
+       const response = await originalFetch.apply(this, args);
+        if (isTargetURL(url) && response.ok) {
+           console.log(LOG_PREFIX, '[Fetch] Intercepting:', url);
+            try {
+                 const cloneResponse = response.clone();
+                 const originalText = await cloneResponse.text();
+                 const newBody = modifyResponseBody(originalText, url);
+                  if(newBody !== originalText){
+                    return new Response(newBody, { status: response.status, statusText: response.statusText, headers: response.headers });
+                 }
+            } catch(e) { console.error(LOG_PREFIX, '[Fetch] Error:', e); }
+       }
+       return response;
+    };
+     console.log(LOG_PREFIX, 'Fetch patch applied.');
+
+    //==================================
+    // 拦截 XMLHttpRequest (XHR)
+    //==================================
+     const xhrProto = XMLHttpRequest.prototype;
+     const originalOpen = xhrProto.open;
+     const originalResponseTextDescriptor = Object.getOwnPropertyDescriptor(xhrProto, 'responseText');
+     const originalResponseDescriptor = Object.getOwnPropertyDescriptor(xhrProto, 'response');
+     let interceptionCount = 0;
+
+     xhrProto.open = function(method, url) {
+         this._interceptorUrl = url;
+         this._isTargetXHR = isTargetURL(url);
+          if(this._isTargetXHR){
+              interceptionCount++;
+               console.log(LOG_PREFIX, `[XHR] Open detected (${interceptionCount}) for:`, url);
+          }
+         return originalOpen.apply(this, arguments);
+     };
+
+      const handleXHRResponse = (xhr, originalValue, type = 'text') => {
+           if (xhr._isTargetXHR && xhr.readyState === 4 && xhr.status === 200) {
+                const cacheKey = '_modifiedResponseCache_' + type;
+                 if(xhr[cacheKey] === undefined){
+                   // console.log(LOG_PREFIX, `[XHR] Processing response[${type}] for:`, xhr._interceptorUrl); // Reduce log noise
+                     const originalText = (type === 'text' || typeof originalValue !== 'object' || originalValue === null) ? String(originalValue || '') : JSON.stringify(originalValue) ;
+                      // Cache the result of modifyResponseBody
+                      xhr[cacheKey] = modifyResponseBody(originalText, xhr._interceptorUrl);
+                 }
+                 // Use the cached result
+                 const cachedResponse = xhr[cacheKey];
+                try{
+                   // 如果是对象类型,且缓存的是字符串，返回时需要反序列化
+                   if (type === 'json' && typeof cachedResponse === 'string') {
+                      // Ensure the string is not empty before parsing
+                      const textToParse = cachedResponse.replace(ANTI_HIJACK_PREFIX,'');
+                       if (textToParse) {
+                         return JSON.parse(textToParse);
+                       }
+                       return null; // or originalValue if parsing empty string is an issue
+                   }
+                 } catch(e){
+                     console.error(LOG_PREFIX, `[XHR] Error parsing cached JSON for type 'json': `, e, `Cache content: ${String(cachedResponse).substring(0,100)}...`);
+                    return originalValue; // fallback
+                 }
+                 return cachedResponse; // text type or already object or empty string
+           }
+            return originalValue;
+      };
+
+
+      if(originalResponseTextDescriptor && originalResponseTextDescriptor.get) {
+          Object.defineProperty(xhrProto, 'responseText', {
+              get: function() {
+                   const originalText = originalResponseTextDescriptor.get.call(this);
+                    // Only handle if responseType is text or default ""
+                   if (this.responseType && this.responseType !== 'text' && this.responseType !== "") return originalText;
+                   return handleXHRResponse(this, originalText, 'text');
+              }, configurable: true
+          });
+           console.log(LOG_PREFIX, 'XHR responseText patch applied.');
+      } else { console.error(LOG_PREFIX, 'XHR: Failed to get original responseText descriptor!'); }
+
+       if(originalResponseDescriptor && originalResponseDescriptor.get) {
+            Object.defineProperty(xhrProto, 'response', {
+               get: function() {
+                   const originalResponse = originalResponseDescriptor.get.call(this);
+                    if (this.responseType === 'json') {
+                         return handleXHRResponse(this, originalResponse, 'json');
+                    }
+                    // When responseType is "" or "text", originalResponse is the text itself
+                     if (!this.responseType || this.responseType === 'text' || this.responseType === "") {
+                          return handleXHRResponse(this, originalResponse, 'text');
+                     }
+                   return originalResponse; // other types like blob, arraybuffer
+               }, configurable: true
+           });
+            console.log(LOG_PREFIX, 'XHR response patch applied.');
+       } else {
+            console.error(LOG_PREFIX, 'XHR: Failed to get original response descriptor!');
+       }
+      console.log(LOG_PREFIX, 'XHR open patch applied.');
+
+})();

browser_utils/operations.py

@@ -0,0 +1,773 @@
+# --- browser_utils/operations.py ---
+# 浏览器页面操作相关功能模块
+
+import asyncio
+import time
+import json
+import os
+import re
+import logging
+from typing import Optional, Any, List, Dict, Callable, Set
+
+from playwright.async_api import Page as AsyncPage, Locator, Error as PlaywrightAsyncError
+
+# 导入配置和模型
+from config import *
+from models import ClientDisconnectedError
+
+logger = logging.getLogger("AIStudioProxyServer")
+
+async def get_raw_text_content(response_element: Locator, previous_text: str, req_id: str) -> str:
+    """从响应元素获取原始文本内容"""
+    raw_text = previous_text
+    try:
+        await response_element.wait_for(state='attached', timeout=1000)
+        pre_element = response_element.locator('pre').last
+        pre_found_and_visible = False
+        try:
+            await pre_element.wait_for(state='visible', timeout=250)
+            pre_found_and_visible = True
+        except PlaywrightAsyncError: 
+            pass
+        
+        if pre_found_and_visible:
+            try:
+                raw_text = await pre_element.inner_text(timeout=500)
+            except PlaywrightAsyncError as pre_err:
+                if DEBUG_LOGS_ENABLED:
+                    logger.debug(f"[{req_id}] (获取原始文本) 获取 pre 元素内部文本失败: {pre_err}")
+        else:
+            try:
+                raw_text = await response_element.inner_text(timeout=500)
+            except PlaywrightAsyncError as e_parent:
+                if DEBUG_LOGS_ENABLED:
+                    logger.debug(f"[{req_id}] (获取原始文本) 获取响应元素内部文本失败: {e_parent}")
+    except PlaywrightAsyncError as e_parent:
+        if DEBUG_LOGS_ENABLED:
+            logger.debug(f"[{req_id}] (获取原始文本) 响应元素未准备好: {e_parent}")
+    except Exception as e_unexpected:
+        logger.warning(f"[{req_id}] (获取原始文本) 意外错误: {e_unexpected}")
+    
+    if raw_text != previous_text:
+        if DEBUG_LOGS_ENABLED:
+            preview = raw_text[:100].replace('\n', '\\n')
+            logger.debug(f"[{req_id}] (获取原始文本) 文本已更新，长度: {len(raw_text)}，预览: '{preview}...'")
+    return raw_text
+
+def _parse_userscript_models(script_content: str):
+    """从油猴脚本中解析模型列表 - 使用JSON解析方式"""
+    try:
+        # 查找脚本版本号
+        version_pattern = r'const\s+SCRIPT_VERSION\s*=\s*[\'"]([^\'"]+)[\'"]'
+        version_match = re.search(version_pattern, script_content)
+        script_version = version_match.group(1) if version_match else "v1.6"
+
+        # 查找 MODELS_TO_INJECT 数组的内容
+        models_array_pattern = r'const\s+MODELS_TO_INJECT\s*=\s*(\[.*?\]);'
+        models_match = re.search(models_array_pattern, script_content, re.DOTALL)
+
+        if not models_match:
+            logger.warning("未找到 MODELS_TO_INJECT 数组")
+            return []
+
+        models_js_code = models_match.group(1)
+
+        # 将JavaScript数组转换为JSON格式
+        # 1. 替换模板字符串中的变量
+        models_js_code = models_js_code.replace('${SCRIPT_VERSION}', script_version)
+
+        # 2. 移除JavaScript注释
+        models_js_code = re.sub(r'//.*?$', '', models_js_code, flags=re.MULTILINE)
+
+        # 3. 将JavaScript对象转换为JSON格式
+        # 移除尾随逗号
+        models_js_code = re.sub(r',\s*([}\]])', r'\1', models_js_code)
+
+        # 替换单引号为双引号
+        models_js_code = re.sub(r"(\w+):\s*'([^']*)'", r'"\1": "\2"', models_js_code)
+        # 替换反引号为双引号
+        models_js_code = re.sub(r'(\w+):\s*`([^`]*)`', r'"\1": "\2"', models_js_code)
+        # 确保属性名用双引号
+        models_js_code = re.sub(r'(\w+):', r'"\1":', models_js_code)
+
+        # 4. 解析JSON
+        import json
+        models_data = json.loads(models_js_code)
+
+        models = []
+        for model_obj in models_data:
+            if isinstance(model_obj, dict) and 'name' in model_obj:
+                models.append({
+                    'name': model_obj.get('name', ''),
+                    'displayName': model_obj.get('displayName', ''),
+                    'description': model_obj.get('description', '')
+                })
+
+        logger.info(f"成功解析 {len(models)} 个模型从油猴脚本")
+        return models
+
+    except Exception as e:
+        logger.error(f"解析油猴脚本模型列表失败: {e}")
+        return []
+
+
+def _get_injected_models():
+    """从油猴脚本中获取注入的模型列表，转换为API格式"""
+    try:
+        # 直接读取环境变量，避免复杂的导入
+        enable_injection = os.environ.get('ENABLE_SCRIPT_INJECTION', 'true').lower() in ('true', '1', 'yes')
+
+        if not enable_injection:
+            return []
+
+        # 获取脚本文件路径
+        script_path = os.environ.get('USERSCRIPT_PATH', 'browser_utils/more_modles.js')
+
+        # 检查脚本文件是否存在
+        if not os.path.exists(script_path):
+            # 脚本文件不存在，静默返回空列表
+            return []
+
+        # 读取油猴脚本内容
+        with open(script_path, 'r', encoding='utf-8') as f:
+            script_content = f.read()
+
+        # 从脚本中解析模型列表
+        models = _parse_userscript_models(script_content)
+
+        if not models:
+            return []
+
+        # 转换为API格式
+        injected_models = []
+        for model in models:
+            model_name = model.get('name', '')
+            if not model_name:
+                continue  # 跳过没有名称的模型
+
+            if model_name.startswith('models/'):
+                simple_id = model_name[7:]  # 移除 'models/' 前缀
+            else:
+                simple_id = model_name
+
+            display_name = model.get('displayName', model.get('display_name', simple_id))
+            description = model.get('description', f'Injected model: {simple_id}')
+
+            # 注意：不再清理显示名称，保留原始的emoji和版本信息
+
+            model_entry = {
+                "id": simple_id,
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "ai_studio_injected",
+                "display_name": display_name,
+                "description": description,
+                "raw_model_path": model_name,
+                "default_temperature": 1.0,
+                "default_max_output_tokens": 65536,
+                "supported_max_output_tokens": 65536,
+                "default_top_p": 0.95,
+                "injected": True  # 标记为注入的模型
+            }
+            injected_models.append(model_entry)
+
+        return injected_models
+
+    except Exception as e:
+        # 静默处理错误，不输出日志，返回空列表
+        return []
+
+
+async def _handle_model_list_response(response: Any):
+    """处理模型列表响应"""
+    # 需要访问全局变量
+    import server
+    global_model_list_raw_json = getattr(server, 'global_model_list_raw_json', None)
+    parsed_model_list = getattr(server, 'parsed_model_list', [])
+    model_list_fetch_event = getattr(server, 'model_list_fetch_event', None)
+    excluded_model_ids = getattr(server, 'excluded_model_ids', set())
+    
+    if MODELS_ENDPOINT_URL_CONTAINS in response.url and response.ok:
+        # 检查是否在登录流程中
+        launch_mode = os.environ.get('LAUNCH_MODE', 'debug')
+        is_in_login_flow = launch_mode in ['debug'] and not getattr(server, 'is_page_ready', False)
+
+        if is_in_login_flow:
+            # 在登录流程中，静默处理，不输出干扰信息
+            pass  # 静默处理，避免干扰用户输入
+        else:
+            logger.info(f"捕获到潜在的模型列表响应来自: {response.url} (状态: {response.status})")
+        try:
+            data = await response.json()
+            models_array_container = None
+            if isinstance(data, list) and data:
+                if isinstance(data[0], list) and data[0] and isinstance(data[0][0], list):
+                    if not is_in_login_flow:
+                        logger.info("检测到三层列表结构 data[0][0] is list. models_array_container 设置为 data[0]。")
+                    models_array_container = data[0]
+                elif isinstance(data[0], list) and data[0] and isinstance(data[0][0], str):
+                    if not is_in_login_flow:
+                        logger.info("检测到两层列表结构 data[0][0] is str. models_array_container 设置为 data。")
+                    models_array_container = data
+                elif isinstance(data[0], dict):
+                    if not is_in_login_flow:
+                        logger.info("检测到根列表，元素为字典。直接使用 data 作为 models_array_container。")
+                    models_array_container = data
+                else:
+                    logger.warning(f"未知的列表嵌套结构。data[0] 类型: {type(data[0]) if data else 'N/A'}。data[0] 预览: {str(data[0])[:200] if data else 'N/A'}")
+            elif isinstance(data, dict):
+                if 'data' in data and isinstance(data['data'], list):
+                    models_array_container = data['data']
+                elif 'models' in data and isinstance(data['models'], list):
+                    models_array_container = data['models']
+                else:
+                    for key, value in data.items():
+                        if isinstance(value, list) and len(value) > 0 and isinstance(value[0], (dict, list)):
+                            models_array_container = value
+                            logger.info(f"模型列表数据在 '{key}' 键下通过启发式搜索找到。")
+                            break
+                    if models_array_container is None:
+                        logger.warning("在字典响应中未能自动定位模型列表数组。")
+                        if model_list_fetch_event and not model_list_fetch_event.is_set(): 
+                            model_list_fetch_event.set()
+                        return
+            else:
+                logger.warning(f"接收到的模型列表数据既不是列表也不是字典: {type(data)}")
+                if model_list_fetch_event and not model_list_fetch_event.is_set(): 
+                    model_list_fetch_event.set()
+                return
+            
+            if models_array_container is not None:
+                new_parsed_list = []
+                for entry_in_container in models_array_container:
+                    model_fields_list = None
+                    if isinstance(entry_in_container, dict):
+                        potential_id = entry_in_container.get('id', entry_in_container.get('model_id', entry_in_container.get('modelId')))
+                        if potential_id: 
+                            model_fields_list = entry_in_container
+                        else: 
+                            model_fields_list = list(entry_in_container.values())
+                    elif isinstance(entry_in_container, list):
+                        model_fields_list = entry_in_container
+                    else:
+                        logger.debug(f"Skipping entry of unknown type: {type(entry_in_container)}")
+                        continue
+                    
+                    if not model_fields_list:
+                        logger.debug("Skipping entry because model_fields_list is empty or None.")
+                        continue
+                    
+                    model_id_path_str = None
+                    display_name_candidate = ""
+                    description_candidate = "N/A"
+                    default_max_output_tokens_val = None
+                    default_top_p_val = None
+                    default_temperature_val = 1.0
+                    supported_max_output_tokens_val = None
+                    current_model_id_for_log = "UnknownModelYet"
+                    
+                    try:
+                        if isinstance(model_fields_list, list):
+                            if not (len(model_fields_list) > 0 and isinstance(model_fields_list[0], (str, int, float))):
+                                logger.debug(f"Skipping list-based model_fields due to invalid first element: {str(model_fields_list)[:100]}")
+                                continue
+                            model_id_path_str = str(model_fields_list[0])
+                            current_model_id_for_log = model_id_path_str.split('/')[-1] if model_id_path_str and '/' in model_id_path_str else model_id_path_str
+                            display_name_candidate = str(model_fields_list[3]) if len(model_fields_list) > 3 else ""
+                            description_candidate = str(model_fields_list[4]) if len(model_fields_list) > 4 else "N/A"
+                            
+                            if len(model_fields_list) > 6 and model_fields_list[6] is not None:
+                                try:
+                                    val_int = int(model_fields_list[6])
+                                    default_max_output_tokens_val = val_int
+                                    supported_max_output_tokens_val = val_int
+                                except (ValueError, TypeError):
+                                    logger.warning(f"模型 {current_model_id_for_log}: 无法将列表索引6的值 '{model_fields_list[6]}' 解析为 max_output_tokens。")
+                            
+                            if len(model_fields_list) > 9 and model_fields_list[9] is not None:
+                                try:
+                                    raw_top_p = float(model_fields_list[9])
+                                    if not (0.0 <= raw_top_p <= 1.0):
+                                        logger.warning(f"模型 {current_model_id_for_log}: 原始 top_p值 {raw_top_p} (来自列表索引9) 超出 [0,1] 范围，将裁剪。")
+                                        default_top_p_val = max(0.0, min(1.0, raw_top_p))
+                                    else:
+                                        default_top_p_val = raw_top_p
+                                except (ValueError, TypeError):
+                                    logger.warning(f"模型 {current_model_id_for_log}: 无法将列表索引9的值 '{model_fields_list[9]}' 解析为 top_p。")
+                                    
+                        elif isinstance(model_fields_list, dict):
+                            model_id_path_str = str(model_fields_list.get('id', model_fields_list.get('model_id', model_fields_list.get('modelId'))))
+                            current_model_id_for_log = model_id_path_str.split('/')[-1] if model_id_path_str and '/' in model_id_path_str else model_id_path_str
+                            display_name_candidate = str(model_fields_list.get('displayName', model_fields_list.get('display_name', model_fields_list.get('name', ''))))
+                            description_candidate = str(model_fields_list.get('description', "N/A"))
+                            
+                            mot_parsed = model_fields_list.get('maxOutputTokens', model_fields_list.get('defaultMaxOutputTokens', model_fields_list.get('outputTokenLimit')))
+                            if mot_parsed is not None:
+                                try:
+                                    val_int = int(mot_parsed)
+                                    default_max_output_tokens_val = val_int
+                                    supported_max_output_tokens_val = val_int
+                                except (ValueError, TypeError):
+                                     logger.warning(f"模型 {current_model_id_for_log}: 无法将字典值 '{mot_parsed}' 解析为 max_output_tokens。")
+                            
+                            top_p_parsed = model_fields_list.get('topP', model_fields_list.get('defaultTopP'))
+                            if top_p_parsed is not None:
+                                try:
+                                    raw_top_p = float(top_p_parsed)
+                                    if not (0.0 <= raw_top_p <= 1.0):
+                                        logger.warning(f"模型 {current_model_id_for_log}: 原始 top_p值 {raw_top_p} (来自字典) 超出 [0,1] 范围，将裁剪。")
+                                        default_top_p_val = max(0.0, min(1.0, raw_top_p))
+                                    else:
+                                        default_top_p_val = raw_top_p
+                                except (ValueError, TypeError):
+                                    logger.warning(f"模型 {current_model_id_for_log}: 无法将字典值 '{top_p_parsed}' 解析为 top_p。")
+                            
+                            temp_parsed = model_fields_list.get('temperature', model_fields_list.get('defaultTemperature'))
+                            if temp_parsed is not None:
+                                try: 
+                                    default_temperature_val = float(temp_parsed)
+                                except (ValueError, TypeError):
+                                    logger.warning(f"模型 {current_model_id_for_log}: 无法将字典值 '{temp_parsed}' 解析为 temperature。")
+                        else:
+                            logger.debug(f"Skipping entry because model_fields_list is not list or dict: {type(model_fields_list)}")
+                            continue
+                    except Exception as e_parse_fields:
+                        logger.error(f"解析模型字段时出错 for entry {str(entry_in_container)[:100]}: {e_parse_fields}")
+                        continue
+                    
+                    if model_id_path_str and model_id_path_str.lower() != "none":
+                        simple_model_id_str = model_id_path_str.split('/')[-1] if '/' in model_id_path_str else model_id_path_str
+                        if simple_model_id_str in excluded_model_ids:
+                            if not is_in_login_flow:
+                                logger.info(f"模型 '{simple_model_id_str}' 在排除列表 excluded_model_ids 中，已跳过。")
+                            continue
+                        
+                        final_display_name_str = display_name_candidate if display_name_candidate else simple_model_id_str.replace("-", " ").title()
+                        model_entry_dict = {
+                            "id": simple_model_id_str, 
+                            "object": "model", 
+                            "created": int(time.time()),
+                            "owned_by": "ai_studio", 
+                            "display_name": final_display_name_str,
+                            "description": description_candidate, 
+                            "raw_model_path": model_id_path_str,
+                            "default_temperature": default_temperature_val,
+                            "default_max_output_tokens": default_max_output_tokens_val,
+                            "supported_max_output_tokens": supported_max_output_tokens_val,
+                            "default_top_p": default_top_p_val
+                        }
+                        new_parsed_list.append(model_entry_dict)
+                    else:
+                        logger.debug(f"Skipping entry due to invalid model_id_path: {model_id_path_str} from entry {str(entry_in_container)[:100]}")
+                
+                if new_parsed_list:
+                    # 尝试添加注入的模型到解析列表
+                    injected_models = _get_injected_models()
+                    if injected_models:
+                        new_parsed_list.extend(injected_models)
+                        if not is_in_login_flow:
+                            logger.info(f"添加了 {len(injected_models)} 个注入的模型到API模型列表")
+
+                    server.parsed_model_list = sorted(new_parsed_list, key=lambda m: m.get('display_name', '').lower())
+                    server.global_model_list_raw_json = json.dumps({"data": server.parsed_model_list, "object": "list"})
+                    if DEBUG_LOGS_ENABLED:
+                        log_output = f"成功解析和更新模型列表。总共解析模型数: {len(server.parsed_model_list)}.\n"
+                        for i, item in enumerate(server.parsed_model_list[:min(3, len(server.parsed_model_list))]):
+                            log_output += f"  Model {i+1}: ID={item.get('id')}, Name={item.get('display_name')}, Temp={item.get('default_temperature')}, MaxTokDef={item.get('default_max_output_tokens')}, MaxTokSup={item.get('supported_max_output_tokens')}, TopP={item.get('default_top_p')}\n"
+                        logger.info(log_output)
+                    if model_list_fetch_event and not model_list_fetch_event.is_set():
+                        model_list_fetch_event.set()
+                elif not server.parsed_model_list:
+                    logger.warning("解析后模型列表仍然为空。")
+                    if model_list_fetch_event and not model_list_fetch_event.is_set(): 
+                        model_list_fetch_event.set()
+            else:
+                logger.warning("models_array_container 为 None，无法解析模型列表。")
+                if model_list_fetch_event and not model_list_fetch_event.is_set(): 
+                    model_list_fetch_event.set()
+        except json.JSONDecodeError as json_err:
+            logger.error(f"解析模型列表JSON失败: {json_err}. 响应 (前500字): {await response.text()[:500]}")
+        except Exception as e_handle_list_resp:
+            logger.exception(f"处理模型列表响应时发生未知错误: {e_handle_list_resp}")
+        finally:
+            if model_list_fetch_event and not model_list_fetch_event.is_set():
+                logger.info("处理模型列表响应结束，强制设置 model_list_fetch_event。")
+                model_list_fetch_event.set()
+
+async def detect_and_extract_page_error(page: AsyncPage, req_id: str) -> Optional[str]:
+    """检测并提取页面错误"""
+    error_toast_locator = page.locator(ERROR_TOAST_SELECTOR).last
+    try:
+        await error_toast_locator.wait_for(state='visible', timeout=500)
+        message_locator = error_toast_locator.locator('span.content-text')
+        error_message = await message_locator.text_content(timeout=500)
+        if error_message:
+             logger.error(f"[{req_id}]    检测到并提取错误消息: {error_message}")
+             return error_message.strip()
+        else:
+             logger.warning(f"[{req_id}]    检测到错误提示框，但无法提取消息。")
+             return "检测到错误提示框，但无法提取特定消息。"
+    except PlaywrightAsyncError: 
+        return None
+    except Exception as e:
+        logger.warning(f"[{req_id}]    检查页面错误时出错: {e}")
+        return None
+
+async def save_error_snapshot(error_name: str = 'error'):
+    """保存错误快照"""
+    import server
+    name_parts = error_name.split('_')
+    req_id = name_parts[-1] if len(name_parts) > 1 and len(name_parts[-1]) == 7 else None
+    base_error_name = error_name if not req_id else '_'.join(name_parts[:-1])
+    log_prefix = f"[{req_id}]" if req_id else "[无请求ID]"
+    page_to_snapshot = server.page_instance
+    
+    if not server.browser_instance or not server.browser_instance.is_connected() or not page_to_snapshot or page_to_snapshot.is_closed():
+        logger.warning(f"{log_prefix} 无法保存快照 ({base_error_name})，浏览器/页面不可用。")
+        return
+    
+    logger.info(f"{log_prefix} 尝试保存错误快照 ({base_error_name})...")
+    timestamp = int(time.time() * 1000)
+    error_dir = os.path.join(os.path.dirname(__file__), '..', 'errors_py')
+    
+    try:
+        os.makedirs(error_dir, exist_ok=True)
+        filename_suffix = f"{req_id}_{timestamp}" if req_id else f"{timestamp}"
+        filename_base = f"{base_error_name}_{filename_suffix}"
+        screenshot_path = os.path.join(error_dir, f"{filename_base}.png")
+        html_path = os.path.join(error_dir, f"{filename_base}.html")
+        
+        try:
+            await page_to_snapshot.screenshot(path=screenshot_path, full_page=True, timeout=15000)
+            logger.info(f"{log_prefix}   快照已保存到: {screenshot_path}")
+        except Exception as ss_err:
+            logger.error(f"{log_prefix}   保存屏幕截图失败 ({base_error_name}): {ss_err}")
+        
+        try:
+            content = await page_to_snapshot.content()
+            f = None
+            try:
+                f = open(html_path, 'w', encoding='utf-8')
+                f.write(content)
+                logger.info(f"{log_prefix}   HTML 已保存到: {html_path}")
+            except Exception as write_err:
+                logger.error(f"{log_prefix}   保存 HTML 失败 ({base_error_name}): {write_err}")
+            finally:
+                if f:
+                    try:
+                        f.close()
+                        logger.debug(f"{log_prefix}   HTML 文件已正确关闭")
+                    except Exception as close_err:
+                        logger.error(f"{log_prefix}   关闭 HTML 文件时出错: {close_err}")
+        except Exception as html_err:
+            logger.error(f"{log_prefix}   获取页面内容失败 ({base_error_name}): {html_err}")
+    except Exception as dir_err:
+        logger.error(f"{log_prefix}   创建错误目录或保存快照时发生其他错误 ({base_error_name}): {dir_err}")
+
+async def get_response_via_edit_button(
+    page: AsyncPage,
+    req_id: str,
+    check_client_disconnected: Callable
+) -> Optional[str]:
+    """通过编辑按钮获取响应"""
+    logger.info(f"[{req_id}] (Helper) 尝试通过编辑按钮获取响应...")
+    last_message_container = page.locator('ms-chat-turn').last
+    edit_button = last_message_container.get_by_label("Edit")
+    finish_edit_button = last_message_container.get_by_label("Stop editing")
+    autosize_textarea_locator = last_message_container.locator('ms-autosize-textarea')
+    actual_textarea_locator = autosize_textarea_locator.locator('textarea')
+    
+    try:
+        logger.info(f"[{req_id}]   - 尝试悬停最后一条消息以显示 'Edit' 按钮...")
+        try:
+            # 对消息容器执行悬停操作
+            await last_message_container.hover(timeout=CLICK_TIMEOUT_MS / 2) # 使用一半的点击超时作为悬停超时
+            await asyncio.sleep(0.3) # 等待悬停效果生效
+            check_client_disconnected("编辑响应 - 悬停后: ")
+        except Exception as hover_err:
+            logger.warning(f"[{req_id}]   - (get_response_via_edit_button) 悬停最后一条消息失败 (忽略): {type(hover_err).__name__}")
+            # 即使悬停失败，也继续尝试后续操作，Playwright的expect_async可能会处理
+        
+        logger.info(f"[{req_id}]   - 定位并点击 'Edit' 按钮...")
+        try:
+            from playwright.async_api import expect as expect_async
+            await expect_async(edit_button).to_be_visible(timeout=CLICK_TIMEOUT_MS)
+            check_client_disconnected("编辑响应 - 'Edit' 按钮可见后: ")
+            await edit_button.click(timeout=CLICK_TIMEOUT_MS)
+            logger.info(f"[{req_id}]   - 'Edit' 按钮已点击。")
+        except Exception as edit_btn_err:
+            logger.error(f"[{req_id}]   - 'Edit' 按钮不可见或点击失败: {edit_btn_err}")
+            await save_error_snapshot(f"edit_response_edit_button_failed_{req_id}")
+            return None
+        
+        check_client_disconnected("编辑响应 - 点击 'Edit' 按钮后: ")
+        await asyncio.sleep(0.3)
+        check_client_disconnected("编辑响应 - 点击 'Edit' 按钮后延时后: ")
+        
+        logger.info(f"[{req_id}]   - 从文本区域获取内容...")
+        response_content = None
+        textarea_failed = False
+        
+        try:
+            await expect_async(autosize_textarea_locator).to_be_visible(timeout=CLICK_TIMEOUT_MS)
+            check_client_disconnected("编辑响应 - autosize-textarea 可见后: ")
+            
+            try:
+                data_value_content = await autosize_textarea_locator.get_attribute("data-value")
+                check_client_disconnected("编辑响应 - get_attribute data-value 后: ")
+                if data_value_content is not None:
+                    response_content = str(data_value_content)
+                    logger.info(f"[{req_id}]   - 从 data-value 获取内容成功。")
+            except Exception as data_val_err:
+                logger.warning(f"[{req_id}]   - 获取 data-value 失败: {data_val_err}")
+                check_client_disconnected("编辑响应 - get_attribute data-value 错误后: ")
+            
+            if response_content is None:
+                logger.info(f"[{req_id}]   - data-value 获取失败或为None，尝试从内部 textarea 获取 input_value...")
+                try:
+                    await expect_async(actual_textarea_locator).to_be_visible(timeout=CLICK_TIMEOUT_MS/2)
+                    input_val_content = await actual_textarea_locator.input_value(timeout=CLICK_TIMEOUT_MS/2)
+                    check_client_disconnected("编辑响应 - input_value 后: ")
+                    if input_val_content is not None:
+                        response_content = str(input_val_content)
+                        logger.info(f"[{req_id}]   - 从 input_value 获取内容成功。")
+                except Exception as input_val_err:
+                     logger.warning(f"[{req_id}]   - 获取 input_value 也失败: {input_val_err}")
+                     check_client_disconnected("编辑响应 - input_value 错误后: ")
+            
+            if response_content is not None:
+                response_content = response_content.strip()
+                content_preview = response_content[:100].replace('\\n', '\\\\n')
+                logger.info(f"[{req_id}]   - ✅ 最终获取内容 (长度={len(response_content)}): '{content_preview}...'")
+            else:
+                logger.warning(f"[{req_id}]   - 所有方法 (data-value, input_value) 内容获取均失败或返回 None。")
+                textarea_failed = True
+                
+        except Exception as textarea_err:
+            logger.error(f"[{req_id}]   - 定位或处理文本区域时失败: {textarea_err}")
+            textarea_failed = True
+            response_content = None
+            check_client_disconnected("编辑响应 - 获取文本区域错误后: ")
+        
+        if not textarea_failed:
+            logger.info(f"[{req_id}]   - 定位并点击 'Stop editing' 按钮...")
+            try:
+                await expect_async(finish_edit_button).to_be_visible(timeout=CLICK_TIMEOUT_MS)
+                check_client_disconnected("编辑响应 - 'Stop editing' 按钮可见后: ")
+                await finish_edit_button.click(timeout=CLICK_TIMEOUT_MS)
+                logger.info(f"[{req_id}]   - 'Stop editing' 按钮已点击。")
+            except Exception as finish_btn_err:
+                logger.warning(f"[{req_id}]   - 'Stop editing' 按钮不可见或点击失败: {finish_btn_err}")
+                await save_error_snapshot(f"edit_response_finish_button_failed_{req_id}")
+            check_client_disconnected("编辑响应 - 点击 'Stop editing' 后: ")
+            await asyncio.sleep(0.2)
+            check_client_disconnected("编辑响应 - 点击 'Stop editing' 后延时后: ")
+        else:
+             logger.info(f"[{req_id}]   - 跳过点击 'Stop editing' 按钮，因为文本区域读取失败。")
+        
+        return response_content
+        
+    except ClientDisconnectedError:
+        logger.info(f"[{req_id}] (Helper Edit) 客户端断开连接。")
+        raise
+    except Exception as e:
+        logger.exception(f"[{req_id}] 通过编辑按钮获取响应过程中发生意外错误")
+        await save_error_snapshot(f"edit_response_unexpected_error_{req_id}")
+        return None
+
+async def get_response_via_copy_button(
+    page: AsyncPage,
+    req_id: str,
+    check_client_disconnected: Callable
+) -> Optional[str]:
+    """通过复制按钮获取响应"""
+    logger.info(f"[{req_id}] (Helper) 尝试通过复制按钮获取响应...")
+    last_message_container = page.locator('ms-chat-turn').last
+    more_options_button = last_message_container.get_by_label("Open options")
+    copy_markdown_button = page.get_by_role("menuitem", name="Copy markdown")
+    
+    try:
+        logger.info(f"[{req_id}]   - 尝试悬停最后一条消息以显示选项...")
+        await last_message_container.hover(timeout=CLICK_TIMEOUT_MS)
+        check_client_disconnected("复制响应 - 悬停后: ")
+        await asyncio.sleep(0.5)
+        check_client_disconnected("复制响应 - 悬停后延时后: ")
+        logger.info(f"[{req_id}]   - 已悬停。")
+        
+        logger.info(f"[{req_id}]   - 定位并点击 '更多选项' 按钮...")
+        try:
+            from playwright.async_api import expect as expect_async
+            await expect_async(more_options_button).to_be_visible(timeout=CLICK_TIMEOUT_MS)
+            check_client_disconnected("复制响应 - 更多选项按钮可见后: ")
+            await more_options_button.click(timeout=CLICK_TIMEOUT_MS)
+            logger.info(f"[{req_id}]   - '更多选项' 已点击 (通过 get_by_label)。")
+        except Exception as more_opts_err:
+            logger.error(f"[{req_id}]   - '更多选项' 按钮 (通过 get_by_label) 不可见或点击失败: {more_opts_err}")
+            await save_error_snapshot(f"copy_response_more_options_failed_{req_id}")
+            return None
+        
+        check_client_disconnected("复制响应 - 点击更多选项后: ")
+        await asyncio.sleep(0.5)
+        check_client_disconnected("复制响应 - 点击更多选项后延时后: ")
+        
+        logger.info(f"[{req_id}]   - 定位并点击 '复制 Markdown' 按钮...")
+        copy_success = False
+        try:
+            await expect_async(copy_markdown_button).to_be_visible(timeout=CLICK_TIMEOUT_MS)
+            check_client_disconnected("复制响应 - 复制按钮可见后: ")
+            await copy_markdown_button.click(timeout=CLICK_TIMEOUT_MS, force=True)
+            copy_success = True
+            logger.info(f"[{req_id}]   - 已点击 '复制 Markdown' (通过 get_by_role)。")
+        except Exception as copy_err:
+            logger.error(f"[{req_id}]   - '复制 Markdown' 按钮 (通过 get_by_role) 点击失败: {copy_err}")
+            await save_error_snapshot(f"copy_response_copy_button_failed_{req_id}")
+            return None
+        
+        if not copy_success:
+             logger.error(f"[{req_id}]   - 未能点击 '复制 Markdown' 按钮。")
+             return None
+             
+        check_client_disconnected("复制响应 - 点击复制按钮后: ")
+        await asyncio.sleep(0.5)
+        check_client_disconnected("复制响应 - 点击复制按钮后延时后: ")
+        
+        logger.info(f"[{req_id}]   - 正在读取剪贴板内容...")
+        try:
+            clipboard_content = await page.evaluate('navigator.clipboard.readText()')
+            check_client_disconnected("复制响应 - 读取剪贴板后: ")
+            if clipboard_content:
+                content_preview = clipboard_content[:100].replace('\n', '\\\\n')
+                logger.info(f"[{req_id}]   - ✅ 成功获取剪贴板内容 (长度={len(clipboard_content)}): '{content_preview}...'")
+                return clipboard_content
+            else:
+                logger.error(f"[{req_id}]   - 剪贴板内容为空。")
+                return None
+        except Exception as clipboard_err:
+            if "clipboard-read" in str(clipboard_err):
+                 logger.error(f"[{req_id}]   - 读取剪贴板失败: 可能是权限问题。错误: {clipboard_err}")
+            else:
+                 logger.error(f"[{req_id}]   - 读取剪贴板失败: {clipboard_err}")
+            await save_error_snapshot(f"copy_response_clipboard_read_failed_{req_id}")
+            return None
+            
+    except ClientDisconnectedError:
+        logger.info(f"[{req_id}] (Helper Copy) 客户端断开连接。")
+        raise
+    except Exception as e:
+        logger.exception(f"[{req_id}] 复制响应过程中发生意外错误")
+        await save_error_snapshot(f"copy_response_unexpected_error_{req_id}")
+        return None
+
+async def _wait_for_response_completion(
+    page: AsyncPage,
+    prompt_textarea_locator: Locator,
+    submit_button_locator: Locator,
+    edit_button_locator: Locator,
+    req_id: str,
+    check_client_disconnected_func: Callable,
+    current_chat_id: Optional[str],
+    timeout_ms=RESPONSE_COMPLETION_TIMEOUT,
+    initial_wait_ms=INITIAL_WAIT_MS_BEFORE_POLLING
+) -> bool:
+    """等待响应完成"""
+    from playwright.async_api import TimeoutError
+    
+    logger.info(f"[{req_id}] (WaitV3) 开始等待响应完成... (超时: {timeout_ms}ms)")
+    await asyncio.sleep(initial_wait_ms / 1000) # Initial brief wait
+    
+    start_time = time.time()
+    wait_timeout_ms_short = 3000 # 3 seconds for individual element checks
+    
+    consecutive_empty_input_submit_disabled_count = 0
+    
+    while True:
+        try:
+            check_client_disconnected_func("等待响应完成 - 循环开始")
+        except ClientDisconnectedError:
+            logger.info(f"[{req_id}] (WaitV3) 客户端断开连接，中止等待。")
+            return False
+
+        current_time_elapsed_ms = (time.time() - start_time) * 1000
+        if current_time_elapsed_ms > timeout_ms:
+            logger.error(f"[{req_id}] (WaitV3) 等待响应完成超时 ({timeout_ms}ms)。")
+            await save_error_snapshot(f"wait_completion_v3_overall_timeout_{req_id}")
+            return False
+
+        try:
+            check_client_disconnected_func("等待响应完成 - 超时检查后")
+        except ClientDisconnectedError:
+            return False
+
+        # --- 主要条件: 输入框空 & 提交按钮禁用 ---
+        is_input_empty = await prompt_textarea_locator.input_value() == ""
+        is_submit_disabled = False
+        try:
+            is_submit_disabled = await submit_button_locator.is_disabled(timeout=wait_timeout_ms_short)
+        except TimeoutError:
+            logger.warning(f"[{req_id}] (WaitV3) 检查提交按钮是否禁用超时。为本次检查假定其未禁用。")
+        
+        try:
+            check_client_disconnected_func("等待响应完成 - 按钮状态检查后")
+        except ClientDisconnectedError:
+            return False
+
+        if is_input_empty and is_submit_disabled:
+            consecutive_empty_input_submit_disabled_count += 1
+            if DEBUG_LOGS_ENABLED:
+                logger.debug(f"[{req_id}] (WaitV3) 主要条件满足: 输入框空，提交按钮禁用 (计数: {consecutive_empty_input_submit_disabled_count})。")
+
+            # --- 最终确认: 编辑按钮可见 ---
+            try:
+                if await edit_button_locator.is_visible(timeout=wait_timeout_ms_short):
+                    logger.info(f"[{req_id}] (WaitV3) ✅ 响应完成: 输入框空，提交按钮禁用，编辑按钮可见。")
+                    return True # 明确完成
+            except TimeoutError:
+                if DEBUG_LOGS_ENABLED:
+                    logger.debug(f"[{req_id}] (WaitV3) 主要条件满足���，检查编辑按钮可见性超时。")
+            
+            try:
+                check_client_disconnected_func("等待响应完成 - 编辑按钮检查后")
+            except ClientDisconnectedError:
+                return False
+
+            # 启发式完成: 如果主要条件持续满足，但编辑按钮仍未出现
+            if consecutive_empty_input_submit_disabled_count >= 3: # 例如，大约 1.5秒 (3 * 0.5秒轮询)
+                logger.warning(f"[{req_id}] (WaitV3) 响应可能已完成 (启发式): 输入框空，提交按钮禁用，但在 {consecutive_empty_input_submit_disabled_count} 次检查后编辑按钮仍未出现。假定完成。后续若内容获取失败，可能与此有关。")
+                return True # 启发式完成
+        else: # 主要条件 (输入框空 & 提交按钮禁用) 未满足
+            consecutive_empty_input_submit_disabled_count = 0 # 重置计数器
+            if DEBUG_LOGS_ENABLED:
+                reasons = []
+                if not is_input_empty: 
+                    reasons.append("输入框非空")
+                if not is_submit_disabled: 
+                    reasons.append("提交按钮非禁用")
+                logger.debug(f"[{req_id}] (WaitV3) 主要条件未满足 ({', '.join(reasons)}). 继续轮询...")
+
+        await asyncio.sleep(0.5) # 轮询间隔
+
+async def _get_final_response_content(
+    page: AsyncPage,
+    req_id: str,
+    check_client_disconnected: Callable
+) -> Optional[str]:
+    """获取最终响应内容"""
+    logger.info(f"[{req_id}] (Helper GetContent) 开始获取最终响应内容...")
+    response_content = await get_response_via_edit_button(
+        page, req_id, check_client_disconnected
+    )
+    if response_content is not None:
+        logger.info(f"[{req_id}] (Helper GetContent) ✅ 成功通过编辑按钮获取内容。")
+        return response_content
+    
+    logger.warning(f"[{req_id}] (Helper GetContent) 编辑按钮方法失败或返回空，回退到复制按钮方法...")
+    response_content = await get_response_via_copy_button(
+        page, req_id, check_client_disconnected
+    )
+    if response_content is not None:
+        logger.info(f"[{req_id}] (Helper GetContent) ✅ 成功通过复制按钮获取内容。")
+        return response_content
+    
+    logger.error(f"[{req_id}] (Helper GetContent) 所有获取响应内容的方法均失败。")
+    await save_error_snapshot(f"get_content_all_methods_failed_{req_id}")
+    return None 

browser_utils/page_controller.py

@@ -0,0 +1,638 @@
+"""
+PageController模块
+封装了所有与Playwright页面直接交互的复杂逻辑。
+"""
+import asyncio
+from typing import Callable, List, Dict, Any
+
+from playwright.async_api import Page as AsyncPage, expect as expect_async, TimeoutError
+
+from config import (
+    TEMPERATURE_INPUT_SELECTOR, MAX_OUTPUT_TOKENS_SELECTOR, STOP_SEQUENCE_INPUT_SELECTOR,
+    MAT_CHIP_REMOVE_BUTTON_SELECTOR, TOP_P_INPUT_SELECTOR, SUBMIT_BUTTON_SELECTOR,
+    CLEAR_CHAT_BUTTON_SELECTOR, CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR, OVERLAY_SELECTOR,
+    PROMPT_TEXTAREA_SELECTOR, RESPONSE_CONTAINER_SELECTOR, RESPONSE_TEXT_SELECTOR,
+    EDIT_MESSAGE_BUTTON_SELECTOR
+)
+from config import (
+    CLICK_TIMEOUT_MS, WAIT_FOR_ELEMENT_TIMEOUT_MS, CLEAR_CHAT_VERIFY_TIMEOUT_MS,
+    DEFAULT_TEMPERATURE, DEFAULT_MAX_OUTPUT_TOKENS, DEFAULT_STOP_SEQUENCES, DEFAULT_TOP_P
+)
+from models import ClientDisconnectedError
+from .operations import save_error_snapshot, _wait_for_response_completion, _get_final_response_content
+
+class PageController:
+    """封装了与AI Studio页面交互的所有操作。"""
+
+    def __init__(self, page: AsyncPage, logger, req_id: str):
+        self.page = page
+        self.logger = logger
+        self.req_id = req_id
+
+    async def _check_disconnect(self, check_client_disconnected: Callable, stage: str):
+        """检查客户端是否断开连接。"""
+        if check_client_disconnected(stage):
+            raise ClientDisconnectedError(f"[{self.req_id}] Client disconnected at stage: {stage}")
+
+    async def adjust_parameters(self, request_params: Dict[str, Any], page_params_cache: Dict[str, Any], params_cache_lock: asyncio.Lock, model_id_to_use: str, parsed_model_list: List[Dict[str, Any]], check_client_disconnected: Callable):
+        """调整所有请求参数。"""
+        self.logger.info(f"[{self.req_id}] 开始调整所有请求参数...")
+        await self._check_disconnect(check_client_disconnected, "Start Parameter Adjustment")
+
+        # 调整温度
+        temp_to_set = request_params.get('temperature', DEFAULT_TEMPERATURE)
+        await self._adjust_temperature(temp_to_set, page_params_cache, params_cache_lock, check_client_disconnected)
+        await self._check_disconnect(check_client_disconnected, "After Temperature Adjustment")
+
+        # 调整最大Token
+        max_tokens_to_set = request_params.get('max_output_tokens', DEFAULT_MAX_OUTPUT_TOKENS)
+        await self._adjust_max_tokens(max_tokens_to_set, page_params_cache, params_cache_lock, model_id_to_use, parsed_model_list, check_client_disconnected)
+        await self._check_disconnect(check_client_disconnected, "After Max Tokens Adjustment")
+
+        # 调整停止序列
+        stop_to_set = request_params.get('stop', DEFAULT_STOP_SEQUENCES)
+        await self._adjust_stop_sequences(stop_to_set, page_params_cache, params_cache_lock, check_client_disconnected)
+        await self._check_disconnect(check_client_disconnected, "After Stop Sequences Adjustment")
+
+        # 调整Top P
+        top_p_to_set = request_params.get('top_p', DEFAULT_TOP_P)
+        await self._adjust_top_p(top_p_to_set, check_client_disconnected)
+        await self._check_disconnect(check_client_disconnected, "End Parameter Adjustment")
+
+
+    async def _adjust_temperature(self, temperature: float, page_params_cache: dict, params_cache_lock: asyncio.Lock, check_client_disconnected: Callable):
+        """调整温度参数。"""
+        async with params_cache_lock:
+            self.logger.info(f"[{self.req_id}] 检查并调整温度设置...")
+            clamped_temp = max(0.0, min(2.0, temperature))
+            if clamped_temp != temperature:
+                self.logger.warning(f"[{self.req_id}] 请求的温度 {temperature} 超出范围 [0, 2]，已调整为 {clamped_temp}")
+
+            cached_temp = page_params_cache.get("temperature")
+            if cached_temp is not None and abs(cached_temp - clamped_temp) < 0.001:
+                self.logger.info(f"[{self.req_id}] 温度 ({clamped_temp}) 与缓存值 ({cached_temp}) 一致。跳过页面交互。")
+                return
+
+            self.logger.info(f"[{self.req_id}] 请求温度 ({clamped_temp}) 与缓存值 ({cached_temp}) 不一致或缓存中无值。需要与页面交互。")
+            temp_input_locator = self.page.locator(TEMPERATURE_INPUT_SELECTOR)
+
+            try:
+                await expect_async(temp_input_locator).to_be_visible(timeout=5000)
+                await self._check_disconnect(check_client_disconnected, "温度调整 - 输入框可见后")
+
+                current_temp_str = await temp_input_locator.input_value(timeout=3000)
+                await self._check_disconnect(check_client_disconnected, "温度调整 - 读取输入框值后")
+
+                current_temp_float = float(current_temp_str)
+                self.logger.info(f"[{self.req_id}] 页面当前温度: {current_temp_float}, 请求调整后温度: {clamped_temp}")
+
+                if abs(current_temp_float - clamped_temp) < 0.001:
+                    self.logger.info(f"[{self.req_id}] 页面当前温度 ({current_temp_float}) 与请求温度 ({clamped_temp}) 一致。更新缓存并跳过写入。")
+                    page_params_cache["temperature"] = current_temp_float
+                else:
+                    self.logger.info(f"[{self.req_id}] 页面温度 ({current_temp_float}) 与请求温度 ({clamped_temp}) 不同，正在更新...")
+                    await temp_input_locator.fill(str(clamped_temp), timeout=5000)
+                    await self._check_disconnect(check_client_disconnected, "温度调整 - 填充输入框后")
+
+                    await asyncio.sleep(0.1)
+                    new_temp_str = await temp_input_locator.input_value(timeout=3000)
+                    new_temp_float = float(new_temp_str)
+
+                    if abs(new_temp_float - clamped_temp) < 0.001:
+                        self.logger.info(f"[{self.req_id}] ✅ 温度已成功更新为: {new_temp_float}。更新缓存。")
+                        page_params_cache["temperature"] = new_temp_float
+                    else:
+                        self.logger.warning(f"[{self.req_id}] ⚠️ 温度更新后验证失败。页面显示: {new_temp_float}, 期望: {clamped_temp}。清除缓存中的温度。")
+                        page_params_cache.pop("temperature", None)
+                        await save_error_snapshot(f"temperature_verify_fail_{self.req_id}")
+
+            except ValueError as ve:
+                self.logger.error(f"[{self.req_id}] 转换温度值为浮点数时出错. 错误: {ve}。清除缓存中的温度。")
+                page_params_cache.pop("temperature", None)
+                await save_error_snapshot(f"temperature_value_error_{self.req_id}")
+            except Exception as pw_err:
+                self.logger.error(f"[{self.req_id}] ❌ 操作温度输入框时发生错误: {pw_err}。清除缓存中的温度。")
+                page_params_cache.pop("temperature", None)
+                await save_error_snapshot(f"temperature_playwright_error_{self.req_id}")
+                if isinstance(pw_err, ClientDisconnectedError):
+                    raise
+
+    async def _adjust_max_tokens(self, max_tokens: int, page_params_cache: dict, params_cache_lock: asyncio.Lock, model_id_to_use: str, parsed_model_list: list, check_client_disconnected: Callable):
+        """调整最大输出Token参数。"""
+        async with params_cache_lock:
+            self.logger.info(f"[{self.req_id}] 检查并调整最大输出 Token 设置...")
+            min_val_for_tokens = 1
+            max_val_for_tokens_from_model = 65536
+
+            if model_id_to_use and parsed_model_list:
+                current_model_data = next((m for m in parsed_model_list if m.get("id") == model_id_to_use), None)
+                if current_model_data and current_model_data.get("supported_max_output_tokens") is not None:
+                    try:
+                        supported_tokens = int(current_model_data["supported_max_output_tokens"])
+                        if supported_tokens > 0:
+                            max_val_for_tokens_from_model = supported_tokens
+                        else:
+                            self.logger.warning(f"[{self.req_id}] 模型 {model_id_to_use} supported_max_output_tokens 无效: {supported_tokens}")
+                    except (ValueError, TypeError):
+                        self.logger.warning(f"[{self.req_id}] 模型 {model_id_to_use} supported_max_output_tokens 解析失败")
+
+            clamped_max_tokens = max(min_val_for_tokens, min(max_val_for_tokens_from_model, max_tokens))
+            if clamped_max_tokens != max_tokens:
+                self.logger.warning(f"[{self.req_id}] 请求的最大输出 Tokens {max_tokens} 超出模型范围，已调整为 {clamped_max_tokens}")
+
+            cached_max_tokens = page_params_cache.get("max_output_tokens")
+            if cached_max_tokens is not None and cached_max_tokens == clamped_max_tokens:
+                self.logger.info(f"[{self.req_id}] 最大输出 Tokens ({clamped_max_tokens}) 与缓存值一致。跳过页面交互。")
+                return
+
+            max_tokens_input_locator = self.page.locator(MAX_OUTPUT_TOKENS_SELECTOR)
+
+            try:
+                await expect_async(max_tokens_input_locator).to_be_visible(timeout=5000)
+                await self._check_disconnect(check_client_disconnected, "最大输出Token调整 - 输入框可见后")
+
+                current_max_tokens_str = await max_tokens_input_locator.input_value(timeout=3000)
+                current_max_tokens_int = int(current_max_tokens_str)
+
+                if current_max_tokens_int == clamped_max_tokens:
+                    self.logger.info(f"[{self.req_id}] 页面当前最大输出 Tokens ({current_max_tokens_int}) 与请求值 ({clamped_max_tokens}) 一致。更新缓存并跳过写入。")
+                    page_params_cache["max_output_tokens"] = current_max_tokens_int
+                else:
+                    self.logger.info(f"[{self.req_id}] 页面最大输出 Tokens ({current_max_tokens_int}) 与请求值 ({clamped_max_tokens}) 不同，正在更新...")
+                    await max_tokens_input_locator.fill(str(clamped_max_tokens), timeout=5000)
+                    await self._check_disconnect(check_client_disconnected, "最大输出Token调整 - 填充输入框后")
+
+                    await asyncio.sleep(0.1)
+                    new_max_tokens_str = await max_tokens_input_locator.input_value(timeout=3000)
+                    new_max_tokens_int = int(new_max_tokens_str)
+
+                    if new_max_tokens_int == clamped_max_tokens:
+                        self.logger.info(f"[{self.req_id}] ✅ 最大输出 Tokens 已成功更新为: {new_max_tokens_int}")
+                        page_params_cache["max_output_tokens"] = new_max_tokens_int
+                    else:
+                        self.logger.warning(f"[{self.req_id}] ⚠️ 最大输出 Tokens 更新后验证失败。页面显示: {new_max_tokens_int}, 期望: {clamped_max_tokens}。清除缓存。")
+                        page_params_cache.pop("max_output_tokens", None)
+                        await save_error_snapshot(f"max_tokens_verify_fail_{self.req_id}")
+
+            except (ValueError, TypeError) as ve:
+                self.logger.error(f"[{self.req_id}] 转换最大输出 Tokens 值时出错: {ve}。清除缓存。")
+                page_params_cache.pop("max_output_tokens", None)
+                await save_error_snapshot(f"max_tokens_value_error_{self.req_id}")
+            except Exception as e:
+                self.logger.error(f"[{self.req_id}] ❌ 调整最大输出 Tokens 时出错: {e}。清除缓存。")
+                page_params_cache.pop("max_output_tokens", None)
+                await save_error_snapshot(f"max_tokens_error_{self.req_id}")
+                if isinstance(e, ClientDisconnectedError):
+                    raise
+    
+    async def _adjust_stop_sequences(self, stop_sequences, page_params_cache: dict, params_cache_lock: asyncio.Lock, check_client_disconnected: Callable):
+        """调整停止序列参数。"""
+        async with params_cache_lock:
+            self.logger.info(f"[{self.req_id}] 检查并设置停止序列...")
+
+            # 处理不同类型的stop_sequences输入
+            normalized_requested_stops = set()
+            if stop_sequences is not None:
+                if isinstance(stop_sequences, str):
+                    # 单个字符串
+                    if stop_sequences.strip():
+                        normalized_requested_stops.add(stop_sequences.strip())
+                elif isinstance(stop_sequences, list):
+                    # 字符串列表
+                    for s in stop_sequences:
+                        if isinstance(s, str) and s.strip():
+                            normalized_requested_stops.add(s.strip())
+
+            cached_stops_set = page_params_cache.get("stop_sequences")
+
+            if cached_stops_set is not None and cached_stops_set == normalized_requested_stops:
+                self.logger.info(f"[{self.req_id}] 请求的停止序列与缓存值一致。跳过页面交互。")
+                return
+
+            stop_input_locator = self.page.locator(STOP_SEQUENCE_INPUT_SELECTOR)
+            remove_chip_buttons_locator = self.page.locator(MAT_CHIP_REMOVE_BUTTON_SELECTOR)
+
+            try:
+                # 清空已有的停止序列
+                initial_chip_count = await remove_chip_buttons_locator.count()
+                removed_count = 0
+                max_removals = initial_chip_count + 5
+
+                while await remove_chip_buttons_locator.count() > 0 and removed_count < max_removals:
+                    await self._check_disconnect(check_client_disconnected, "停止序列清除 - 循环开始")
+                    try:
+                        await remove_chip_buttons_locator.first.click(timeout=2000)
+                        removed_count += 1
+                        await asyncio.sleep(0.15)
+                    except Exception:
+                        break
+
+                # 添加新的停止序列
+                if normalized_requested_stops:
+                    await expect_async(stop_input_locator).to_be_visible(timeout=5000)
+                    for seq in normalized_requested_stops:
+                        await stop_input_locator.fill(seq, timeout=3000)
+                        await stop_input_locator.press("Enter", timeout=3000)
+                        await asyncio.sleep(0.2)
+
+                page_params_cache["stop_sequences"] = normalized_requested_stops
+                self.logger.info(f"[{self.req_id}] ✅ 停止序列已成功设置。缓存已更新。")
+
+            except Exception as e:
+                self.logger.error(f"[{self.req_id}] ❌ 设置停止序列时出错: {e}")
+                page_params_cache.pop("stop_sequences", None)
+                await save_error_snapshot(f"stop_sequence_error_{self.req_id}")
+                if isinstance(e, ClientDisconnectedError):
+                    raise
+
+    async def _adjust_top_p(self, top_p: float, check_client_disconnected: Callable):
+        """调整Top P参数。"""
+        self.logger.info(f"[{self.req_id}] 检查并调整 Top P 设置...")
+        clamped_top_p = max(0.0, min(1.0, top_p))
+
+        if abs(clamped_top_p - top_p) > 1e-9:
+            self.logger.warning(f"[{self.req_id}] 请求的 Top P {top_p} 超出范围 [0, 1]，已调整为 {clamped_top_p}")
+
+        top_p_input_locator = self.page.locator(TOP_P_INPUT_SELECTOR)
+        try:
+            await expect_async(top_p_input_locator).to_be_visible(timeout=5000)
+            await self._check_disconnect(check_client_disconnected, "Top P 调整 - 输入框可见后")
+
+            current_top_p_str = await top_p_input_locator.input_value(timeout=3000)
+            current_top_p_float = float(current_top_p_str)
+
+            if abs(current_top_p_float - clamped_top_p) > 1e-9:
+                self.logger.info(f"[{self.req_id}] 页面 Top P ({current_top_p_float}) 与请求值 ({clamped_top_p}) 不同，正在更新...")
+                await top_p_input_locator.fill(str(clamped_top_p), timeout=5000)
+                await self._check_disconnect(check_client_disconnected, "Top P 调整 - 填充输入框后")
+
+                # 验证设置是否成功
+                await asyncio.sleep(0.1)
+                new_top_p_str = await top_p_input_locator.input_value(timeout=3000)
+                new_top_p_float = float(new_top_p_str)
+
+                if abs(new_top_p_float - clamped_top_p) <= 1e-9:
+                    self.logger.info(f"[{self.req_id}] ✅ Top P 已成功更新为: {new_top_p_float}")
+                else:
+                    self.logger.warning(f"[{self.req_id}] ⚠️ Top P 更新后验证失败。页面显示: {new_top_p_float}, 期望: {clamped_top_p}")
+                    await save_error_snapshot(f"top_p_verify_fail_{self.req_id}")
+            else:
+                self.logger.info(f"[{self.req_id}] 页面 Top P ({current_top_p_float}) 与请求值 ({clamped_top_p}) 一致，无需更改")
+
+        except (ValueError, TypeError) as ve:
+            self.logger.error(f"[{self.req_id}] 转换 Top P 值时出错: {ve}")
+            await save_error_snapshot(f"top_p_value_error_{self.req_id}")
+        except Exception as e:
+            self.logger.error(f"[{self.req_id}] ❌ 调整 Top P 时出错: {e}")
+            await save_error_snapshot(f"top_p_error_{self.req_id}")
+            if isinstance(e, ClientDisconnectedError):
+                raise
+
+    async def clear_chat_history(self, check_client_disconnected: Callable):
+        """清空聊天记录。"""
+        self.logger.info(f"[{self.req_id}] 开始清空聊天记录...")
+        await self._check_disconnect(check_client_disconnected, "Start Clear Chat")
+
+        try:
+            # 一般是使用流式代理时遇到,流式输出已结束,但页面上AI仍回复个不停,此时会锁住清空按钮,但页面仍是/new_chat,而跳过后续清空操作
+            # 导致后续请求无法发出而卡住,故先检查并点击发送按钮(此时是停止功能)
+            submit_button_locator = self.page.locator(SUBMIT_BUTTON_SELECTOR)
+            try:
+                self.logger.info(f"[{self.req_id}] 尝试检查发送按钮状态...")
+                # 使用较短的超时时间（1秒），避免长时间阻塞，因为这不是清空流程的常见步骤
+                await expect_async(submit_button_locator).to_be_enabled(timeout=1000)
+                self.logger.info(f"[{self.req_id}] 发送按钮可用，尝试点击并等待1秒...")
+                await submit_button_locator.click(timeout=CLICK_TIMEOUT_MS)
+                await asyncio.sleep(1.0)
+                self.logger.info(f"[{self.req_id}] 发送按钮点击并等待完成。")
+            except Exception as e_submit:
+                # 如果发送按钮不可用、超时或发生Playwright相关错误，记录日志并继续
+                self.logger.info(f"[{self.req_id}] 发送按钮不可用或检查/点击时发生Playwright错误。符合预期,继续检查清空按钮。")
+
+            clear_chat_button_locator = self.page.locator(CLEAR_CHAT_BUTTON_SELECTOR)
+            confirm_button_locator = self.page.locator(CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR)
+            overlay_locator = self.page.locator(OVERLAY_SELECTOR)
+
+            can_attempt_clear = False
+            try:
+                await expect_async(clear_chat_button_locator).to_be_enabled(timeout=3000)
+                can_attempt_clear = True
+                self.logger.info(f"[{self.req_id}] \"清空聊天\"按钮可用，继续清空流程。")
+            except Exception as e_enable:
+                is_new_chat_url = '/prompts/new_chat' in self.page.url.rstrip('/')
+                if is_new_chat_url:
+                    self.logger.info(f"[{self.req_id}] \"清空聊天\"按钮不可用 (预期，因为在 new_chat 页面)。跳过清空操作。")
+                else:
+                    self.logger.warning(f"[{self.req_id}] 等待\"清空聊天\"按钮可用失败: {e_enable}。清空操作可能无法执行。")
+
+            await self._check_disconnect(check_client_disconnected, "清空聊天 - \"清空聊天\"按钮可用性检查后")
+
+            if can_attempt_clear:
+                await self._execute_chat_clear(clear_chat_button_locator, confirm_button_locator, overlay_locator, check_client_disconnected)
+                await self._verify_chat_cleared(check_client_disconnected)
+
+        except Exception as e_clear:
+            self.logger.error(f"[{self.req_id}] 清空聊天过程中发生错误: {e_clear}")
+            if not (isinstance(e_clear, ClientDisconnectedError) or (hasattr(e_clear, 'name') and 'Disconnect' in e_clear.name)):
+                await save_error_snapshot(f"clear_chat_error_{self.req_id}")
+            raise
+
+    async def _execute_chat_clear(self, clear_chat_button_locator, confirm_button_locator, overlay_locator, check_client_disconnected: Callable):
+        """执行清空聊天操作"""
+        overlay_initially_visible = False
+        try:
+            if await overlay_locator.is_visible(timeout=1000):
+                overlay_initially_visible = True
+                self.logger.info(f"[{self.req_id}] 清空聊天确认遮罩层已可见。直接点击\"继续\"。")
+        except TimeoutError:
+            self.logger.info(f"[{self.req_id}] 清空聊天确认遮罩层初始不可见 (检查超时或未找到)。")
+            overlay_initially_visible = False
+        except Exception as e_vis_check:
+            self.logger.warning(f"[{self.req_id}] 检查遮罩层可见性时发生错误: {e_vis_check}。假定不可见。")
+            overlay_initially_visible = False
+
+        await self._check_disconnect(check_client_disconnected, "清空聊天 - 初始遮罩层检查后")
+
+        if overlay_initially_visible:
+            self.logger.info(f"[{self.req_id}] 点击\"继续\"按钮 (遮罩层已存在): {CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR}")
+            await confirm_button_locator.click(timeout=CLICK_TIMEOUT_MS)
+        else:
+            self.logger.info(f"[{self.req_id}] 点击\"清空聊天\"按钮: {CLEAR_CHAT_BUTTON_SELECTOR}")
+            await clear_chat_button_locator.click(timeout=CLICK_TIMEOUT_MS)
+            await self._check_disconnect(check_client_disconnected, "清空聊天 - 点击\"清空聊天\"后")
+
+            try:
+                self.logger.info(f"[{self.req_id}] 等待清空聊天确认遮罩层出现: {OVERLAY_SELECTOR}")
+                await expect_async(overlay_locator).to_be_visible(timeout=WAIT_FOR_ELEMENT_TIMEOUT_MS)
+                self.logger.info(f"[{self.req_id}] 清空聊天确认遮罩层已出现。")
+            except TimeoutError:
+                error_msg = f"等待清空聊天确认遮罩层超时 (点击清空按钮后)。请求 ID: {self.req_id}"
+                self.logger.error(error_msg)
+                await save_error_snapshot(f"clear_chat_overlay_timeout_{self.req_id}")
+                raise Exception(error_msg)
+
+            await self._check_disconnect(check_client_disconnected, "清空聊天 - 遮罩层出现后")
+            self.logger.info(f"[{self.req_id}] 点击\"继续\"按钮 (在对话框中): {CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR}")
+            await confirm_button_locator.click(timeout=CLICK_TIMEOUT_MS)
+
+        await self._check_disconnect(check_client_disconnected, "清空聊天 - 点击\"继续\"后")
+
+        # 等待对话框消失
+        max_retries_disappear = 3
+        for attempt_disappear in range(max_retries_disappear):
+            try:
+                self.logger.info(f"[{self.req_id}] 等待清空聊天确认按钮/对话框消失 (尝试 {attempt_disappear + 1}/{max_retries_disappear})...")
+                await expect_async(confirm_button_locator).to_be_hidden(timeout=CLEAR_CHAT_VERIFY_TIMEOUT_MS)
+                await expect_async(overlay_locator).to_be_hidden(timeout=1000)
+                self.logger.info(f"[{self.req_id}] ✅ 清空聊天确认对话框已成功消失。")
+                break
+            except TimeoutError:
+                self.logger.warning(f"[{self.req_id}] ⚠️ 等待清空聊天确认对话框消失超时 (尝试 {attempt_disappear + 1}/{max_retries_disappear})。")
+                if attempt_disappear < max_retries_disappear - 1:
+                    await asyncio.sleep(1.0)
+                    await self._check_disconnect(check_client_disconnected, f"清空聊天 - 重试消失检查 {attempt_disappear + 1} 前")
+                    continue
+                else:
+                    error_msg = f"达到最大重试次数。清空聊天确认对话框未消失。请求 ID: {self.req_id}"
+                    self.logger.error(error_msg)
+                    await save_error_snapshot(f"clear_chat_dialog_disappear_timeout_{self.req_id}")
+                    raise Exception(error_msg)
+            except ClientDisconnectedError:
+                self.logger.info(f"[{self.req_id}] 客户端在等待清空确认对话框消失时断开连接。")
+                raise
+            except Exception as other_err:
+                self.logger.warning(f"[{self.req_id}] 等待清空确认对话框消失时发生其他错误: {other_err}")
+                if attempt_disappear < max_retries_disappear - 1:
+                    await asyncio.sleep(1.0)
+                    continue
+                else:
+                    raise
+
+            await self._check_disconnect(check_client_disconnected, f"清空聊天 - 消失检查尝试 {attempt_disappear + 1} 后")
+
+    async def _verify_chat_cleared(self, check_client_disconnected: Callable):
+        """验证聊天已清空"""
+        last_response_container = self.page.locator(RESPONSE_CONTAINER_SELECTOR).last
+        await asyncio.sleep(0.5)
+        await self._check_disconnect(check_client_disconnected, "After Clear Post-Delay")
+        try:
+            await expect_async(last_response_container).to_be_hidden(timeout=CLEAR_CHAT_VERIFY_TIMEOUT_MS - 500)
+            self.logger.info(f"[{self.req_id}] ✅ 聊天已成功清空 (验证通过 - 最后响应容器隐藏)。")
+        except Exception as verify_err:
+            self.logger.warning(f"[{self.req_id}] ⚠️ 警告: 清空聊天验证失败 (最后响应容器未隐藏): {verify_err}")
+    
+    async def submit_prompt(self, prompt: str, check_client_disconnected: Callable):
+        """提交提示到页面。"""
+        self.logger.info(f"[{self.req_id}] 填充并提交提示 ({len(prompt)} chars)...")
+        prompt_textarea_locator = self.page.locator(PROMPT_TEXTAREA_SELECTOR)
+        autosize_wrapper_locator = self.page.locator('ms-prompt-input-wrapper ms-autosize-textarea')
+        submit_button_locator = self.page.locator(SUBMIT_BUTTON_SELECTOR)
+
+        try:
+            await expect_async(prompt_textarea_locator).to_be_visible(timeout=5000)
+            await self._check_disconnect(check_client_disconnected, "After Input Visible")
+
+            # 使用 JavaScript 填充文本
+            await prompt_textarea_locator.evaluate(
+                '''
+                (element, text) => {
+                    element.value = text;
+                    element.dispatchEvent(new Event('input', { bubbles: true, cancelable: true }));
+                    element.dispatchEvent(new Event('change', { bubbles: true, cancelable: true }));
+                }
+                ''',
+                prompt
+            )
+            await autosize_wrapper_locator.evaluate('(element, text) => { element.setAttribute("data-value", text); }', prompt)
+            await self._check_disconnect(check_client_disconnected, "After Input Fill")
+
+            # 等待发送按钮启用
+            wait_timeout_ms_submit_enabled = 40000
+            try:
+                await self._check_disconnect(check_client_disconnected, "填充提示后等待发送按钮启用 - 前置检查")
+                await expect_async(submit_button_locator).to_be_enabled(timeout=wait_timeout_ms_submit_enabled)
+                self.logger.info(f"[{self.req_id}] ✅ 发送按钮已启用。")
+            except Exception as e_pw_enabled:
+                self.logger.error(f"[{self.req_id}] ❌ 等待发送按钮启用超时或错误: {e_pw_enabled}")
+                await save_error_snapshot(f"submit_button_enable_timeout_{self.req_id}")
+                raise
+
+            await self._check_disconnect(check_client_disconnected, "After Submit Button Enabled")
+            await asyncio.sleep(0.3)
+
+            # 尝试使用快捷键提交
+            submitted_successfully = await self._try_shortcut_submit(prompt_textarea_locator, check_client_disconnected)
+
+            # 如果快捷键失败，使用按钮点击
+            if not submitted_successfully:
+                self.logger.info(f"[{self.req_id}] 快捷键提交失败，尝试点击提交按钮...")
+                try:
+                    await submit_button_locator.click(timeout=5000)
+                    self.logger.info(f"[{self.req_id}] ✅ 提交按钮点击完成。")
+                except Exception as click_err:
+                    self.logger.error(f"[{self.req_id}] ❌ 提交按钮点击失败: {click_err}")
+                    await save_error_snapshot(f"submit_button_click_fail_{self.req_id}")
+                    raise
+
+            await self._check_disconnect(check_client_disconnected, "After Submit")
+
+        except Exception as e_input_submit:
+            self.logger.error(f"[{self.req_id}] 输入和提交过程中发生错误: {e_input_submit}")
+            if not isinstance(e_input_submit, ClientDisconnectedError):
+                await save_error_snapshot(f"input_submit_error_{self.req_id}")
+            raise
+
+    async def _try_shortcut_submit(self, prompt_textarea_locator, check_client_disconnected: Callable) -> bool:
+        """尝试使用快捷键提交"""
+        import os
+        try:
+            # 检测操作系统
+            host_os_from_launcher = os.environ.get('HOST_OS_FOR_SHORTCUT')
+            is_mac_determined = False
+
+            if host_os_from_launcher == "Darwin":
+                is_mac_determined = True
+            elif host_os_from_launcher in ["Windows", "Linux"]:
+                is_mac_determined = False
+            else:
+                # 使用浏览器检测
+                try:
+                    user_agent_data_platform = await self.page.evaluate("() => navigator.userAgentData?.platform || ''")
+                except Exception:
+                    user_agent_string = await self.page.evaluate("() => navigator.userAgent || ''")
+                    user_agent_string_lower = user_agent_string.lower()
+                    if "macintosh" in user_agent_string_lower or "mac os x" in user_agent_string_lower:
+                        user_agent_data_platform = "macOS"
+                    else:
+                        user_agent_data_platform = "Other"
+
+                is_mac_determined = "mac" in user_agent_data_platform.lower()
+
+            shortcut_modifier = "Meta" if is_mac_determined else "Control"
+            shortcut_key = "Enter"
+
+            self.logger.info(f"[{self.req_id}] 使用快捷键: {shortcut_modifier}+{shortcut_key}")
+
+            await prompt_textarea_locator.focus(timeout=5000)
+            await self._check_disconnect(check_client_disconnected, "After Input Focus")
+            await asyncio.sleep(0.1)
+
+            # 记录提交前的输入框内容，用于验证
+            original_content = ""
+            try:
+                original_content = await prompt_textarea_locator.input_value(timeout=2000) or ""
+            except Exception:
+                # 如果无法获取原始内容，仍然尝试提交
+                pass
+
+            try:
+                await self.page.keyboard.press(f'{shortcut_modifier}+{shortcut_key}')
+            except Exception:
+                # 尝试分步按键
+                await self.page.keyboard.down(shortcut_modifier)
+                await asyncio.sleep(0.05)
+                await self.page.keyboard.press(shortcut_key)
+                await asyncio.sleep(0.05)
+                await self.page.keyboard.up(shortcut_modifier)
+
+            await self._check_disconnect(check_client_disconnected, "After Shortcut Press")
+
+            # 等待更长时间让提交完成
+            await asyncio.sleep(2.0)
+
+            # 多种方式验证提交是否成功
+            submission_success = False
+
+            try:
+                # 方法1: 检查原始输入框是否清空
+                current_content = await prompt_textarea_locator.input_value(timeout=2000) or ""
+                if original_content and not current_content.strip():
+                    self.logger.info(f"[{self.req_id}] 验证方法1: 输入框已清空，快捷键提交成功")
+                    submission_success = True
+
+                # 方法2: 检查提交按钮状态
+                if not submission_success:
+                    submit_button_locator = self.page.locator(SUBMIT_BUTTON_SELECTOR)
+                    try:
+                        is_disabled = await submit_button_locator.is_disabled(timeout=2000)
+                        if is_disabled:
+                            self.logger.info(f"[{self.req_id}] 验证方法2: 提交按钮已禁用，快捷键提交成功")
+                            submission_success = True
+                    except Exception:
+                        pass
+
+                # 方法3: 检查是否有响应容器出现
+                if not submission_success:
+                    try:
+                        response_container = self.page.locator(RESPONSE_CONTAINER_SELECTOR)
+                        container_count = await response_container.count()
+                        if container_count > 0:
+                            # 检查最后一个容器是否是新的
+                            last_container = response_container.last
+                            if await last_container.is_visible(timeout=1000):
+                                self.logger.info(f"[{self.req_id}] 验证方法3: 检测到响应容器，快捷键提交成功")
+                                submission_success = True
+                    except Exception:
+                        pass
+
+            except Exception as verify_err:
+                self.logger.warning(f"[{self.req_id}] 快捷键提交验证过程出错: {verify_err}")
+                # 出错时假定提交成功，让后续流程继续
+                submission_success = True
+
+            if submission_success:
+                self.logger.info(f"[{self.req_id}] ✅ 快捷键提交成功")
+                return True
+            else:
+                self.logger.warning(f"[{self.req_id}] ⚠️ 快捷键提交验证失败")
+                return False
+
+        except Exception as shortcut_err:
+            self.logger.warning(f"[{self.req_id}] 快捷键提交失败: {shortcut_err}")
+            return False
+
+    async def get_response(self, check_client_disconnected: Callable) -> str:
+        """获取响应内容。"""
+        self.logger.info(f"[{self.req_id}] 等待并获取响应...")
+
+        try:
+            # 等待响应容器出现
+            response_container_locator = self.page.locator(RESPONSE_CONTAINER_SELECTOR).last
+            response_element_locator = response_container_locator.locator(RESPONSE_TEXT_SELECTOR)
+
+            self.logger.info(f"[{self.req_id}] 等待响应元素附加到DOM...")
+            await expect_async(response_element_locator).to_be_attached(timeout=90000)
+            await self._check_disconnect(check_client_disconnected, "获取响应 - 响应元素已附加")
+
+            # 等待响应完成
+            submit_button_locator = self.page.locator(SUBMIT_BUTTON_SELECTOR)
+            edit_button_locator = self.page.locator(EDIT_MESSAGE_BUTTON_SELECTOR)
+            input_field_locator = self.page.locator(PROMPT_TEXTAREA_SELECTOR)
+
+            self.logger.info(f"[{self.req_id}] 等待响应完成...")
+            completion_detected = await _wait_for_response_completion(
+                self.page, input_field_locator, submit_button_locator, edit_button_locator, self.req_id, check_client_disconnected, None
+            )
+
+            if not completion_detected:
+                self.logger.warning(f"[{self.req_id}] 响应完成检测失败，尝试获取当前内容")
+            else:
+                self.logger.info(f"[{self.req_id}] ✅ 响应完成检测成功")
+
+            # 获取最终响应内容
+            final_content = await _get_final_response_content(self.page, self.req_id, check_client_disconnected)
+
+            if not final_content or not final_content.strip():
+                self.logger.warning(f"[{self.req_id}] ⚠️ 获取到的响应内容为空")
+                await save_error_snapshot(f"empty_response_{self.req_id}")
+                # 不抛出异常，返回空内容让上层处理
+                return ""
+
+            self.logger.info(f"[{self.req_id}] ✅ 成功获取响应内容 ({len(final_content)} chars)")
+            return final_content
+
+        except Exception as e:
+            self.logger.error(f"[{self.req_id}] ❌ 获取响应时出错: {e}")
+            if not isinstance(e, ClientDisconnectedError):
+                await save_error_snapshot(f"get_response_error_{self.req_id}")
+            raise

browser_utils/script_manager.py

@@ -0,0 +1,183 @@
+# --- browser_utils/script_manager.py ---
+# 油猴脚本管理模块 - 动态挂载和注入脚本功能
+
+import os
+import json
+import logging
+from typing import Dict, List, Optional, Any
+from playwright.async_api import Page as AsyncPage
+
+logger = logging.getLogger("AIStudioProxyServer")
+
+class ScriptManager:
+    """油猴脚本管理器 - 负责动态加载和注入脚本"""
+    
+    def __init__(self, script_dir: str = "browser_utils"):
+        self.script_dir = script_dir
+        self.loaded_scripts: Dict[str, str] = {}
+        self.model_configs: Dict[str, List[Dict[str, Any]]] = {}
+        
+    def load_script(self, script_name: str) -> Optional[str]:
+        """加载指定的JavaScript脚本文件"""
+        script_path = os.path.join(self.script_dir, script_name)
+        
+        if not os.path.exists(script_path):
+            logger.error(f"脚本文件不存在: {script_path}")
+            return None
+            
+        try:
+            with open(script_path, 'r', encoding='utf-8') as f:
+                script_content = f.read()
+                self.loaded_scripts[script_name] = script_content
+                logger.info(f"成功加载脚本: {script_name}")
+                return script_content
+        except Exception as e:
+            logger.error(f"加载脚本失败 {script_name}: {e}")
+            return None
+    
+    def load_model_config(self, config_path: str) -> Optional[List[Dict[str, Any]]]:
+        """加载模型配置文件"""
+        if not os.path.exists(config_path):
+            logger.warning(f"模型配置文件不存在: {config_path}")
+            return None
+            
+        try:
+            with open(config_path, 'r', encoding='utf-8') as f:
+                config_data = json.load(f)
+                models = config_data.get('models', [])
+                self.model_configs[config_path] = models
+                logger.info(f"成功加载模型配置: {len(models)} 个模型")
+                return models
+        except Exception as e:
+            logger.error(f"加载模型配置失败 {config_path}: {e}")
+            return None
+    
+    def generate_dynamic_script(self, base_script: str, models: List[Dict[str, Any]], 
+                              script_version: str = "dynamic") -> str:
+        """基于模型配置动态生成脚本内容"""
+        try:
+            # 构建模型列表的JavaScript代码
+            models_js = "const MODELS_TO_INJECT = [\n"
+            for model in models:
+                name = model.get('name', '')
+                display_name = model.get('displayName', model.get('display_name', ''))
+                description = model.get('description', f'Model injected by script {script_version}')
+                
+                # 如果displayName中没有包含版本信息，添加版本信息
+                if f"(Script {script_version})" not in display_name:
+                    display_name = f"{display_name} (Script {script_version})"
+                
+                models_js += f"""       {{
+          name: '{name}',
+          displayName: `{display_name}`,
+          description: `{description}`
+       }},\n"""
+            
+            models_js += "    ];"
+            
+            # 替换脚本中的模型定义部分
+            # 查找模型定义的开始和结束标记
+            start_marker = "const MODELS_TO_INJECT = ["
+            end_marker = "];"
+            
+            start_idx = base_script.find(start_marker)
+            if start_idx == -1:
+                logger.error("未找到模型定义开始标记")
+                return base_script
+                
+            # 找到对应的结束标记
+            bracket_count = 0
+            end_idx = start_idx + len(start_marker)
+            found_end = False
+            
+            for i in range(end_idx, len(base_script)):
+                if base_script[i] == '[':
+                    bracket_count += 1
+                elif base_script[i] == ']':
+                    if bracket_count == 0:
+                        end_idx = i + 1
+                        found_end = True
+                        break
+                    bracket_count -= 1
+            
+            if not found_end:
+                logger.error("未找到模型定义结束标记")
+                return base_script
+            
+            # 替换模型定义部分
+            new_script = (base_script[:start_idx] + 
+                         models_js + 
+                         base_script[end_idx:])
+            
+            # 更新版本号
+            new_script = new_script.replace(
+                f'const SCRIPT_VERSION = "v1.6";',
+                f'const SCRIPT_VERSION = "{script_version}";'
+            )
+            
+            logger.info(f"成功生成动态脚本，包含 {len(models)} 个模型")
+            return new_script
+            
+        except Exception as e:
+            logger.error(f"生成动态脚本失败: {e}")
+            return base_script
+    
+    async def inject_script_to_page(self, page: AsyncPage, script_content: str, 
+                                  script_name: str = "injected_script") -> bool:
+        """将脚本注入到页面中"""
+        try:
+            # 移除UserScript头部信息，因为我们是直接注入而不是通过油猴
+            cleaned_script = self._clean_userscript_headers(script_content)
+            
+            # 注入脚本
+            await page.add_init_script(cleaned_script)
+            logger.info(f"成功注入脚本到页面: {script_name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"注入脚本到页面失败 {script_name}: {e}")
+            return False
+    
+    def _clean_userscript_headers(self, script_content: str) -> str:
+        """清理UserScript头部信息"""
+        lines = script_content.split('\n')
+        cleaned_lines = []
+        in_userscript_block = False
+        
+        for line in lines:
+            if line.strip().startswith('// ==UserScript=='):
+                in_userscript_block = True
+                continue
+            elif line.strip().startswith('// ==/UserScript=='):
+                in_userscript_block = False
+                continue
+            elif in_userscript_block:
+                continue
+            else:
+                cleaned_lines.append(line)
+        
+        return '\n'.join(cleaned_lines)
+    
+    async def setup_model_injection(self, page: AsyncPage,
+                                  script_name: str = "more_modles.js") -> bool:
+        """设置模型注入 - 直接注入油猴脚本"""
+
+        # 检查脚本文件是否存在
+        script_path = os.path.join(self.script_dir, script_name)
+        if not os.path.exists(script_path):
+            # 脚本文件不存在，静默跳过注入
+            return False
+
+        logger.info("开始设置模型注入...")
+
+        # 加载油猴脚本
+        script_content = self.load_script(script_name)
+        if not script_content:
+            return False
+
+        # 直接注入原始脚本（不修改内容）
+        return await self.inject_script_to_page(page, script_content, script_name)
+
+
+# 全局脚本管理器实例
+script_manager = ScriptManager()