Upload 88 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+AIStudioProxyAPI/支持作者.jpg filter=lfs diff=lfs merge=lfs -text

AIStudioProxyAPI/.dockerignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.pyc
+.git/
+.gitignore
+.vscode/
+deprecated_javascript_version/
+memory-bank/
+*.log
+*.DS_Store
+venv/
+env/
+# auth_profiles/ # Handled by volume mount
+# certs/         # Handled by volume mount or generated in container
+# logs/          # Supervisord logs to stdout/stderr

AIStudioProxyAPI/.env.example

@@ -0,0 +1,196 @@
+# AI Studio Proxy API 配置文件示例
+# 复制此文件为 .env 并根据需要修改配置
+
+# =============================================================================
+# 服务端口配置
+# =============================================================================
+
+# FastAPI 服务端口
+PORT=2048
+
+# GUI 启动器默认端口配置
+DEFAULT_FASTAPI_PORT=2048
+DEFAULT_CAMOUFOX_PORT=9222
+
+# 流式代理服务配置
+STREAM_PORT=3120
+# 设置为 0 禁用流式代理服务
+
+# =============================================================================
+# 代理配置
+# =============================================================================
+
+# HTTP/HTTPS 代理设置
+# HTTP_PROXY=http://127.0.0.1:7890
+# HTTPS_PROXY=http://127.0.0.1:7890
+
+# 统一代理配置 (优先级高于 HTTP_PROXY/HTTPS_PROXY)
+UNIFIED_PROXY_CONFIG=http://127.0.0.1:7890
+
+# 代理绕过列表 (用分号分隔)
+# NO_PROXY=localhost;127.0.0.1;*.local
+
+# =============================================================================
+# 日志配置
+# =============================================================================
+
+# 服务器日志级别 (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+SERVER_LOG_LEVEL=INFO
+
+# 是否重定向 print 输出到日志
+SERVER_REDIRECT_PRINT=false
+
+# 启用调试日志
+DEBUG_LOGS_ENABLED=false
+
+# 启用跟踪日志
+TRACE_LOGS_ENABLED=false
+
+# =============================================================================
+# 认证配置
+# =============================================================================
+
+# 自动保存认证信息
+AUTO_SAVE_AUTH=false
+
+# 认证保存超时时间 (秒)
+AUTH_SAVE_TIMEOUT=30
+
+# 自动确认登录
+AUTO_CONFIRM_LOGIN=true
+
+# =============================================================================
+# 浏览器配置
+# =============================================================================
+
+# Camoufox WebSocket 端点
+# CAMOUFOX_WS_ENDPOINT=ws://127.0.0.1:9222
+
+# 启动模式 (normal, headless, virtual_display, direct_debug_no_browser)
+LAUNCH_MODE=normal
+
+# =============================================================================
+# API 默认参数配置
+# =============================================================================
+
+# 默认温度值 (0.0-2.0)
+DEFAULT_TEMPERATURE=1.0
+
+# 默认最大输出令牌数
+DEFAULT_MAX_OUTPUT_TOKENS=65536
+
+# 默认 Top-P 值 (0.0-1.0)
+DEFAULT_TOP_P=0.95
+
+# 默认停止序列 (JSON 数组格式)
+DEFAULT_STOP_SEQUENCES=["用户:"]
+
+# 是否在处理请求时自动打开并使用 "URL Context" 功能,此工具功能详情可参考:https://ai.google.dev/gemini-api/docs/url-context
+ENABLE_URL_CONTEXT=false
+
+# 是否默认启用 "指定思考预算" 功能 (true/false),不启用时模型一般将自行决定思考预算
+# 当 API 请求中未提供 reasoning_effort 参数时将使用此值。
+ENABLE_THINKING_BUDGET=false
+
+# "指定思考预算量" 的默认值 (token)
+# 当 API 请求中未提供 reasoning_effort 参数时，将使用此值。
+DEFAULT_THINKING_BUDGET=8192
+
+# 是否默认启用 "Google Search" 功能 (true/false)
+# 当 API 请求中未提供 tools 参数时，将使用此设置作为 Google Search 的默认开关状态。
+ENABLE_GOOGLE_SEARCH=false
+
+# =============================================================================
+# 超时配置 (毫秒)
+# =============================================================================
+
+# 响应完成总超时时间
+RESPONSE_COMPLETION_TIMEOUT=300000
+
+# 初始等待时间
+INITIAL_WAIT_MS_BEFORE_POLLING=500
+
+# 轮询间隔
+POLLING_INTERVAL=300
+POLLING_INTERVAL_STREAM=180
+
+# 静默超时
+SILENCE_TIMEOUT_MS=60000
+
+# 页面操作超时
+POST_SPINNER_CHECK_DELAY_MS=500
+FINAL_STATE_CHECK_TIMEOUT_MS=1500
+POST_COMPLETION_BUFFER=700
+
+# 清理聊天相关超时
+CLEAR_CHAT_VERIFY_TIMEOUT_MS=4000
+CLEAR_CHAT_VERIFY_INTERVAL_MS=4000
+
+# 点击和剪贴板操作超时
+CLICK_TIMEOUT_MS=3000
+CLIPBOARD_READ_TIMEOUT_MS=3000
+
+# 元素等待超时
+WAIT_FOR_ELEMENT_TIMEOUT_MS=10000
+
+# 流相关配置
+PSEUDO_STREAM_DELAY=0.01
+
+# =============================================================================
+# GUI 启动器配置
+# =============================================================================
+
+# GUI 默认代理地址
+GUI_DEFAULT_PROXY_ADDRESS=http://127.0.0.1:7890
+
+# GUI 默认流式代理端口
+GUI_DEFAULT_STREAM_PORT=3120
+
+# GUI 默认 Helper 端点
+GUI_DEFAULT_HELPER_ENDPOINT=
+
+# =============================================================================
+# 脚本注入配置
+# =============================================================================
+
+# 是否启用油猴脚本注入功能(已失效)
+ENABLE_SCRIPT_INJECTION=false
+
+# 油猴脚本文件路径（相对于项目根目录）
+# 模型数据直接从此脚本文件中解析，无需额��配置文件
+USERSCRIPT_PATH=browser_utils/more_modles.js
+
+# =============================================================================
+# 其他配置
+# =============================================================================
+
+# 模型名称
+MODEL_NAME=AI-Studio_Proxy_API
+
+# 聊天完成 ID 前缀
+CHAT_COMPLETION_ID_PREFIX=chatcmpl-
+
+# 默认回退模型 ID
+DEFAULT_FALLBACK_MODEL_ID=no model list
+
+# 排除模型文件名
+EXCLUDED_MODELS_FILENAME=excluded_models.txt
+
+# AI Studio URL 模式
+AI_STUDIO_URL_PATTERN=aistudio.google.com/
+
+# 模型端点 URL 包含字符串
+MODELS_ENDPOINT_URL_CONTAINS=MakerSuiteService/ListModels
+
+# 用户输入标记符
+USER_INPUT_START_MARKER_SERVER=__USER_INPUT_START__
+USER_INPUT_END_MARKER_SERVER=__USER_INPUT_END__
+
+# =============================================================================
+# 流状态配置
+# =============================================================================
+
+# 流超时日志状态配置
+STREAM_MAX_INITIAL_ERRORS=3
+STREAM_WARNING_INTERVAL_AFTER_SUPPRESS=60.0
+STREAM_SUPPRESS_DURATION_AFTER_INITIAL_BURST=400.0

AIStudioProxyAPI/.gitignore

@@ -0,0 +1,251 @@
+# Logs
+logs
+*.log
+certs/*
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+/upload_images
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the next line if you're using Gatsby Cloud
+# .gatsby/
+public
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# macOS files
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Thumbnails
+._*
+
+# Files that might appear on external disk
+.Spotlight-V100
+.Trashes
+
+# Temporary files created by editors
+*~
+#*.swp
+
+# IDE config folders
+.idea/
+.vscode/
+
+# Custom
+errors/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Python Libraries
+*.egg-info/
+*.egg
+
+# Distribution / packaging
+.Python
+build/
+dist/
+part/
+sdist/
+*.manifest
+*.spec
+wheels/
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Error snapshots directory (Python specific)
+errors_py/
+logs/
+
+# Authentication Profiles (Sensitive)
+auth_profiles/active/*
+!auth_profiles/active/.gitkeep
+auth_profiles/saved/*
+!auth_profiles/saved/.gitkeep
+
+# Camoufox/Playwright Profile Data (Assume these are generated/temporary)
+camoufox_profile/
+chrome_temp_profile/
+
+# Deprecated Javascript Version node_modules
+deprecated_javascript_version/node_modules/ 
+
+.roomodes
+memory-bank/
+gui_config.json
+
+# key
+key.txt
+
+# 脚本注入相关文件
+# 用户自定义的模型配置文件（保留示例文件）
+browser_utils/model_configs.json
+browser_utils/my_*.json
+# 用户自定义的油猴脚本（如果不是默认的）
+browser_utils/custom_*.js
+browser_utils/my_*.js
+# 临时生成的脚本文件
+browser_utils/generated_*.js
+# Docker 环境的实际配置文件（保留示例文件）
+docker/.env
+docker/my_*.json

AIStudioProxyAPI/LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

AIStudioProxyAPI/README.md

@@ -0,0 +1,379 @@
+# AI Studio Proxy API
+
+这是一个基于 Python 的代理服务器，用于将 Google AI Studio 的网页界面转换为 OpenAI 兼容的 API。通过 Camoufox (反指纹检测的 Firefox) 和 Playwright 自动化，提供稳定的 API 访问。
+
+[![Star History Chart](https://api.star-history.com/svg?repos=CJackHwang/AIstudioProxyAPI&type=Date)](https://www.star-history.com/#CJackHwang/AIstudioProxyAPI&Date)
+
+This project is generously sponsored by ZMTO. Visit their website: [https://zmto.com/](https://zmto.com/)
+
+本项目由 ZMTO 慷慨赞助服务器支持。访问他们的网站：[https://zmto.com/](https://zmto.com/)
+
+---
+
+## 致谢 (Acknowledgements)
+
+本项目的诞生与发展，离不开以下个人、组织和社区的慷慨支持与智慧贡献：
+
+- **项目发起与主要开发**: @CJackHwang ([https://github.com/CJackHwang](https://github.com/CJackHwang))
+- **功能完善、页面操作优化思路贡献**: @ayuayue ([https://github.com/ayuayue](https://github.com/ayuayue))
+- **实时流式功能优化与完善**: @luispater ([https://github.com/luispater](https://github.com/luispater))
+- **3400+行主文件项目重构伟大贡献**: @yattin (Holt) ([https://github.com/yattin](https://github.com/yattin))
+- **项目后期高质量维护**: @Louie （[https://github.com/NikkeTryHard](https://github.com/NikkeTryHard)）
+- **社区支持与灵感碰撞**: 特别感谢 [Linux.do 社区](https://linux.do/) 成员们的热烈讨论、宝贵建议和问题反馈，你们的参与是项目前进的重要动力。
+
+同时，我们衷心感谢所有通过提交 Issue、提供建议、分享使用体验、贡献代码修复等方式为本项目默默奉献的每一位朋友。是你们共同的努力，让这个项目变得更好！
+
+---
+
+**这是当前维护的 Python 版本。不再维护的 Javascript 版本请参见 [`deprecated_javascript_version/README.md`](deprecated_javascript_version/README.md)。**
+
+## 系统要求
+
+- **Python**: >=3.9, <4.0 (推荐 3.10+ 以获得最佳性能，Docker 环境使用 3.10)
+- **依赖管理**: [Poetry](https://python-poetry.org/) (现代化 Python 依赖管理工具，替代传统 requirements.txt)
+- **类型检查**: [Pyright](https://github.com/microsoft/pyright) (可选，用于开发时类型检查和 IDE 支持)
+- **操作系统**: Windows, macOS, Linux (完全跨平台支持，Docker 部署支持 x86_64 和 ARM64)
+- **内存**: 建议 2GB+ 可用内存 (浏览器自动化需要)
+- **网络**: 稳定的互联网连接访问 Google AI Studio (支持代理配置)
+
+## 主要特性
+
+- **OpenAI 兼容 API**: 支持 `/v1/chat/completions` 端点，完全兼容 OpenAI 客户端和第三方工具
+- **三层流式响应机制**: 集成流式代理 → 外部 Helper 服务 → Playwright 页面交互的多重保障
+- **智能模型切换**: 通过 API 请求中的 `model` 字段动态切换 AI Studio 中的模型
+- **完整参数控制**: 支持 `temperature`、`max_output_tokens`、`top_p`、`stop`、`reasoning_effort` 等所有主要参数
+- **反指纹检测**: 使用 Camoufox 浏览器降低被检测为自动化脚本的风险
+- **脚本注入功能 v3.0**: 使用 Playwright 原生网络拦截，支持油猴脚本动态挂载，100%可靠 🆕
+- **现代化 Web UI**: 内置测试界面，支持实时聊天、状态监控、分级 API 密钥管理
+- **图形界面启动器**: 提供功能丰富的 GUI 启动器，简化配置和进程管理
+- **灵活认证系统**: 支持可选的 API 密钥认证，完全兼容 OpenAI 标准的 Bearer token 格式
+- **模块化架构**: 清晰的模块分离设计，api_utils/、browser_utils/、config/ 等独立模块
+- **统一配置管理**: 基于 `.env` 文件的统一配置方式，支持环境变量覆盖，Docker 兼容
+- **现代化开发工具**: Poetry 依赖管理 + Pyright 类型检查，提供优秀的开发体验
+
+## 系统架构
+
+```mermaid
+graph TD
+    subgraph "用户端 (User End)"
+        User["用户 (User)"]
+        WebUI["Web UI (Browser)"]
+        API_Client["API 客户端 (API Client)"]
+    end
+
+    subgraph "启动与配置 (Launch & Config)"
+        GUI_Launch["gui_launcher.py (图形启动器)"]
+        CLI_Launch["launch_camoufox.py (命令行启动)"]
+        EnvConfig[".env (统一配置)"]
+        KeyFile["auth_profiles/key.txt (API Keys)"]
+        ConfigDir["config/ (配置模块)"]
+    end
+
+    subgraph "核心应用 (Core Application)"
+        FastAPI_App["api_utils/app.py (FastAPI 应用)"]
+        Routes["api_utils/routes.py (路由处理)"]
+        RequestProcessor["api_utils/request_processor.py (请求处理)"]
+        AuthUtils["api_utils/auth_utils.py (认证管理)"]
+        PageController["browser_utils/page_controller.py (页面控制)"]
+        ScriptManager["browser_utils/script_manager.py (脚本注入)"]
+        ModelManager["browser_utils/model_management.py (模型管理)"]
+        StreamProxy["stream/ (流式代理服务器)"]
+    end
+
+    subgraph "外部依赖 (External Dependencies)"
+        CamoufoxInstance["Camoufox 浏览器 (反指纹)"]
+        AI_Studio["Google AI Studio"]
+        UserScript["油猴脚本 (可选)"]
+    end
+
+    User -- "运行 (Run)" --> GUI_Launch
+    User -- "运行 (Run)" --> CLI_Launch
+    User -- "访问 (Access)" --> WebUI
+
+    GUI_Launch -- "启动 (Starts)" --> CLI_Launch
+    CLI_Launch -- "启动 (Starts)" --> FastAPI_App
+    CLI_Launch -- "配置 (Configures)" --> StreamProxy
+
+    API_Client -- "API 请求 (Request)" --> FastAPI_App
+    WebUI -- "聊天请求 (Chat Request)" --> FastAPI_App
+
+    FastAPI_App -- "读取配置 (Reads Config)" --> EnvConfig
+    FastAPI_App -- "使用路由 (Uses Routes)" --> Routes
+    AuthUtils -- "验证密钥 (Validates Key)" --> KeyFile
+    ConfigDir -- "提供设置 (Provides Settings)" --> EnvConfig
+
+    Routes -- "处理请求 (Processes Request)" --> RequestProcessor
+    Routes -- "认证管理 (Auth Management)" --> AuthUtils
+    RequestProcessor -- "控制浏览器 (Controls Browser)" --> PageController
+    RequestProcessor -- "通过代理 (Uses Proxy)" --> StreamProxy
+
+    PageController -- "模型管理 (Model Management)" --> ModelManager
+    PageController -- "脚本注入 (Script Injection)" --> ScriptManager
+    ScriptManager -- "加载脚本 (Loads Script)" --> UserScript
+    ScriptManager -- "增强功能 (Enhances)" --> CamoufoxInstance
+    PageController -- "自动化 (Automates)" --> CamoufoxInstance
+    CamoufoxInstance -- "访问 (Accesses)" --> AI_Studio
+    StreamProxy -- "转发请求 (Forwards Request)" --> AI_Studio
+
+    AI_Studio -- "响应 (Response)" --> CamoufoxInstance
+    AI_Studio -- "响应 (Response)" --> StreamProxy
+
+    CamoufoxInstance -- "返回数据 (Returns Data)" --> PageController
+    StreamProxy -- "返回数据 (Returns Data)" --> RequestProcessor
+
+    FastAPI_App -- "API 响应 (Response)" --> API_Client
+    FastAPI_App -- "UI 响应 (Response)" --> WebUI
+```
+
+## 配置管理 ⭐
+
+**新功能**: 项目现在支持通过 `.env` 文件进行配置管理，避免硬编码参数！
+
+### 快速配置
+
+```bash
+# 1. 复制配置模板
+cp .env.example .env
+
+# 2. 编辑配置文件
+nano .env  # 或使用其他编辑器
+
+# 3. 启动服务（自动读取配置）
+python gui_launcher.py
+# 或直接命令行启动
+python launch_camoufox.py --headless
+```
+
+### 主要优势
+
+- ✅ **版本更新无忧**: 一个 `git pull` 就完成更新，无需重新配置
+- ✅ **配置集中管理**: 所有配置项统一在 `.env` 文件中
+- ✅ **启动命令简化**: 无需复杂的命令行参数，一键启动
+- ✅ **安全性**: `.env` 文件已被 `.gitignore` 忽略，不会泄露配置
+- ✅ **灵活性**: 支持不同环境的配置管理
+- ✅ **Docker 兼容**: Docker 和本地环境使用相同的配置方式
+
+详细配置说明请参见 [环境变量配置指南](docs/environment-configuration.md)。
+
+## 使用教程
+
+推荐使用 [`gui_launcher.py`](gui_launcher.py) (图形界面) 或直接使用 [`launch_camoufox.py`](launch_camoufox.py) (命令行) 进行日常运行。仅在首次设置或认证过期时才需要使用调试模式。
+
+### 快速开始
+
+本项目采用现代化的 Python 开发工具链，使用 [Poetry](https://python-poetry.org/) 进行依赖管理，[Pyright](https://github.com/microsoft/pyright) 进行类型检查。
+
+#### 🚀 一键安装脚本 (推荐)
+
+```bash
+# macOS/Linux 用户
+curl -sSL https://raw.githubusercontent.com/CJackHwang/AIstudioProxyAPI/main/scripts/install.sh | bash
+
+# Windows 用户 (PowerShell)
+iwr -useb https://raw.githubusercontent.com/CJackHwang/AIstudioProxyAPI/main/scripts/install.ps1 | iex
+```
+
+#### 📋 手动安装步骤
+
+1.  **安装 Poetry** (如果尚未安装):
+
+    ```bash
+    # macOS/Linux
+    curl -sSL https://install.python-poetry.org | python3 -
+
+    # Windows (PowerShell)
+    (Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -
+
+    # 或使用包管理器
+    # macOS: brew install poetry
+    # Ubuntu/Debian: apt install python3-poetry
+    ```
+
+2.  **克隆项目**:
+
+    ```bash
+    git clone https://github.com/CJackHwang/AIstudioProxyAPI.git
+    cd AIstudioProxyAPI
+    ```
+
+3.  **安装依赖**:
+    Poetry 会自动创建虚拟环境并安装所有依赖：
+
+    ```bash
+    poetry install
+    ```
+
+4.  **激活虚拟环境**:
+
+    ```bash
+    # 方式1: 激活 shell (推荐日常开发)
+    poetry env activate
+
+    # 方式2: 直接运行命令 (推荐自动化脚本)
+    poetry run python gui_launcher.py
+    ```
+
+#### 🔧 后续配置步骤
+
+5.  **环境配置**: 参见 [环境变量配置指南](docs/environment-configuration.md) - **推荐先配置**
+6.  **首次认证**: 参见 [认证设置指南](docs/authentication-setup.md)
+7.  **日常运行**: 参见 [日常运行指南](docs/daily-usage.md)
+8.  **API 使用**: 参见 [API 使用指南](docs/api-usage.md)
+9.  **Web 界面**: 参见 [Web UI 使用指南](docs/webui-guide.md)
+
+#### 🛠️ 开发者选项
+
+如果您是开发者，还可以：
+
+```bash
+# 安装开发依赖 (包含类型检查、测试工具等)
+poetry install --with dev
+
+# 启用类型检查 (需要安装 pyright)
+npm install -g pyright
+pyright
+
+# 查看项目依赖树
+poetry show --tree
+
+# 更新依赖
+poetry update
+```
+
+### 📚 详细文档
+
+#### 🚀 快速上手
+
+- [安装指南](docs/installation-guide.md) - 详细的安装步骤和环境配置
+- [环境变量配置指南](docs/environment-configuration.md) - **.env 文件配置管理** ⭐
+- [认证设置指南](docs/authentication-setup.md) - 首次运行与认证文件设置
+- [日常运行指南](docs/daily-usage.md) - 日常使用和配置选项
+
+#### 🔧 功能使用
+
+- [API 使用指南](docs/api-usage.md) - API 端点和客户端配置
+- [Web UI 使用指南](docs/webui-guide.md) - Web 界面功能说明
+- [脚本注入指南](docs/script_injection_guide.md) - 油猴脚本动态挂载功能使用指南 (v3.0) 🆕
+
+#### ⚙️ 高级配置
+
+- [流式处理模式详解](docs/streaming-modes.md) - 三层响应获取机制详细说明 🆕
+- [高级配置指南](docs/advanced-configuration.md) - 高级功能和配置选项
+- [日志控制指南](docs/logging-control.md) - 日志系统配置和调试
+- [故障排除指南](docs/troubleshooting.md) - 常见问题解决方案
+
+#### 🛠️ 开发相关
+
+- [项目架构指南](docs/architecture-guide.md) - 模块化架构设计和组件详解 🆕
+- [开发者指南](docs/development-guide.md) - Poetry、Pyright 和开发工作流程
+- [依赖版本说明](docs/dependency-versions.md) - Poetry 依赖管理和版本控制详解
+
+## 客户端配置示例
+
+以 Open WebUI 为例：
+
+1. 打开 Open WebUI
+2. 进入 "设置" -> "连接"
+3. 在 "模型" 部分，点击 "添加模型"
+4. **模型名称**: 输入你想要的名字，例如 `aistudio-gemini-py`
+5. **API 基础 URL**: 输入 `http://127.0.0.1:2048/v1`
+6. **API 密钥**: 留空或输入任意字符
+7. 保存设置并开始聊天
+
+---
+
+## 🐳 Docker 部署
+
+本项目支持通过 Docker 进行部署，使用 **Poetry** 进行依赖管理，**完全支持 `.env` 配置文件**！
+
+> 📁 **注意**: 所有 Docker 相关文件已移至 `docker/` 目录，保持项目根目录整洁。
+
+### 🚀 快速 Docker 部署
+
+```bash
+# 1. 准备配置文件
+cd docker
+cp .env.docker .env
+nano .env  # 编辑配置
+
+# 2. 使用 Docker Compose 启动
+docker compose up -d
+
+# 3. 查看日志
+docker compose logs -f
+
+# 4. 版本更新 (在 docker 目录下)
+bash update.sh
+```
+
+### 📚 详细文档
+
+- [Docker 部署指南 (docker/README-Docker.md)](docker/README-Docker.md) - 包含完整的 Poetry + `.env` 配置说明
+- [Docker 快速指南 (docker/README.md)](docker/README.md) - 快速开始指南
+
+### ✨ Docker 特性
+
+- ✅ **Poetry 依赖管理**: 使用现代化的 Python 依赖管理工具
+- ✅ **多阶段构建**: 优化镜像大小和构建速度
+- ✅ **配置统一**: 使用 `.env` 文件管理所有配置
+- ✅ **版本更新**: `bash update.sh` 即可完成更新
+- ✅ **目录整洁**: Docker 文件已移至 `docker/` 目录
+- ✅ **跨平台支持**: 支持 x86_64 和 ARM64 架构
+- ⚠️ **认证文件**: 首次运行需要在主机上获取认证文件，然后挂载到容器中
+
+---
+
+## 关于 Camoufox
+
+本项目使用 [Camoufox](https://camoufox.com/) 来提供具有增强反指纹检测能力的浏览器实例。
+
+- **核心目标**: 模拟真实用户流量，避免被网站识别为自动化脚本或机器人
+- **实现方式**: Camoufox 基于 Firefox，通过修改浏览器底层 C++ 实现来伪装设备指纹（如屏幕、操作系统、WebGL、字体等），而不是通过容易被检测到的 JavaScript 注入
+- **Playwright 兼容**: Camoufox 提供了与 Playwright 兼容的接口
+- **Python 接口**: Camoufox 提供了 Python 包，可以通过 `camoufox.server.launch_server()` 启动其服务，并通过 WebSocket 连接进行控制
+
+使用 Camoufox 的主要目的是提高与 AI Studio 网页交互时的隐蔽性，减少被检测或限制的可能性。但请注意，没有任何反指纹技术是绝对完美的。
+
+## 重要提示
+
+### 三层响应获取机制与参数控制
+
+- **响应获取优先级**: 项目采用三层响应获取机制，确保高可用性：
+
+  1. **集成流式代理服务 (Stream Proxy)**: 默认启用，端口 3120，提供最佳性能和稳定性
+  2. **外部 Helper 服务**: 可选配置，需要有效认证文件，作为备用方案
+  3. **Playwright 页面交互**: 最终后备方案，通过浏览器自动化获取响应
+
+- **参数控制机制**:
+
+  - **流式代理模式**: 支持基础参���传递，性能最优
+  - **Helper 服务模式**: 参数支持取决于外部服务实现
+  - **Playwright 模式**: 完整支持所有参数（`temperature`, `max_output_tokens`, `top_p`, `stop`, `reasoning_effort`等）
+
+- **脚本注入增强**: v3.0 版本使用 Playwright 原生网络拦截，确保注入模型与原生模型 100%一致
+
+### 客户端管理历史
+
+**客户端管理历史，代理不支持 UI 内编辑**: 客户端负责维护完整的聊天记录并将其发送给代理。代理服务器本身不支持在 AI Studio 界面中对历史消息进行编辑或分叉操作。
+
+## 未来计划
+
+以下是一些计划中的改进方向：
+
+- **云服务器部署指南**: 提供更详细的在主流云平台上部署和管理服务的指南
+- **认证更新流程优化**: 探索更便捷的认证文件更新机制，减少手动操作
+- **流程健壮性优化**: 减少错误几率和接近原生体验
+
+## 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+## License
+
+[AGPLv3](LICENSE)
+
+## 开发不易，支持作者
+
+如果您觉得本项目对您有帮助，并且希望支持作者的持续开发，欢迎通过以下方式进行捐赠。您的支持是对我们最大的鼓励！
+
+![开发不易，支持作者](./支持作者.jpg)

AIStudioProxyAPI/api_utils/__init__.py

@@ -0,0 +1,78 @@
+"""
+API工具模块
+提供FastAPI应用初始化、路由处理和工具函数
+"""
+
+# 应用初始化
+from .app import (
+    create_app
+)
+
+# 路由处理器
+from .routes import (
+    read_index,
+    get_css,
+    get_js,
+    get_api_info,
+    health_check,
+    list_models,
+    chat_completions,
+    cancel_request,
+    get_queue_status,
+    websocket_log_endpoint
+)
+
+# 工具函数
+from .utils import (
+    generate_sse_chunk,
+    generate_sse_stop_chunk,
+    generate_sse_error_chunk,
+    use_stream_response,
+    clear_stream_queue,
+    use_helper_get_response,
+    validate_chat_request,
+    prepare_combined_prompt,
+    estimate_tokens,
+    calculate_usage_stats
+)
+
+# 请求处理器
+from .request_processor import (
+    _process_request_refactored
+)
+
+# 队列工作器
+from .queue_worker import (
+    queue_worker
+)
+
+__all__ = [
+    # 应用初始化
+    'create_app',
+    # 路由处理器
+    'read_index',
+    'get_css',
+    'get_js',
+    'get_api_info',
+    'health_check',
+    'list_models',
+    'chat_completions',
+    'cancel_request',
+    'get_queue_status',
+    'websocket_log_endpoint',
+    # 工具函数
+    'generate_sse_chunk',
+    'generate_sse_stop_chunk',
+    'generate_sse_error_chunk',
+    'use_stream_response',
+    'clear_stream_queue',
+    'use_helper_get_response',
+    'validate_chat_request',
+    'prepare_combined_prompt',
+    'estimate_tokens',
+    'calculate_usage_stats',
+    # 请求处理器
+    '_process_request_refactored',
+    # 队列工作器
+    'queue_worker'
+] 

AIStudioProxyAPI/api_utils/app.py

@@ -0,0 +1,328 @@
+"""
+FastAPI应用初始化和生命周期管理
+"""
+
+import asyncio
+import multiprocessing
+import os
+import sys
+import queue  # <-- FIX: Added missing import for queue.Empty
+from contextlib import asynccontextmanager
+from typing import Optional
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.types import ASGIApp
+from typing import Callable, Awaitable
+from playwright.async_api import Browser as AsyncBrowser, Playwright as AsyncPlaywright
+
+# --- FIX: Replaced star import with explicit imports ---
+from config import NO_PROXY_ENV, EXCLUDED_MODELS_FILENAME
+
+# --- models模块导入 ---
+from models import WebSocketConnectionManager
+
+# --- logging_utils模块导入 ---
+from logging_utils import setup_server_logging, restore_original_streams
+
+# --- browser_utils模块导入 ---
+from browser_utils import (
+    _initialize_page_logic,
+    _close_page_logic,
+    load_excluded_models,
+    _handle_initial_model_state_and_storage,
+    enable_temporary_chat_mode
+)
+
+import stream
+from asyncio import Queue, Lock
+from . import auth_utils
+
+# 全局状态变量（这些将在server.py中被引用）
+playwright_manager: Optional[AsyncPlaywright] = None
+browser_instance: Optional[AsyncBrowser] = None
+page_instance = None
+is_playwright_ready = False
+is_browser_connected = False
+is_page_ready = False
+is_initializing = False
+
+global_model_list_raw_json = None
+parsed_model_list = []
+model_list_fetch_event = None
+
+current_ai_studio_model_id = None
+model_switching_lock = None
+
+excluded_model_ids = set()
+
+request_queue = None
+processing_lock = None
+worker_task = None
+
+page_params_cache = {}
+params_cache_lock = None
+
+log_ws_manager = None
+
+STREAM_QUEUE = None
+STREAM_PROCESS = None
+
+# --- Lifespan Context Manager ---
+def _setup_logging():
+    import server
+    log_level_env = os.environ.get('SERVER_LOG_LEVEL', 'INFO')
+    redirect_print_env = os.environ.get('SERVER_REDIRECT_PRINT', 'false')
+    server.log_ws_manager = WebSocketConnectionManager()
+    return setup_server_logging(
+        logger_instance=server.logger,
+        log_ws_manager=server.log_ws_manager,
+        log_level_name=log_level_env,
+        redirect_print_str=redirect_print_env
+    )
+
+def _initialize_globals():
+    import server
+    server.request_queue = Queue()
+    server.processing_lock = Lock()
+    server.model_switching_lock = Lock()
+    server.params_cache_lock = Lock()
+    auth_utils.initialize_keys()
+    server.logger.info("API keys and global locks initialized.")
+
+def _initialize_proxy_settings():
+    import server
+    STREAM_PORT = os.environ.get('STREAM_PORT')
+    if STREAM_PORT == '0':
+        PROXY_SERVER_ENV = os.environ.get('HTTPS_PROXY') or os.environ.get('HTTP_PROXY')
+    else:
+        PROXY_SERVER_ENV = f"http://127.0.0.1:{STREAM_PORT or 3120}/"
+    
+    if PROXY_SERVER_ENV:
+        server.PLAYWRIGHT_PROXY_SETTINGS = {'server': PROXY_SERVER_ENV}
+        if NO_PROXY_ENV:
+            server.PLAYWRIGHT_PROXY_SETTINGS['bypass'] = NO_PROXY_ENV.replace(',', ';')
+        server.logger.info(f"Playwright proxy settings configured: {server.PLAYWRIGHT_PROXY_SETTINGS}")
+    else:
+        server.logger.info("No proxy configured for Playwright.")
+
+async def _start_stream_proxy():
+    import server
+    STREAM_PORT = os.environ.get('STREAM_PORT')
+    if STREAM_PORT != '0':
+        port = int(STREAM_PORT or 3120)
+        STREAM_PROXY_SERVER_ENV = os.environ.get('UNIFIED_PROXY_CONFIG') or os.environ.get('HTTPS_PROXY') or os.environ.get('HTTP_PROXY')
+        server.logger.info(f"Starting STREAM proxy on port {port} with upstream proxy: {STREAM_PROXY_SERVER_ENV}")
+        server.STREAM_QUEUE = multiprocessing.Queue()
+        server.STREAM_PROCESS = multiprocessing.Process(target=stream.start, args=(server.STREAM_QUEUE, port, STREAM_PROXY_SERVER_ENV))
+        server.STREAM_PROCESS.start()
+        server.logger.info("STREAM proxy process started. Waiting for 'READY' signal...")
+
+        # --- FIX: Wait for the proxy to be ready ---
+        try:
+            # Use asyncio.to_thread to wait for the blocking queue.get()
+            # Set a timeout to avoid waiting forever
+            ready_signal = await asyncio.to_thread(server.STREAM_QUEUE.get, timeout=15)
+            if ready_signal == "READY":
+                server.logger.info("✅ Received 'READY' signal from STREAM proxy.")
+            else:
+                server.logger.warning(f"Received unexpected signal from proxy: {ready_signal}")
+        except queue.Empty:
+            server.logger.error("❌ Timed out waiting for STREAM proxy to become ready. Startup will likely fail.")
+            raise RuntimeError("STREAM proxy failed to start in time.")
+
+async def _initialize_browser_and_page():
+    import server
+    from playwright.async_api import async_playwright
+    
+    server.logger.info("Starting Playwright...")
+    server.playwright_manager = await async_playwright().start()
+    server.is_playwright_ready = True
+    server.logger.info("Playwright started.")
+
+    ws_endpoint = os.environ.get('CAMOUFOX_WS_ENDPOINT')
+    launch_mode = os.environ.get('LAUNCH_MODE', 'unknown')
+
+    if not ws_endpoint and launch_mode != "direct_debug_no_browser":
+        raise ValueError("CAMOUFOX_WS_ENDPOINT environment variable is missing.")
+
+    if ws_endpoint:
+        server.logger.info(f"Connecting to browser at: {ws_endpoint}")
+        server.browser_instance = await server.playwright_manager.firefox.connect(ws_endpoint, timeout=30000)
+        server.is_browser_connected = True
+        server.logger.info(f"Connected to browser: {server.browser_instance.version}")
+        
+        server.page_instance, server.is_page_ready = await _initialize_page_logic(server.browser_instance)
+        if server.is_page_ready:
+            await _handle_initial_model_state_and_storage(server.page_instance)
+            await enable_temporary_chat_mode(server.page_instance)
+            server.logger.info("Page initialized successfully.")
+        else:
+            server.logger.error("Page initialization failed.")
+    
+    if not server.model_list_fetch_event.is_set():
+        server.model_list_fetch_event.set()
+
+async def _shutdown_resources():
+    import server
+    logger = server.logger
+    logger.info("Shutting down resources...")
+    
+    if server.STREAM_PROCESS:
+        server.STREAM_PROCESS.terminate()
+        logger.info("STREAM proxy terminated.")
+
+    if server.worker_task and not server.worker_task.done():
+        server.worker_task.cancel()
+        try:
+            await asyncio.wait_for(server.worker_task, timeout=5.0)
+        except (asyncio.TimeoutError, asyncio.CancelledError):
+            pass
+        logger.info("Worker task stopped.")
+
+    if server.page_instance:
+        await _close_page_logic()
+    
+    if server.browser_instance and server.browser_instance.is_connected():
+        await server.browser_instance.close()
+        logger.info("Browser connection closed.")
+    
+    if server.playwright_manager:
+        await server.playwright_manager.stop()
+        logger.info("Playwright stopped.")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """FastAPI application life cycle management"""
+    import server
+    from server import queue_worker
+
+    original_streams = sys.stdout, sys.stderr
+    initial_stdout, initial_stderr = _setup_logging()
+    logger = server.logger
+
+    _initialize_globals()
+    _initialize_proxy_settings()
+    load_excluded_models(EXCLUDED_MODELS_FILENAME)
+    
+    server.is_initializing = True
+    logger.info("Starting AI Studio Proxy Server...")
+
+    try:
+        await _start_stream_proxy()
+        await _initialize_browser_and_page()
+        
+        launch_mode = os.environ.get('LAUNCH_MODE', 'unknown')
+        if server.is_page_ready or launch_mode == "direct_debug_no_browser":
+            server.worker_task = asyncio.create_task(queue_worker())
+            logger.info("Request processing worker started.")
+        else:
+            raise RuntimeError("Failed to initialize browser/page, worker not started.")
+
+        logger.info("Server startup complete.")
+        server.is_initializing = False
+        yield
+    except Exception as e:
+        logger.critical(f"Application startup failed: {e}", exc_info=True)
+        await _shutdown_resources()
+        raise RuntimeError(f"Application startup failed: {e}") from e
+    finally:
+        logger.info("Shutting down server...")
+        await _shutdown_resources()
+        restore_original_streams(initial_stdout, initial_stderr)
+        restore_original_streams(*original_streams)
+        logger.info("Server shutdown complete.")
+
+
+class APIKeyAuthMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app: ASGIApp):
+        super().__init__(app)
+        self.excluded_paths = [
+            "/v1/models",
+            "/health",
+            "/docs",
+            "/openapi.json",
+            # FastAPI 自动生成的其他文档路径
+            "/redoc",
+            "/favicon.ico"
+        ]
+
+    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable]):
+        if not auth_utils.API_KEYS:  # 如果 API_KEYS 为空，则不进行验证
+            return await call_next(request)
+
+        # 检查是否是需要保护的路径
+        if not request.url.path.startswith("/v1/"):
+            return await call_next(request)
+
+        # 检查是否是排除的路径
+        for excluded_path in self.excluded_paths:
+            if request.url.path == excluded_path or request.url.path.startswith(excluded_path + "/"):
+                return await call_next(request)
+
+        # 支持多种认证头格式以兼容OpenAI标准
+        api_key = None
+
+        # 1. 优先检查标准的 Authorization: Bearer <token> 头
+        auth_header = request.headers.get("Authorization")
+        if auth_header and auth_header.startswith("Bearer "):
+            api_key = auth_header[7:]  # 移除 "Bearer " 前缀
+
+        # 2. 回退到自定义的 X-API-Key 头（向后兼容）
+        if not api_key:
+            api_key = request.headers.get("X-API-Key")
+
+        if not api_key or not auth_utils.verify_api_key(api_key):
+            return JSONResponse(
+                status_code=401,
+                content={
+                    "error": {
+                        "message": "Invalid or missing API key. Please provide a valid API key using 'Authorization: Bearer <your_key>' or 'X-API-Key: <your_key>' header.",
+                        "type": "invalid_request_error",
+                        "param": None,
+                        "code": "invalid_api_key"
+                    }
+                }
+            )
+        return await call_next(request)
+
+def create_app() -> FastAPI:
+    """创建FastAPI应用实例"""
+    app = FastAPI(
+        title="AI Studio Proxy Server (集成模式)",
+        description="通过 Playwright与 AI Studio 交互的代理服务器。",
+        version="0.6.0-integrated",
+        lifespan=lifespan
+    )
+    
+    # 添加中间件
+    app.add_middleware(APIKeyAuthMiddleware)
+
+    # 注册路由
+    from .routes import (
+        read_index, get_css, get_js, get_api_info,
+        health_check, list_models, chat_completions,
+        cancel_request, get_queue_status, websocket_log_endpoint,
+        get_api_keys, add_api_key, test_api_key, delete_api_key
+    )
+    from fastapi.responses import FileResponse
+    
+    app.get("/", response_class=FileResponse)(read_index)
+    app.get("/webui.css")(get_css)
+    app.get("/webui.js")(get_js)
+    app.get("/api/info")(get_api_info)
+    app.get("/health")(health_check)
+    app.get("/v1/models")(list_models)
+    app.post("/v1/chat/completions")(chat_completions)
+    app.post("/v1/cancel/{req_id}")(cancel_request)
+    app.get("/v1/queue")(get_queue_status)
+    app.websocket("/ws/logs")(websocket_log_endpoint)
+
+    # API密钥管理端点
+    app.get("/api/keys")(get_api_keys)
+    app.post("/api/keys")(add_api_key)
+    app.post("/api/keys/test")(test_api_key)
+    app.delete("/api/keys")(delete_api_key)
+
+    return app

AIStudioProxyAPI/api_utils/auth_utils.py

@@ -0,0 +1,32 @@
+import os
+from typing import Set
+
+API_KEYS: Set[str] = set()
+KEY_FILE_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "auth_profiles", "key.txt")
+
+def load_api_keys():
+    """Loads API keys from the key file into the API_KEYS set."""
+    global API_KEYS
+    API_KEYS.clear()
+    if os.path.exists(KEY_FILE_PATH):
+        with open(KEY_FILE_PATH, "r") as f:
+            for line in f:
+                key = line.strip()
+                if key:
+                    API_KEYS.add(key)
+
+def initialize_keys():
+    """Initializes API keys. Ensures key.txt exists and loads keys."""
+    if not os.path.exists(KEY_FILE_PATH):
+        with open(KEY_FILE_PATH, "w") as f:
+            pass  # Create an empty file
+    load_api_keys()
+
+def verify_api_key(api_key_from_header: str) -> bool:
+    """
+    Verifies the API key.
+    Returns True if API_KEYS is empty (no validation) or if the key is valid.
+    """
+    if not API_KEYS:
+        return True
+    return api_key_from_header in API_KEYS

AIStudioProxyAPI/api_utils/dependencies.py

@@ -0,0 +1,57 @@
+"""
+FastAPI 依赖项模块
+"""
+import logging
+from asyncio import Queue, Lock, Event
+from typing import Dict, Any, List, Set
+
+from fastapi import Request
+
+def get_logger() -> logging.Logger:
+    from server import logger
+    return logger
+
+def get_log_ws_manager():
+    from server import log_ws_manager
+    return log_ws_manager
+
+def get_request_queue() -> Queue:
+    from server import request_queue
+    return request_queue
+
+def get_processing_lock() -> Lock:
+    from server import processing_lock
+    return processing_lock
+
+def get_worker_task():
+    from server import worker_task
+    return worker_task
+
+def get_server_state() -> Dict[str, Any]:
+    from server import is_initializing, is_playwright_ready, is_browser_connected, is_page_ready
+    return {
+        "is_initializing": is_initializing,
+        "is_playwright_ready": is_playwright_ready,
+        "is_browser_connected": is_browser_connected,
+        "is_page_ready": is_page_ready,
+    }
+
+def get_page_instance():
+    from server import page_instance
+    return page_instance
+
+def get_model_list_fetch_event() -> Event:
+    from server import model_list_fetch_event
+    return model_list_fetch_event
+
+def get_parsed_model_list() -> List[Dict[str, Any]]:
+    from server import parsed_model_list
+    return parsed_model_list
+
+def get_excluded_model_ids() -> Set[str]:
+    from server import excluded_model_ids
+    return excluded_model_ids
+
+def get_current_ai_studio_model_id() -> str:
+    from server import current_ai_studio_model_id
+    return current_ai_studio_model_id

AIStudioProxyAPI/api_utils/queue_worker.py

@@ -0,0 +1,351 @@
+"""
+队列工作器模块
+处理请求队列中的任务
+"""
+
+import asyncio
+import time
+from fastapi import HTTPException
+
+
+
+async def queue_worker():
+    """队列工作器，处理请求队列中的任务"""
+    # 导入全局变量
+    from server import (
+        logger, request_queue, processing_lock, model_switching_lock, 
+        params_cache_lock
+    )
+    
+    logger.info("--- 队列 Worker 已启动 ---")
+    
+    # 检查并初始化全局变量
+    if request_queue is None:
+        logger.info("初始化 request_queue...")
+        from asyncio import Queue
+        request_queue = Queue()
+    
+    if processing_lock is None:
+        logger.info("初始化 processing_lock...")
+        from asyncio import Lock
+        processing_lock = Lock()
+    
+    if model_switching_lock is None:
+        logger.info("初始化 model_switching_lock...")
+        from asyncio import Lock
+        model_switching_lock = Lock()
+    
+    if params_cache_lock is None:
+        logger.info("初始化 params_cache_lock...")
+        from asyncio import Lock
+        params_cache_lock = Lock()
+    
+    was_last_request_streaming = False
+    last_request_completion_time = 0
+    
+    while True:
+        request_item = None
+        result_future = None
+        req_id = "UNKNOWN"
+        completion_event = None
+        
+        try:
+            # 检查队列中的项目，清理已断开连接的请求
+            queue_size = request_queue.qsize()
+            if queue_size > 0:
+                checked_count = 0
+                items_to_requeue = []
+                processed_ids = set()
+                
+                while checked_count < queue_size and checked_count < 10:
+                    try:
+                        item = request_queue.get_nowait()
+                        item_req_id = item.get("req_id", "unknown")
+                        
+                        if item_req_id in processed_ids:
+                            items_to_requeue.append(item)
+                            continue
+                            
+                        processed_ids.add(item_req_id)
+                        
+                        if not item.get("cancelled", False):
+                            item_http_request = item.get("http_request")
+                            if item_http_request:
+                                try:
+                                    if await item_http_request.is_disconnected():
+                                        logger.info(f"[{item_req_id}] (Worker Queue Check) 检测到客户端已断开，标记为取消。")
+                                        item["cancelled"] = True
+                                        item_future = item.get("result_future")
+                                        if item_future and not item_future.done():
+                                            item_future.set_exception(HTTPException(status_code=499, detail=f"[{item_req_id}] Client disconnected while queued."))
+                                except Exception as check_err:
+                                    logger.error(f"[{item_req_id}] (Worker Queue Check) Error checking disconnect: {check_err}")
+                        
+                        items_to_requeue.append(item)
+                        checked_count += 1
+                    except asyncio.QueueEmpty:
+                        break
+                
+                for item in items_to_requeue:
+                    await request_queue.put(item)
+            
+            # 获取下一个请求
+            try:
+                request_item = await asyncio.wait_for(request_queue.get(), timeout=5.0)
+            except asyncio.TimeoutError:
+                # 如果5秒内没有新请求，继续循环检查
+                continue
+            
+            req_id = request_item["req_id"]
+            request_data = request_item["request_data"]
+            http_request = request_item["http_request"]
+            result_future = request_item["result_future"]
+
+            if request_item.get("cancelled", False):
+                logger.info(f"[{req_id}] (Worker) 请求已取消，跳过。")
+                if not result_future.done():
+                    result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] 请求已被用户取消"))
+                request_queue.task_done()
+                continue
+
+            is_streaming_request = request_data.stream
+            logger.info(f"[{req_id}] (Worker) 取出请求。模式: {'流式' if is_streaming_request else '非流式'}")
+
+            # 优化：在开始处理前主动检测客户端连接状态，避免不必要的处理
+            from api_utils.request_processor import _test_client_connection
+            is_connected = await _test_client_connection(req_id, http_request)
+            if not is_connected:
+                logger.info(f"[{req_id}] (Worker) ✅ 主动检测到客户端已断开，跳过处理节省资源")
+                if not result_future.done():
+                    result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] 客户端在处理前已断开连接"))
+                request_queue.task_done()
+                continue
+            
+            # 流式请求间隔控制
+            current_time = time.time()
+            if was_last_request_streaming and is_streaming_request and (current_time - last_request_completion_time < 1.0):
+                delay_time = max(0.5, 1.0 - (current_time - last_request_completion_time))
+                logger.info(f"[{req_id}] (Worker) 连续流式请求，添加 {delay_time:.2f}s 延迟...")
+                await asyncio.sleep(delay_time)
+            
+            # 等待锁前再次主动检测客户端连接
+            is_connected = await _test_client_connection(req_id, http_request)
+            if not is_connected:
+                logger.info(f"[{req_id}] (Worker) ✅ 等待锁时检测到客户端断开，取消处理")
+                if not result_future.done():
+                    result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] 客户端关闭了请求"))
+                request_queue.task_done()
+                continue
+            
+            logger.info(f"[{req_id}] (Worker) 等待处理锁...")
+            async with processing_lock:
+                logger.info(f"[{req_id}] (Worker) 已获取处理锁。开始核心处理...")
+                
+                # 获取锁后最终主动检测客户端连接
+                is_connected = await _test_client_connection(req_id, http_request)
+                if not is_connected:
+                    logger.info(f"[{req_id}] (Worker) ✅ 获取锁后检测到客户端断开，取消处理")
+                    if not result_future.done():
+                        result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] 客户端关闭了请求"))
+                elif result_future.done():
+                    logger.info(f"[{req_id}] (Worker) Future 在处理前已完成/取消。跳过。")
+                else:
+                    # 调用实际的请求处理函数
+                    try:
+                        from api_utils import _process_request_refactored
+                        returned_value = await _process_request_refactored(
+                            req_id, request_data, http_request, result_future
+                        )
+                        
+                        completion_event, submit_btn_loc, client_disco_checker = None, None, None
+                        current_request_was_streaming = False
+
+                        if isinstance(returned_value, tuple) and len(returned_value) == 3:
+                            completion_event, submit_btn_loc, client_disco_checker = returned_value
+                            if completion_event is not None:
+                                current_request_was_streaming = True
+                                logger.info(f"[{req_id}] (Worker) _process_request_refactored returned stream info (event, locator, checker).")
+                            else:
+                                current_request_was_streaming = False
+                                logger.info(f"[{req_id}] (Worker) _process_request_refactored returned a tuple, but completion_event is None (likely non-stream or early exit).")
+                        elif returned_value is None:
+                            current_request_was_streaming = False
+                            logger.info(f"[{req_id}] (Worker) _process_request_refactored returned non-stream completion (None).")
+                        else:
+                            current_request_was_streaming = False
+                            logger.warning(f"[{req_id}] (Worker) _process_request_refactored returned unexpected type: {type(returned_value)}")
+
+                        # 统一的客户端断开检测和响应处理
+                        if completion_event:
+                            # 流式模式：等待流式生成器完成信号
+                            logger.info(f"[{req_id}] (Worker) 等待流式生成器完成信号...")
+
+                            # 创建一个增强的客户端断开检测器，支持提前done信号触发
+                            client_disconnected_early = False
+
+                            async def enhanced_disconnect_monitor():
+                                nonlocal client_disconnected_early
+                                while not completion_event.is_set():
+                                    try:
+                                        # 主动检查客户端是否断开连接
+                                        is_connected = await _test_client_connection(req_id, http_request)
+                                        if not is_connected:
+                                            logger.info(f"[{req_id}] (Worker) ✅ 流式处理中检测到客户端断开，提前触发done信号")
+                                            client_disconnected_early = True
+                                            # 立即设置completion_event以提前结束等待
+                                            if not completion_event.is_set():
+                                                completion_event.set()
+                                            break
+                                        await asyncio.sleep(0.3)  # 更频繁的检查间隔
+                                    except Exception as e:
+                                        logger.error(f"[{req_id}] (Worker) 增强断开检测器错误: {e}")
+                                        break
+
+                            # 启动增强的断开连接监控
+                            disconnect_monitor_task = asyncio.create_task(enhanced_disconnect_monitor())
+                        else:
+                            # 非流式模式：等待处理完成并检测客户端断开
+                            logger.info(f"[{req_id}] (Worker) 非流式模式，等待处理完成...")
+
+                            client_disconnected_early = False
+
+                            async def non_streaming_disconnect_monitor():
+                                nonlocal client_disconnected_early
+                                while not result_future.done():
+                                    try:
+                                        # 主动检查客户端是否断开连接
+                                        is_connected = await _test_client_connection(req_id, http_request)
+                                        if not is_connected:
+                                            logger.info(f"[{req_id}] (Worker) ✅ 非流式处理中检测到客户端断开，取消处理")
+                                            client_disconnected_early = True
+                                            # 取消result_future
+                                            if not result_future.done():
+                                                result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] 客户端在非流式处理中断开连接"))
+                                            break
+                                        await asyncio.sleep(0.3)  # 更频繁的检查间隔
+                                    except Exception as e:
+                                        logger.error(f"[{req_id}] (Worker) 非流式断开检测器错误: {e}")
+                                        break
+
+                            # 启动非流式断开连接监控
+                            disconnect_monitor_task = asyncio.create_task(non_streaming_disconnect_monitor())
+
+                        # 等待处理完成（流式或非流式）
+                        try:
+                            if completion_event:
+                                # 流式模式：等待completion_event
+                                from server import RESPONSE_COMPLETION_TIMEOUT
+                                await asyncio.wait_for(completion_event.wait(), timeout=RESPONSE_COMPLETION_TIMEOUT/1000 + 60)
+                                logger.info(f"[{req_id}] (Worker) ✅ 流式生成器完成信号收到。客户端提前断开: {client_disconnected_early}")
+                            else:
+                                # 非流式模式：等待result_future完成
+                                from server import RESPONSE_COMPLETION_TIMEOUT
+                                await asyncio.wait_for(asyncio.shield(result_future), timeout=RESPONSE_COMPLETION_TIMEOUT/1000 + 60)
+                                logger.info(f"[{req_id}] (Worker) ✅ 非流式处理完成。客户端提前断开: {client_disconnected_early}")
+
+                            # 如果客户端提前断开，跳过按钮状态处理
+                            if client_disconnected_early:
+                                logger.info(f"[{req_id}] (Worker) 客户端提前断开，跳过按钮状态处理")
+                            elif submit_btn_loc and client_disco_checker and completion_event:
+                                    # 等待发送按钮禁用确认流式响应完全结束
+                                    logger.info(f"[{req_id}] (Worker) 流式响应完成，检查并处理发送按钮状态...")
+                                    wait_timeout_ms = 30000  # 30 seconds
+                                    try:
+                                        from playwright.async_api import expect as expect_async
+                                        from api_utils.request_processor import ClientDisconnectedError
+
+                                        # 检查客户端连接状态
+                                        client_disco_checker("流式响应后按钮状态检查 - 前置检查: ")
+                                        await asyncio.sleep(0.5)  # 给UI一点时间更新
+
+                                        # 检查按钮是否仍然启用，如果启用则直接点击停止
+                                        logger.info(f"[{req_id}] (Worker) 检查发送按钮状态...")
+                                        try:
+                                            is_button_enabled = await submit_btn_loc.is_enabled(timeout=2000)
+                                            logger.info(f"[{req_id}] (Worker) 发送按钮启用状态: {is_button_enabled}")
+
+                                            if is_button_enabled:
+                                                # 流式响应完成后按钮仍启用，直接点击停止
+                                                logger.info(f"[{req_id}] (Worker) 流式响应完成但按钮仍启用，主动点击按钮停止生成...")
+                                                await submit_btn_loc.click(timeout=5000, force=True)
+                                                logger.info(f"[{req_id}] (Worker) ✅ 发送按钮点击完成。")
+                                            else:
+                                                logger.info(f"[{req_id}] (Worker) 发送按钮已禁用，无需点击。")
+                                        except Exception as button_check_err:
+                                            logger.warning(f"[{req_id}] (Worker) 检查按钮状态失败: {button_check_err}")
+
+                                        # 等待按钮最终禁用
+                                        logger.info(f"[{req_id}] (Worker) 等待发送按钮最终禁用...")
+                                        await expect_async(submit_btn_loc).to_be_disabled(timeout=wait_timeout_ms)
+                                        logger.info(f"[{req_id}] ✅ 发送按钮已禁用。")
+
+                                    except Exception as e_pw_disabled:
+                                        logger.warning(f"[{req_id}] ⚠️ 流式响应后按钮状态处理超时或错误: {e_pw_disabled}")
+                                        from api_utils.request_processor import save_error_snapshot
+                                        await save_error_snapshot(f"stream_post_submit_button_handling_timeout_{req_id}")
+                                    except ClientDisconnectedError:
+                                        logger.info(f"[{req_id}] 客户端在流式响应后按钮状态处理时断开连接。")
+                            elif completion_event and current_request_was_streaming:
+                                logger.warning(f"[{req_id}] (Worker) 流式请求但 submit_btn_loc 或 client_disco_checker 未提供。跳过按钮禁用等待。")
+
+                        except asyncio.TimeoutError:
+                            logger.warning(f"[{req_id}] (Worker) ⚠️ 等待处理完成超时。")
+                            if not result_future.done():
+                                result_future.set_exception(HTTPException(status_code=504, detail=f"[{req_id}] Processing timed out waiting for completion."))
+                        except Exception as ev_wait_err:
+                            logger.error(f"[{req_id}] (Worker) ❌ 等待处理完成时出错: {ev_wait_err}")
+                            if not result_future.done():
+                                result_future.set_exception(HTTPException(status_code=500, detail=f"[{req_id}] Error waiting for completion: {ev_wait_err}"))
+                        finally:
+                            # 清理断开连接监控任务
+                            if 'disconnect_monitor_task' in locals() and not disconnect_monitor_task.done():
+                                disconnect_monitor_task.cancel()
+                                try:
+                                    await disconnect_monitor_task
+                                except asyncio.CancelledError:
+                                    pass
+
+                    except Exception as process_err:
+                        logger.error(f"[{req_id}] (Worker) _process_request_refactored execution error: {process_err}")
+                        if not result_future.done():
+                            result_future.set_exception(HTTPException(status_code=500, detail=f"[{req_id}] Request processing error: {process_err}"))
+            
+            logger.info(f"[{req_id}] (Worker) 释放处理锁。")
+
+            # 在释放处理锁后立即执行清空操作
+            try:
+                # 清空流式队列缓存
+                from api_utils import clear_stream_queue
+                await clear_stream_queue()
+
+                # 清空聊天历史（对于所有模式：流式和非流式）
+                if submit_btn_loc and client_disco_checker:
+                    from server import page_instance, is_page_ready
+                    if page_instance and is_page_ready:
+                        from browser_utils.page_controller import PageController
+                        page_controller = PageController(page_instance, logger, req_id)
+                        logger.info(f"[{req_id}] (Worker) 执行聊天历史清空（{'流式' if completion_event else '非流式'}模式）...")
+                        await page_controller.clear_chat_history(client_disco_checker)
+                        logger.info(f"[{req_id}] (Worker) ✅ 聊天历史清空完成。")
+                else:
+                    logger.info(f"[{req_id}] (Worker) 跳过聊天历史清空：缺少必要参数（submit_btn_loc: {bool(submit_btn_loc)}, client_disco_checker: {bool(client_disco_checker)}）")
+            except Exception as clear_err:
+                logger.error(f"[{req_id}] (Worker) 清空操作时发生错误: {clear_err}", exc_info=True)
+
+            was_last_request_streaming = is_streaming_request
+            last_request_completion_time = time.time()
+            
+        except asyncio.CancelledError:
+            logger.info("--- 队列 Worker 被取消 ---")
+            if result_future and not result_future.done():
+                result_future.cancel("Worker cancelled")
+            break
+        except Exception as e:
+            logger.error(f"[{req_id}] (Worker) ❌ 处理请求时发生意外错误: {e}", exc_info=True)
+            if result_future and not result_future.done():
+                result_future.set_exception(HTTPException(status_code=500, detail=f"[{req_id}] 服务器内部错误: {e}"))
+        finally:
+            if request_item:
+                request_queue.task_done()
+    
+    logger.info("--- 队列 Worker 已停止 ---") 

AIStudioProxyAPI/api_utils/request_processor.py

@@ -0,0 +1,884 @@
+"""
+请求处理器模块
+包含核心的请求处理逻辑
+"""
+
+import asyncio
+import json
+import os
+import random
+import time
+from typing import Optional, Tuple, Callable, AsyncGenerator
+from asyncio import Event, Future
+
+from fastapi import HTTPException, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+from playwright.async_api import Page as AsyncPage, Locator, Error as PlaywrightAsyncError, expect as expect_async
+
+# --- 配置模块导入 ---
+from config import *
+
+# --- models模块导入 ---
+from models import ChatCompletionRequest, ClientDisconnectedError
+
+# --- browser_utils模块导入 ---
+from browser_utils import (
+    switch_ai_studio_model,
+    save_error_snapshot
+)
+
+# --- api_utils模块导入 ---
+from .utils import (
+    validate_chat_request,
+    prepare_combined_prompt,
+    generate_sse_chunk,
+    generate_sse_stop_chunk,
+    use_stream_response,
+    calculate_usage_stats
+)
+from browser_utils.page_controller import PageController
+
+
+async def _initialize_request_context(req_id: str, request: ChatCompletionRequest) -> dict:
+    """初始化请求上下文"""
+    from server import (
+        logger, page_instance, is_page_ready, parsed_model_list,
+        current_ai_studio_model_id, model_switching_lock, page_params_cache,
+        params_cache_lock
+    )
+    
+    logger.info(f"[{req_id}] 开始处理请求...")
+    logger.info(f"[{req_id}]   请求参数 - Model: {request.model}, Stream: {request.stream}")
+    
+    context = {
+        'logger': logger,
+        'page': page_instance,
+        'is_page_ready': is_page_ready,
+        'parsed_model_list': parsed_model_list,
+        'current_ai_studio_model_id': current_ai_studio_model_id,
+        'model_switching_lock': model_switching_lock,
+        'page_params_cache': page_params_cache,
+        'params_cache_lock': params_cache_lock,
+        'is_streaming': request.stream,
+        'model_actually_switched': False,
+        'requested_model': request.model,
+        'model_id_to_use': None,
+        'needs_model_switching': False
+    }
+    
+    return context
+
+
+async def _analyze_model_requirements(req_id: str, context: dict, request: ChatCompletionRequest) -> dict:
+    """分析模型需求并确定是否需要切换"""
+    logger = context['logger']
+    current_ai_studio_model_id = context['current_ai_studio_model_id']
+    parsed_model_list = context['parsed_model_list']
+    requested_model = request.model
+    
+    if requested_model and requested_model != MODEL_NAME:
+        requested_model_id = requested_model.split('/')[-1]
+        logger.info(f"[{req_id}] 请求使用模型: {requested_model_id}")
+        
+        if parsed_model_list:
+            valid_model_ids = [m.get("id") for m in parsed_model_list]
+            if requested_model_id not in valid_model_ids:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"[{req_id}] Invalid model '{requested_model_id}'. Available models: {', '.join(valid_model_ids)}"
+                )
+        
+        context['model_id_to_use'] = requested_model_id
+        if current_ai_studio_model_id != requested_model_id:
+            context['needs_model_switching'] = True
+            logger.info(f"[{req_id}] 需要切换模型: 当前={current_ai_studio_model_id} -> 目标={requested_model_id}")
+    
+    return context
+
+
+async def _test_client_connection(req_id: str, http_request: Request) -> bool:
+    """通过发送测试数据包来主动检测客户端连接状态"""
+    try:
+        # 尝试发送一个小的测试数据包
+        test_chunk = "data: {\"type\":\"ping\"}\n\n"
+
+        # 获取底层的响应对象
+        if hasattr(http_request, '_receive'):
+            # 检查接收通道是否还活跃
+            try:
+                # 尝试非阻塞地检查是否有断开消息
+                import asyncio
+                receive_task = asyncio.create_task(http_request._receive())
+                done, pending = await asyncio.wait([receive_task], timeout=0.01)
+
+                if done:
+                    message = receive_task.result()
+                    if message.get("type") == "http.disconnect":
+                        return False
+                else:
+                    # 取消未完成的任务
+                    receive_task.cancel()
+                    try:
+                        await receive_task
+                    except asyncio.CancelledError:
+                        pass
+
+            except Exception:
+                # 如果检查过程中出现异常，可能表示连接有问题
+                return False
+
+        # 如果上述检查都通过，认为连接正常
+        return True
+
+    except Exception as e:
+        # 任何异常都认为连接已断开
+        return False
+
+async def _setup_disconnect_monitoring(req_id: str, http_request: Request, result_future: Future) -> Tuple[Event, asyncio.Task, Callable]:
+    """设置客户端断开连接监控"""
+    from server import logger
+
+    client_disconnected_event = Event()
+
+    async def check_disconnect_periodically():
+        while not client_disconnected_event.is_set():
+            try:
+                # 使用主动检测方法
+                is_connected = await _test_client_connection(req_id, http_request)
+                if not is_connected:
+                    logger.info(f"[{req_id}] 主动检测到客户端断开连接。")
+                    client_disconnected_event.set()
+                    if not result_future.done():
+                        result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] 客户端关闭了请求"))
+                    break
+
+                # 备用检查：使用原有的is_disconnected方法
+                if await http_request.is_disconnected():
+                    logger.info(f"[{req_id}] 备用检测到客户端断开连接。")
+                    client_disconnected_event.set()
+                    if not result_future.done():
+                        result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] 客户端关闭了请求"))
+                    break
+
+                await asyncio.sleep(0.3)  # 更频繁的检查间隔，从0.5秒改为0.3秒
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"[{req_id}] (Disco Check Task) 错误: {e}")
+                client_disconnected_event.set()
+                if not result_future.done():
+                    result_future.set_exception(HTTPException(status_code=500, detail=f"[{req_id}] Internal disconnect checker error: {e}"))
+                break
+
+    disconnect_check_task = asyncio.create_task(check_disconnect_periodically())
+
+    def check_client_disconnected(stage: str = ""):
+        if client_disconnected_event.is_set():
+            logger.info(f"[{req_id}] 在 '{stage}' 检测到客户端断开连接。")
+            raise ClientDisconnectedError(f"[{req_id}] Client disconnected at stage: {stage}")
+        return False
+
+    return client_disconnected_event, disconnect_check_task, check_client_disconnected
+
+
+async def _validate_page_status(req_id: str, context: dict, check_client_disconnected: Callable) -> None:
+    """验证页面状态"""
+    page = context['page']
+    is_page_ready = context['is_page_ready']
+    
+    if not page or page.is_closed() or not is_page_ready:
+        raise HTTPException(status_code=503, detail=f"[{req_id}] AI Studio 页面丢失或未就绪。", headers={"Retry-After": "30"})
+    
+    check_client_disconnected("Initial Page Check")
+
+
+async def _handle_model_switching(req_id: str, context: dict, check_client_disconnected: Callable) -> dict:
+    """处理模型切换逻辑"""
+    if not context['needs_model_switching']:
+        return context
+    
+    logger = context['logger']
+    page = context['page']
+    model_switching_lock = context['model_switching_lock']
+    model_id_to_use = context['model_id_to_use']
+    
+    import server
+    
+    async with model_switching_lock:
+        if server.current_ai_studio_model_id != model_id_to_use:
+            logger.info(f"[{req_id}] 准备切换模型: {server.current_ai_studio_model_id} -> {model_id_to_use}")
+            switch_success = await switch_ai_studio_model(page, model_id_to_use, req_id)
+            if switch_success:
+                server.current_ai_studio_model_id = model_id_to_use
+                context['model_actually_switched'] = True
+                context['current_ai_studio_model_id'] = model_id_to_use
+                logger.info(f"[{req_id}] ✅ 模型切换成功: {server.current_ai_studio_model_id}")
+            else:
+                await _handle_model_switch_failure(req_id, page, model_id_to_use, server.current_ai_studio_model_id, logger)
+    
+    return context
+
+
+async def _handle_model_switch_failure(req_id: str, page: AsyncPage, model_id_to_use: str, model_before_switch: str, logger) -> None:
+    """处理模型切换失败的情况"""
+    import server
+    
+    logger.warning(f"[{req_id}] ❌ 模型切换至 {model_id_to_use} 失败。")
+    # 尝试恢复全局状态
+    server.current_ai_studio_model_id = model_before_switch
+    
+    raise HTTPException(
+        status_code=422,
+        detail=f"[{req_id}] 未能切换到模型 '{model_id_to_use}'。请确保模型可用。"
+    )
+
+
+async def _handle_parameter_cache(req_id: str, context: dict) -> None:
+    """处理参数缓存"""
+    logger = context['logger']
+    params_cache_lock = context['params_cache_lock']
+    page_params_cache = context['page_params_cache']
+    current_ai_studio_model_id = context['current_ai_studio_model_id']
+    model_actually_switched = context['model_actually_switched']
+    
+    async with params_cache_lock:
+        cached_model_for_params = page_params_cache.get("last_known_model_id_for_params")
+        
+        if model_actually_switched or (current_ai_studio_model_id != cached_model_for_params):
+            logger.info(f"[{req_id}] 模型已更改，参数缓存失效。")
+            page_params_cache.clear()
+            page_params_cache["last_known_model_id_for_params"] = current_ai_studio_model_id
+
+
+async def _prepare_and_validate_request(req_id: str, request: ChatCompletionRequest, check_client_disconnected: Callable) -> str:
+    """准备和验证请求"""
+    try:
+        validate_chat_request(request.messages, req_id)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=f"[{req_id}] 无效请求: {e}")
+    
+    prepared_prompt = prepare_combined_prompt(request.messages, req_id)
+    check_client_disconnected("After Prompt Prep")
+    
+    return prepared_prompt
+
+async def _handle_response_processing(req_id: str, request: ChatCompletionRequest, page: AsyncPage,
+                                    context: dict, result_future: Future,
+                                    submit_button_locator: Locator, check_client_disconnected: Callable) -> Optional[Tuple[Event, Locator, Callable]]:
+    """处理响应生成"""
+    from server import logger
+    
+    is_streaming = request.stream
+    current_ai_studio_model_id = context.get('current_ai_studio_model_id')
+    
+    # 检查是否使用辅助流
+    stream_port = os.environ.get('STREAM_PORT')
+    use_stream = stream_port != '0'
+    
+    if use_stream:
+        return await _handle_auxiliary_stream_response(req_id, request, context, result_future, submit_button_locator, check_client_disconnected)
+    else:
+        return await _handle_playwright_response(req_id, request, page, context, result_future, submit_button_locator, check_client_disconnected)
+
+
+async def _handle_auxiliary_stream_response(req_id: str, request: ChatCompletionRequest, context: dict, 
+                                          result_future: Future, submit_button_locator: Locator, 
+                                          check_client_disconnected: Callable) -> Optional[Tuple[Event, Locator, Callable]]:
+    """使用辅助流处理响应"""
+    from server import logger
+    
+    is_streaming = request.stream
+    current_ai_studio_model_id = context.get('current_ai_studio_model_id')
+    
+    def generate_random_string(length):
+        charset = "abcdefghijklmnopqrstuvwxyz0123456789"
+        return ''.join(random.choice(charset) for _ in range(length))
+
+    if is_streaming:
+        try:
+            completion_event = Event()
+            
+            async def create_stream_generator_from_helper(event_to_set: Event) -> AsyncGenerator[str, None]:
+                last_reason_pos = 0
+                last_body_pos = 0
+                model_name_for_stream = current_ai_studio_model_id or MODEL_NAME
+                chat_completion_id = f"{CHAT_COMPLETION_ID_PREFIX}{req_id}-{int(time.time())}-{random.randint(100, 999)}"
+                created_timestamp = int(time.time())
+
+                # 用于收集完整内容以计算usage
+                full_reasoning_content = ""
+                full_body_content = ""
+
+                # 数据接收状态标记
+                data_receiving = False
+
+                try:
+                    async for raw_data in use_stream_response(req_id):
+                        # 标记数据接收状态
+                        data_receiving = True
+
+                        # 检查客户端是否断开连接
+                        try:
+                            check_client_disconnected(f"流式生成器循环 ({req_id}): ")
+                        except ClientDisconnectedError:
+                            logger.info(f"[{req_id}] 客户端断开连接，终止流式生成")
+                            # 如果正在接收数据时客户端断开，立即设置done信号
+                            if data_receiving and not event_to_set.is_set():
+                                logger.info(f"[{req_id}] 数据接收中客户端断开，立即设置done信号")
+                                event_to_set.set()
+                            break
+                        
+                        # 确保 data 是字典类型
+                        if isinstance(raw_data, str):
+                            try:
+                                data = json.loads(raw_data)
+                            except json.JSONDecodeError:
+                                logger.warning(f"[{req_id}] 无法解析流数据JSON: {raw_data}")
+                                continue
+                        elif isinstance(raw_data, dict):
+                            data = raw_data
+                        else:
+                            logger.warning(f"[{req_id}] 未知的流数据类型: {type(raw_data)}")
+                            continue
+                        
+                        # 确保必要的键存在
+                        if not isinstance(data, dict):
+                            logger.warning(f"[{req_id}] 数据不是字典类型: {data}")
+                            continue
+                        
+                        reason = data.get("reason", "")
+                        body = data.get("body", "")
+                        done = data.get("done", False)
+                        function = data.get("function", [])
+                        
+                        # 更新完整内容记录
+                        if reason:
+                            full_reasoning_content = reason
+                        if body:
+                            full_body_content = body
+                        
+                        # 处理推理内容
+                        if len(reason) > last_reason_pos:
+                            output = {
+                                "id": chat_completion_id,
+                                "object": "chat.completion.chunk",
+                                "model": model_name_for_stream,
+                                "created": created_timestamp,
+                                "choices":[{
+                                    "index": 0,
+                                    "delta":{
+                                        "role": "assistant",
+                                        "content": None,
+                                        "reasoning_content": reason[last_reason_pos:],
+                                    },
+                                    "finish_reason": None,
+                                    "native_finish_reason": None,
+                                }]
+                            }
+                            last_reason_pos = len(reason)
+                            yield f"data: {json.dumps(output, ensure_ascii=False, separators=(',', ':'))}\n\n"
+                        
+                        # 处理主体内容
+                        if len(body) > last_body_pos:
+                            finish_reason_val = None
+                            if done:
+                                finish_reason_val = "stop"
+                            
+                            delta_content = {"role": "assistant", "content": body[last_body_pos:]}
+                            choice_item = {
+                                "index": 0,
+                                "delta": delta_content,
+                                "finish_reason": finish_reason_val,
+                                "native_finish_reason": finish_reason_val,
+                            }
+
+                            if done and function and len(function) > 0:
+                                tool_calls_list = []
+                                for func_idx, function_call_data in enumerate(function):
+                                    tool_calls_list.append({
+                                        "id": f"call_{generate_random_string(24)}",
+                                        "index": func_idx,
+                                        "type": "function",
+                                        "function": {
+                                            "name": function_call_data["name"],
+                                            "arguments": json.dumps(function_call_data["params"]),
+                                        },
+                                    })
+                                delta_content["tool_calls"] = tool_calls_list
+                                choice_item["finish_reason"] = "tool_calls"
+                                choice_item["native_finish_reason"] = "tool_calls"
+                                delta_content["content"] = None
+
+                            output = {
+                                "id": chat_completion_id,
+                                "object": "chat.completion.chunk",
+                                "model": model_name_for_stream,
+                                "created": created_timestamp,
+                                "choices": [choice_item]
+                            }
+                            last_body_pos = len(body)
+                            yield f"data: {json.dumps(output, ensure_ascii=False, separators=(',', ':'))}\n\n"
+                        
+                        # 处理只有done=True但没有新内容的情况（仅有函数调用或纯结束）
+                        elif done:
+                            # 如果有函数调用但没有新的body内容
+                            if function and len(function) > 0:
+                                delta_content = {"role": "assistant", "content": None}
+                                tool_calls_list = []
+                                for func_idx, function_call_data in enumerate(function):
+                                    tool_calls_list.append({
+                                        "id": f"call_{generate_random_string(24)}",
+                                        "index": func_idx,
+                                        "type": "function",
+                                        "function": {
+                                            "name": function_call_data["name"],
+                                            "arguments": json.dumps(function_call_data["params"]),
+                                        },
+                                    })
+                                delta_content["tool_calls"] = tool_calls_list
+                                choice_item = {
+                                    "index": 0,
+                                    "delta": delta_content,
+                                    "finish_reason": "tool_calls",
+                                    "native_finish_reason": "tool_calls",
+                                }
+                            else:
+                                # 纯结束，没有新内容和函数调用
+                                choice_item = {
+                                    "index": 0,
+                                    "delta": {"role": "assistant"},
+                                    "finish_reason": "stop",
+                                    "native_finish_reason": "stop",
+                                }
+
+                            output = {
+                                "id": chat_completion_id,
+                                "object": "chat.completion.chunk",
+                                "model": model_name_for_stream,
+                                "created": created_timestamp,
+                                "choices": [choice_item]
+                            }
+                            yield f"data: {json.dumps(output, ensure_ascii=False, separators=(',', ':'))}\n\n"
+                
+                except ClientDisconnectedError:
+                    logger.info(f"[{req_id}] 流式生成器中检测到客户端断开连接")
+                    # 客户端断开时立即设置done信号
+                    if data_receiving and not event_to_set.is_set():
+                        logger.info(f"[{req_id}] 客户端断开异常处理中立即设置done信号")
+                        event_to_set.set()
+                except Exception as e:
+                    logger.error(f"[{req_id}] 流式生成器处理过程中发生错误: {e}", exc_info=True)
+                    # 发送错误信息给客户端
+                    try:
+                        error_chunk = {
+                            "id": chat_completion_id,
+                            "object": "chat.completion.chunk",
+                            "model": model_name_for_stream,
+                            "created": created_timestamp,
+                            "choices": [{
+                                "index": 0,
+                                "delta": {"role": "assistant", "content": f"\n\n[错误: {str(e)}]"},
+                                "finish_reason": "stop",
+                                "native_finish_reason": "stop",
+                            }]
+                        }
+                        yield f"data: {json.dumps(error_chunk, ensure_ascii=False, separators=(',', ':'))}\n\n"
+                    except Exception:
+                        pass  # 如果无法发送错误信息，继续处理结束逻辑
+                finally:
+                    # 计算usage统计
+                    try:
+                        usage_stats = calculate_usage_stats(
+                            [msg.model_dump() for msg in request.messages],
+                            full_body_content,
+                            full_reasoning_content
+                        )
+                        logger.info(f"[{req_id}] 计算的token使用统计: {usage_stats}")
+                        
+                        # 发送带usage的最终chunk
+                        final_chunk = {
+                            "id": chat_completion_id,
+                            "object": "chat.completion.chunk",
+                            "model": model_name_for_stream,
+                            "created": created_timestamp,
+                            "choices": [{
+                                "index": 0,
+                                "delta": {},
+                                "finish_reason": "stop",
+                                "native_finish_reason": "stop"
+                            }],
+                            "usage": usage_stats
+                        }
+                        yield f"data: {json.dumps(final_chunk, ensure_ascii=False, separators=(',', ':'))}\n\n"
+                        logger.info(f"[{req_id}] 已发送带usage统计的最终chunk")
+                        
+                    except Exception as usage_err:
+                        logger.error(f"[{req_id}] 计算或发送usage统计时出错: {usage_err}")
+                    
+                    # 确保总是发送 [DONE] 标记
+                    try:
+                        logger.info(f"[{req_id}] 流式生成器完成，发送 [DONE] 标记")
+                        yield "data: [DONE]\n\n"
+                    except Exception as done_err:
+                        logger.error(f"[{req_id}] 发送 [DONE] 标记时出错: {done_err}")
+                    
+                    # 确保事件被设置
+                    if not event_to_set.is_set():
+                        event_to_set.set()
+                        logger.info(f"[{req_id}] 流式生成器完成事件已设置")
+
+            stream_gen_func = create_stream_generator_from_helper(completion_event)
+            if not result_future.done():
+                result_future.set_result(StreamingResponse(stream_gen_func, media_type="text/event-stream"))
+            else:
+                if not completion_event.is_set():
+                    completion_event.set()
+            
+            return completion_event, submit_button_locator, check_client_disconnected
+
+        except Exception as e:
+            logger.error(f"[{req_id}] 从队列获取流式数据时出错: {e}", exc_info=True)
+            if completion_event and not completion_event.is_set():
+                completion_event.set()
+            raise
+
+    else:  # 非流式
+        content = None
+        reasoning_content = None
+        functions = None
+        final_data_from_aux_stream = None
+
+        async for raw_data in use_stream_response(req_id):
+            check_client_disconnected(f"非流式辅助流 - 循环中 ({req_id}): ")
+            
+            # 确保 data 是字典类型
+            if isinstance(raw_data, str):
+                try:
+                    data = json.loads(raw_data)
+                except json.JSONDecodeError:
+                    logger.warning(f"[{req_id}] 无法解析非流式数据JSON: {raw_data}")
+                    continue
+            elif isinstance(raw_data, dict):
+                data = raw_data
+            else:
+                logger.warning(f"[{req_id}] 非流式未知数据类型: {type(raw_data)}")
+                continue
+            
+            # 确保数据是字典类型
+            if not isinstance(data, dict):
+                logger.warning(f"[{req_id}] 非流式数据不是字典类型: {data}")
+                continue
+                
+            final_data_from_aux_stream = data
+            if data.get("done"):
+                content = data.get("body")
+                reasoning_content = data.get("reason")
+                functions = data.get("function")
+                break
+        
+        if final_data_from_aux_stream and final_data_from_aux_stream.get("reason") == "internal_timeout":
+            logger.error(f"[{req_id}] 非流式请求通过辅助流失败: 内部超时")
+            raise HTTPException(status_code=502, detail=f"[{req_id}] 辅助流处理错误 (内部超时)")
+
+        if final_data_from_aux_stream and final_data_from_aux_stream.get("done") is True and content is None:
+             logger.error(f"[{req_id}] 非流式请求通过辅助流完成但未提供内容")
+             raise HTTPException(status_code=502, detail=f"[{req_id}] 辅助流完成但未提供内容")
+
+        model_name_for_json = current_ai_studio_model_id or MODEL_NAME
+        message_payload = {"role": "assistant", "content": content}
+        finish_reason_val = "stop"
+
+        if functions and len(functions) > 0:
+            tool_calls_list = []
+            for func_idx, function_call_data in enumerate(functions):
+                tool_calls_list.append({
+                    "id": f"call_{generate_random_string(24)}",
+                    "index": func_idx,
+                    "type": "function",
+                    "function": {
+                        "name": function_call_data["name"],
+                        "arguments": json.dumps(function_call_data["params"]),
+                    },
+                })
+            message_payload["tool_calls"] = tool_calls_list
+            finish_reason_val = "tool_calls"
+            message_payload["content"] = None
+        
+        if reasoning_content:
+            message_payload["reasoning_content"] = reasoning_content
+
+        # 计算token使用统计
+        usage_stats = calculate_usage_stats(
+            [msg.model_dump() for msg in request.messages],
+            content or "",
+            reasoning_content
+        )
+
+        response_payload = {
+            "id": f"{CHAT_COMPLETION_ID_PREFIX}{req_id}-{int(time.time())}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": model_name_for_json,
+            "choices": [{
+                "index": 0,
+                "message": message_payload,
+                "finish_reason": finish_reason_val,
+                "native_finish_reason": finish_reason_val,
+            }],
+            "usage": usage_stats
+        }
+
+        if not result_future.done():
+            result_future.set_result(JSONResponse(content=response_payload))
+        return None
+
+
+async def _handle_playwright_response(req_id: str, request: ChatCompletionRequest, page: AsyncPage, 
+                                    context: dict, result_future: Future, submit_button_locator: Locator, 
+                                    check_client_disconnected: Callable) -> Optional[Tuple[Event, Locator, Callable]]:
+    """使用Playwright处理响应"""
+    from server import logger
+    
+    is_streaming = request.stream
+    current_ai_studio_model_id = context.get('current_ai_studio_model_id')
+    
+    logger.info(f"[{req_id}] 定位响应元素...")
+    response_container = page.locator(RESPONSE_CONTAINER_SELECTOR).last
+    response_element = response_container.locator(RESPONSE_TEXT_SELECTOR)
+    
+    try:
+        await expect_async(response_container).to_be_attached(timeout=20000)
+        check_client_disconnected("After Response Container Attached: ")
+        await expect_async(response_element).to_be_attached(timeout=90000)
+        logger.info(f"[{req_id}] 响应元素已定位。")
+    except (PlaywrightAsyncError, asyncio.TimeoutError, ClientDisconnectedError) as locate_err:
+        if isinstance(locate_err, ClientDisconnectedError):
+            raise
+        logger.error(f"[{req_id}] ❌ 错误: 定位响应元素失败或超时: {locate_err}")
+        await save_error_snapshot(f"response_locate_error_{req_id}")
+        raise HTTPException(status_code=502, detail=f"[{req_id}] 定位AI Studio响应元素失败: {locate_err}")
+    except Exception as locate_exc:
+        logger.exception(f"[{req_id}] ❌ 错误: 定位响应元素时意外错误")
+        await save_error_snapshot(f"response_locate_unexpected_{req_id}")
+        raise HTTPException(status_code=500, detail=f"[{req_id}] 定位响应元素时意外错误: {locate_exc}")
+
+    check_client_disconnected("After Response Element Located: ")
+
+    if is_streaming:
+        completion_event = Event()
+
+        async def create_response_stream_generator():
+            # 数据接收状态标记
+            data_receiving = False
+
+            try:
+                # 使用PageController获取响应
+                page_controller = PageController(page, logger, req_id)
+                final_content = await page_controller.get_response(check_client_disconnected)
+
+                # 标记数据接收状态
+                data_receiving = True
+
+                # 生成流式响应 - 保持Markdown格式
+                # 按行分割以保持换行符和Markdown结构
+                lines = final_content.split('\n')
+                for line_idx, line in enumerate(lines):
+                    # 检查客户端是否断开连接
+                    try:
+                        check_client_disconnected(f"Playwright流式生成器循环 ({req_id}): ")
+                    except ClientDisconnectedError:
+                        logger.info(f"[{req_id}] Playwright流式生成器中检测到客户端断开连接")
+                        # 如果正在接收数据时客户端断开，立即设置done信号
+                        if data_receiving and not completion_event.is_set():
+                            logger.info(f"[{req_id}] Playwright数据接收中客户端断开，立即设置done信号")
+                            completion_event.set()
+                        break
+
+                    # 输出当前行的内容（包括空行，以保持Markdown格式）
+                    if line:  # 非空行按字符分块输出
+                        chunk_size = 5  # 每次输出5个字符，平衡速度和体验
+                        for i in range(0, len(line), chunk_size):
+                            chunk = line[i:i+chunk_size]
+                            yield generate_sse_chunk(chunk, req_id, current_ai_studio_model_id or MODEL_NAME)
+                            await asyncio.sleep(0.03)  # 适中的输出速度
+
+                    # 添加换行符（除了最后一行）
+                    if line_idx < len(lines) - 1:
+                        yield generate_sse_chunk('\n', req_id, current_ai_studio_model_id or MODEL_NAME)
+                        await asyncio.sleep(0.01)
+                
+                # 计算并发送带usage的完成块
+                usage_stats = calculate_usage_stats(
+                    [msg.model_dump() for msg in request.messages],
+                    final_content,
+                    ""  # Playwright模式没有reasoning content
+                )
+                logger.info(f"[{req_id}] Playwright非流式计算的token使用统计: {usage_stats}")
+                
+                # 发送带usage的完成块
+                yield generate_sse_stop_chunk(req_id, current_ai_studio_model_id or MODEL_NAME, "stop", usage_stats)
+                
+            except ClientDisconnectedError:
+                logger.info(f"[{req_id}] Playwright���式生成器中检测到客户端断开连接")
+                # 客户端断开时立即设置done信号
+                if data_receiving and not completion_event.is_set():
+                    logger.info(f"[{req_id}] Playwright客户端断开异常处理中立即设置done信号")
+                    completion_event.set()
+            except Exception as e:
+                logger.error(f"[{req_id}] Playwright流式生成器处理过程中发生错误: {e}", exc_info=True)
+                # 发送错误信息给客户端
+                try:
+                    yield generate_sse_chunk(f"\n\n[错误: {str(e)}]", req_id, current_ai_studio_model_id or MODEL_NAME)
+                    yield generate_sse_stop_chunk(req_id, current_ai_studio_model_id or MODEL_NAME)
+                except Exception:
+                    pass  # 如果无法发送错误信息，继续处理结束逻辑
+            finally:
+                # 确保事件被设置
+                if not completion_event.is_set():
+                    completion_event.set()
+                    logger.info(f"[{req_id}] Playwright流式生成器完成事件已设置")
+
+        stream_gen_func = create_response_stream_generator()
+        if not result_future.done():
+            result_future.set_result(StreamingResponse(stream_gen_func, media_type="text/event-stream"))
+        
+        return completion_event, submit_button_locator, check_client_disconnected
+    else:
+        # 使用PageController获取响应
+        page_controller = PageController(page, logger, req_id)
+        final_content = await page_controller.get_response(check_client_disconnected)
+        
+        # 计算token使用统计
+        usage_stats = calculate_usage_stats(
+            [msg.model_dump() for msg in request.messages],
+            final_content,
+            ""  # Playwright模式没有reasoning content
+        )
+        logger.info(f"[{req_id}] Playwright非流式计算的token使用统计: {usage_stats}")
+        
+        response_payload = {
+            "id": f"{CHAT_COMPLETION_ID_PREFIX}{req_id}-{int(time.time())}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": current_ai_studio_model_id or MODEL_NAME,
+            "choices": [{
+                "index": 0,
+                "message": {"role": "assistant", "content": final_content},
+                "finish_reason": "stop"
+            }],
+            "usage": usage_stats
+        }
+        
+        if not result_future.done():
+            result_future.set_result(JSONResponse(content=response_payload))
+        
+        return None
+
+
+async def _cleanup_request_resources(req_id: str, disconnect_check_task: Optional[asyncio.Task], 
+                                   completion_event: Optional[Event], result_future: Future, 
+                                   is_streaming: bool) -> None:
+    """清理请求资源"""
+    from server import logger
+    
+    if disconnect_check_task and not disconnect_check_task.done():
+        disconnect_check_task.cancel()
+        try: 
+            await disconnect_check_task
+        except asyncio.CancelledError: 
+            pass
+        except Exception as task_clean_err: 
+            logger.error(f"[{req_id}] 清理任务时出错: {task_clean_err}")
+    
+    logger.info(f"[{req_id}] 处理完成。")
+    
+    if is_streaming and completion_event and not completion_event.is_set() and (result_future.done() and result_future.exception() is not None):
+         logger.warning(f"[{req_id}] 流式请求异常，确保完成事件已设置。")
+         completion_event.set()
+
+
+async def _process_request_refactored(
+    req_id: str,
+    request: ChatCompletionRequest,
+    http_request: Request,
+    result_future: Future
+) -> Optional[Tuple[Event, Locator, Callable[[str], bool]]]:
+    """核心请求处理函数 - 重构版本"""
+
+    # 优化：在开始任何处理前主动检测客户端连接状态
+    is_connected = await _test_client_connection(req_id, http_request)
+    if not is_connected:
+        from server import logger
+        logger.info(f"[{req_id}] ✅ 核心处理前检测到客户端断开，提前退出节省资源")
+        if not result_future.done():
+            result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] 客户端在处理开始前已断开连接"))
+        return None
+
+    context = await _initialize_request_context(req_id, request)
+    context = await _analyze_model_requirements(req_id, context, request)
+    
+    client_disconnected_event, disconnect_check_task, check_client_disconnected = await _setup_disconnect_monitoring(
+        req_id, http_request, result_future
+    )
+    
+    page = context['page']
+    submit_button_locator = page.locator(SUBMIT_BUTTON_SELECTOR) if page else None
+    completion_event = None
+    
+    try:
+        await _validate_page_status(req_id, context, check_client_disconnected)
+        
+        page_controller = PageController(page, context['logger'], req_id)
+
+        await _handle_model_switching(req_id, context, check_client_disconnected)
+        await _handle_parameter_cache(req_id, context)
+        
+        prepared_prompt,image_list = await _prepare_and_validate_request(req_id, request, check_client_disconnected)
+
+        # 使用PageController处理页面交互
+        # 注意：聊天历史清空已移至队列处理锁释放后执行
+
+        await page_controller.adjust_parameters(
+            request.model_dump(exclude_none=True), # 使用 exclude_none=True 避免传递None值
+            context['page_params_cache'],
+            context['params_cache_lock'],
+            context['model_id_to_use'],
+            context['parsed_model_list'],
+            check_client_disconnected
+        )
+
+        # 优化：在提交提示前再次检查客户端连接，避免不必要的后台请求
+        check_client_disconnected("提交提示前最终检查")
+
+        await page_controller.submit_prompt(prepared_prompt,image_list, check_client_disconnected)
+        
+        # 响应处理仍然需要在这里，因为它决定了是流式还是非流式，并设置future
+        response_result = await _handle_response_processing(
+            req_id, request, page, context, result_future, submit_button_locator, check_client_disconnected
+        )
+        
+        if response_result:
+            completion_event, _, _ = response_result
+        
+        return completion_event, submit_button_locator, check_client_disconnected
+        
+    except ClientDisconnectedError as disco_err:
+        context['logger'].info(f"[{req_id}] 捕获到客户端断开连接信号: {disco_err}")
+        if not result_future.done():
+             result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] Client disconnected during processing."))
+    except HTTPException as http_err:
+        context['logger'].warning(f"[{req_id}] 捕获到 HTTP 异常: {http_err.status_code} - {http_err.detail}")
+        if not result_future.done():
+            result_future.set_exception(http_err)
+    except PlaywrightAsyncError as pw_err:
+        context['logger'].error(f"[{req_id}] 捕获到 Playwright 错误: {pw_err}")
+        await save_error_snapshot(f"process_playwright_error_{req_id}")
+        if not result_future.done():
+            result_future.set_exception(HTTPException(status_code=502, detail=f"[{req_id}] Playwright interaction failed: {pw_err}"))
+    except Exception as e:
+        context['logger'].exception(f"[{req_id}] 捕获到意外错误")
+        await save_error_snapshot(f"process_unexpected_error_{req_id}")
+        if not result_future.done():
+            result_future.set_exception(HTTPException(status_code=500, detail=f"[{req_id}] Unexpected server error: {e}"))
+    finally:
+        await _cleanup_request_resources(req_id, disconnect_check_task, completion_event, result_future, request.stream)

AIStudioProxyAPI/api_utils/request_processor_backup.py

@@ -0,0 +1,274 @@
+"""
+请求处理器模块
+包含核心的请求处理逻辑
+"""
+
+import asyncio
+import json
+import os
+import random
+import time
+from typing import Optional, Tuple, Callable, AsyncGenerator
+from asyncio import Event, Future
+
+from fastapi import HTTPException, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+from playwright.async_api import Page as AsyncPage, Locator, Error as PlaywrightAsyncError, expect as expect_async, TimeoutError
+
+# --- 配置模块导入 ---
+from config import *
+
+# --- models模块导入 ---
+from models import ChatCompletionRequest, ClientDisconnectedError
+
+# --- browser_utils模块导入 ---
+from browser_utils import (
+    switch_ai_studio_model, 
+    save_error_snapshot,
+    _wait_for_response_completion,
+    _get_final_response_content,
+    detect_and_extract_page_error
+)
+
+# --- api_utils模块导入 ---
+from .utils import (
+    validate_chat_request, 
+    prepare_combined_prompt,
+    generate_sse_chunk,
+    generate_sse_stop_chunk,
+    generate_sse_error_chunk,
+    use_helper_get_response,
+    use_stream_response
+)
+
+
+async def _process_request_refactored(
+    req_id: str,
+    request: ChatCompletionRequest,
+    http_request: Request,
+    result_future: Future
+) -> Optional[Tuple[Event, Locator, Callable[[str], bool]]]:
+    """核心请求处理函数 - 完整版本"""
+    global current_ai_studio_model_id
+    
+    # 导入全局变量
+    from server import (
+        logger, page_instance, is_page_ready, parsed_model_list,
+        current_ai_studio_model_id, model_switching_lock, page_params_cache,
+        params_cache_lock
+    )
+    
+    model_actually_switched_in_current_api_call = False
+    logger.info(f"[{req_id}] (Refactored Process) 开始处理请求...")
+    logger.info(f"[{req_id}]   请求参数 - Model: {request.model}, Stream: {request.stream}")
+    logger.info(f"[{req_id}]   请求参数 - Temperature: {request.temperature}")
+    logger.info(f"[{req_id}]   请求参数 - Max Output Tokens: {request.max_output_tokens}")
+    logger.info(f"[{req_id}]   请求参数 - Stop Sequences: {request.stop}")
+    logger.info(f"[{req_id}]   请求参数 - Top P: {request.top_p}")
+    
+    is_streaming = request.stream
+    page: Optional[AsyncPage] = page_instance
+    completion_event: Optional[Event] = None
+    requested_model = request.model
+    model_id_to_use = None
+    needs_model_switching = False
+    
+    if requested_model and requested_model != MODEL_NAME:
+        requested_model_parts = requested_model.split('/')
+        requested_model_id = requested_model_parts[-1] if len(requested_model_parts) > 1 else requested_model
+        logger.info(f"[{req_id}] 请求使用模型: {requested_model_id}")
+        if parsed_model_list:
+            valid_model_ids = [m.get("id") for m in parsed_model_list]
+            if requested_model_id not in valid_model_ids:
+                logger.error(f"[{req_id}] ❌ 无效的模型ID: {requested_model_id}。可用模型: {valid_model_ids}")
+                raise HTTPException(status_code=400, detail=f"[{req_id}] Invalid model '{requested_model_id}'. Available models: {', '.join(valid_model_ids)}")
+        model_id_to_use = requested_model_id
+        if current_ai_studio_model_id != model_id_to_use:
+            needs_model_switching = True
+            logger.info(f"[{req_id}] 需要切换模型: 当前={current_ai_studio_model_id} -> 目标={model_id_to_use}")
+        else:
+            logger.info(f"[{req_id}] 请求模型与当前模型相同 ({model_id_to_use})，无需切换")
+    else:
+        logger.info(f"[{req_id}] 未指定具体模型或使用代理模型名称，将使用当前模型: {current_ai_studio_model_id or '未知'}")
+    
+    client_disconnected_event = Event()
+    disconnect_check_task = None
+    input_field_locator = page.locator(INPUT_SELECTOR) if page else None
+    submit_button_locator = page.locator(SUBMIT_BUTTON_SELECTOR) if page else None
+
+    async def check_disconnect_periodically():
+        while not client_disconnected_event.is_set():
+            try:
+                if await http_request.is_disconnected():
+                    logger.info(f"[{req_id}] (Disco Check Task) 客户端断开。设置事件并尝试停止。")
+                    client_disconnected_event.set()
+                    try:
+                        if submit_button_locator and await submit_button_locator.is_enabled(timeout=1500):
+                             if input_field_locator and await input_field_locator.input_value(timeout=1500) == '':
+                                 logger.info(f"[{req_id}] (Disco Check Task)   点击停止...")
+                                 await submit_button_locator.click(timeout=3000, force=True)
+                    except Exception as click_err: 
+                        logger.warning(f"[{req_id}] (Disco Check Task) 停止按钮点击失败: {click_err}")
+                    if not result_future.done(): 
+                        result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] 客户端在处理期间关闭了请求"))
+                    break
+                await asyncio.sleep(1.0)
+            except asyncio.CancelledError: 
+                break
+            except Exception as e:
+                logger.error(f"[{req_id}] (Disco Check Task) 错误: {e}")
+                client_disconnected_event.set()
+                if not result_future.done(): 
+                    result_future.set_exception(HTTPException(status_code=500, detail=f"[{req_id}] Internal disconnect checker error: {e}"))
+                break
+    
+    disconnect_check_task = asyncio.create_task(check_disconnect_periodically())
+    
+    def check_client_disconnected(*args):
+        msg_to_log = ""
+        if len(args) == 1 and isinstance(args[0], str):
+            msg_to_log = args[0]
+
+        if client_disconnected_event.is_set():
+            logger.info(f"[{req_id}] {msg_to_log}检测到客户端断开连接事件。")
+            raise ClientDisconnectedError(f"[{req_id}] Client disconnected event set.")
+        return False
+    
+    try:
+        if not page or page.is_closed() or not is_page_ready:
+            raise HTTPException(status_code=503, detail=f"[{req_id}] AI Studio 页面丢失或未就绪。", headers={"Retry-After": "30"})
+        
+        check_client_disconnected("Initial Page Check: ")
+        
+        # 模型切换逻辑
+        if needs_model_switching and model_id_to_use:
+            async with model_switching_lock:
+                model_before_switch_attempt = current_ai_studio_model_id
+                if current_ai_studio_model_id != model_id_to_use:
+                    logger.info(f"[{req_id}] 获取锁后准备切换: 当前内存中模型={current_ai_studio_model_id}, 目标={model_id_to_use}")
+                    switch_success = await switch_ai_studio_model(page, model_id_to_use, req_id)
+                    if switch_success:
+                        current_ai_studio_model_id = model_id_to_use
+                        model_actually_switched_in_current_api_call = True
+                        logger.info(f"[{req_id}] ✅ 模型切换成功。全局模型状态已更新为: {current_ai_studio_model_id}")
+                    else:
+                        logger.warning(f"[{req_id}] ❌ 模型切换至 {model_id_to_use} 失败 (AI Studio 未接受或覆盖了更改)。")
+                        active_model_id_after_fail = model_before_switch_attempt
+                        try:
+                            final_prefs_str_after_fail = await page.evaluate("() => localStorage.getItem('aiStudioUserPreference')")
+                            if final_prefs_str_after_fail:
+                                final_prefs_obj_after_fail = json.loads(final_prefs_str_after_fail)
+                                model_path_in_final_prefs = final_prefs_obj_after_fail.get("promptModel")
+                                if model_path_in_final_prefs and isinstance(model_path_in_final_prefs, str):
+                                    active_model_id_after_fail = model_path_in_final_prefs.split('/')[-1]
+                        except Exception as read_final_prefs_err:
+                            logger.error(f"[{req_id}] 切换失败后读取最终 localStorage 出错: {read_final_prefs_err}")
+                        current_ai_studio_model_id = active_model_id_after_fail
+                        logger.info(f"[{req_id}] 全局模型状态在切换失败后设置为 (或保持为): {current_ai_studio_model_id}")
+                        actual_displayed_model_name = "未知 (无法读取)"
+                        try:
+                            model_wrapper_locator = page.locator('#mat-select-value-0 mat-select-trigger').first
+                            actual_displayed_model_name = await model_wrapper_locator.inner_text(timeout=3000)
+                        except Exception:
+                            pass
+                        raise HTTPException(
+                            status_code=422,
+                            detail=f"[{req_id}] AI Studio 未能应用所请求的模型 '{model_id_to_use}' 或该模型不受支持。请选择 AI Studio 网页界面中可用的模型。当前实际生效的模型 ID 为 '{current_ai_studio_model_id}', 页面显示为 '{actual_displayed_model_name}'."
+                        )
+                else:
+                    logger.info(f"[{req_id}] 获取锁后发现模型已是目标模型 {current_ai_studio_model_id}，无需切换")
+        
+        # 参数缓存处理
+        async with params_cache_lock:
+            cached_model_for_params = page_params_cache.get("last_known_model_id_for_params")
+            if model_actually_switched_in_current_api_call or \
+               (current_ai_studio_model_id is not None and current_ai_studio_model_id != cached_model_for_params):
+                action_taken = "Invalidating" if page_params_cache else "Initializing"
+                logger.info(f"[{req_id}] {action_taken} parameter cache. Reason: Model context changed (switched this call: {model_actually_switched_in_current_api_call}, current model: {current_ai_studio_model_id}, cache model: {cached_model_for_params}).")
+                page_params_cache.clear()
+                if current_ai_studio_model_id:
+                    page_params_cache["last_known_model_id_for_params"] = current_ai_studio_model_id
+            else:
+                logger.debug(f"[{req_id}] Parameter cache for model '{cached_model_for_params}' remains valid (current model: '{current_ai_studio_model_id}', switched this call: {model_actually_switched_in_current_api_call}).")
+        
+        # 验证请求
+        try: 
+            validate_chat_request(request.messages, req_id)
+        except ValueError as e: 
+            raise HTTPException(status_code=400, detail=f"[{req_id}] 无效请求: {e}")
+        
+        # 准备提示
+        prepared_prompt,image_list = prepare_combined_prompt(request.messages, req_id)
+        check_client_disconnected("After Prompt Prep: ")
+        
+        # 这里需要添加完整的处理逻辑 - 由于函数太长，暂时返回简化响应
+        logger.info(f"[{req_id}] (Refactored Process) 处理完整逻辑 - 需要从备份恢复剩余部分")
+        
+        # 简单响应用于测试
+        if is_streaming:
+            completion_event = Event()
+            
+            async def create_simple_stream_generator():
+                try:
+                    yield generate_sse_chunk("正在处理请求...", req_id, MODEL_NAME)
+                    await asyncio.sleep(1)
+                    yield generate_sse_chunk("处理完成", req_id, MODEL_NAME)
+                    yield generate_sse_stop_chunk(req_id, MODEL_NAME)
+                    yield "data: [DONE]\n\n"
+                finally:
+                    if not completion_event.is_set():
+                        completion_event.set()
+            
+            if not result_future.done():
+                result_future.set_result(StreamingResponse(create_simple_stream_generator(), media_type="text/event-stream"))
+            
+            return completion_event, submit_button_locator, check_client_disconnected
+        else:
+            response_payload = {
+                "id": f"{CHAT_COMPLETION_ID_PREFIX}{req_id}-{int(time.time())}",
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": MODEL_NAME,
+                "choices": [{
+                    "index": 0,
+                    "message": {"role": "assistant", "content": "处理完成 - 需要完整逻辑"},
+                    "finish_reason": "stop"
+                }],
+                "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+            }
+            
+            if not result_future.done():
+                result_future.set_result(JSONResponse(content=response_payload))
+            
+            return None
+        
+    except ClientDisconnectedError as disco_err:
+        logger.info(f"[{req_id}] (Refactored Process) 捕获到客户端断开连接信号: {disco_err}")
+        if not result_future.done():
+             result_future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] Client disconnected during processing."))
+    except HTTPException as http_err:
+        logger.warning(f"[{req_id}] (Refactored Process) 捕获到 HTTP 异常: {http_err.status_code} - {http_err.detail}")
+        if not result_future.done(): 
+            result_future.set_exception(http_err)
+    except Exception as e:
+        logger.exception(f"[{req_id}] (Refactored Process) 捕获到意外错误")
+        await save_error_snapshot(f"process_unexpected_error_{req_id}")
+        if not result_future.done(): 
+            result_future.set_exception(HTTPException(status_code=500, detail=f"[{req_id}] Unexpected server error: {e}"))
+    finally:
+        if disconnect_check_task and not disconnect_check_task.done():
+            disconnect_check_task.cancel()
+            try: 
+                await disconnect_check_task
+            except asyncio.CancelledError: 
+                pass
+            except Exception as task_clean_err: 
+                logger.error(f"[{req_id}] 清理任务时出错: {task_clean_err}")
+        
+        logger.info(f"[{req_id}] (Refactored Process) 处理完成。")
+        
+        if is_streaming and completion_event and not completion_event.is_set() and (result_future.done() and result_future.exception() is not None):
+             logger.warning(f"[{req_id}] (Refactored Process) 流式请求异常，确保完成事件已设置。")
+             completion_event.set()
+        
+        return completion_event, submit_button_locator, check_client_disconnected 

AIStudioProxyAPI/api_utils/routes.py

@@ -0,0 +1,385 @@
+"""
+FastAPI路由处理器模块
+包含所有API端点的处理函数
+"""
+
+import asyncio
+import os
+import random
+import time
+import uuid
+from typing import Dict, List, Any, Set
+from asyncio import Queue, Future, Lock, Event
+import logging
+
+from fastapi import HTTPException, Request, WebSocket, WebSocketDisconnect, Depends
+from fastapi.responses import JSONResponse, FileResponse
+from pydantic import BaseModel
+from playwright.async_api import Page as AsyncPage
+
+# --- 配置模块导入 ---
+from config import *
+
+# --- models模块导入 ---
+from models import ChatCompletionRequest, WebSocketConnectionManager
+
+# --- browser_utils模块导入 ---
+from browser_utils import _handle_model_list_response
+
+# --- 依赖项导入 ---
+from .dependencies import *
+
+
+# --- 静态文件端点 ---
+async def read_index(logger: logging.Logger = Depends(get_logger)):
+    """返回主页面"""
+    index_html_path = os.path.join(os.path.dirname(__file__), "..", "index.html")
+    if not os.path.exists(index_html_path):
+        logger.error(f"index.html not found at {index_html_path}")
+        raise HTTPException(status_code=404, detail="index.html not found")
+    return FileResponse(index_html_path)
+
+
+async def get_css(logger: logging.Logger = Depends(get_logger)):
+    """返回CSS文件"""
+    css_path = os.path.join(os.path.dirname(__file__), "..", "webui.css")
+    if not os.path.exists(css_path):
+        logger.error(f"webui.css not found at {css_path}")
+        raise HTTPException(status_code=404, detail="webui.css not found")
+    return FileResponse(css_path, media_type="text/css")
+
+
+async def get_js(logger: logging.Logger = Depends(get_logger)):
+    """返回JavaScript文件"""
+    js_path = os.path.join(os.path.dirname(__file__), "..", "webui.js")
+    if not os.path.exists(js_path):
+        logger.error(f"webui.js not found at {js_path}")
+        raise HTTPException(status_code=404, detail="webui.js not found")
+    return FileResponse(js_path, media_type="application/javascript")
+
+
+# --- API信息端点 ---
+async def get_api_info(request: Request, current_ai_studio_model_id: str = Depends(get_current_ai_studio_model_id)):
+    """返回API信息"""
+    from api_utils import auth_utils
+
+    server_port = request.url.port or os.environ.get('SERVER_PORT_INFO', '8000')
+    host = request.headers.get('host') or f"127.0.0.1:{server_port}"
+    scheme = request.headers.get('x-forwarded-proto', 'http')
+    base_url = f"{scheme}://{host}"
+    api_base = f"{base_url}/v1"
+    effective_model_name = current_ai_studio_model_id or MODEL_NAME
+
+    api_key_required = bool(auth_utils.API_KEYS)
+    api_key_count = len(auth_utils.API_KEYS)
+
+    if api_key_required:
+        message = f"API Key is required. {api_key_count} valid key(s) configured."
+    else:
+        message = "API Key is not required."
+
+    return JSONResponse(content={
+        "model_name": effective_model_name,
+        "api_base_url": api_base,
+        "server_base_url": base_url,
+        "api_key_required": api_key_required,
+        "api_key_count": api_key_count,
+        "auth_header": "Authorization: Bearer <token> or X-API-Key: <token>" if api_key_required else None,
+        "openai_compatible": True,
+        "supported_auth_methods": ["Authorization: Bearer", "X-API-Key"] if api_key_required else [],
+        "message": message
+    })
+
+
+# --- 健康检查端点 ---
+async def health_check(
+    server_state: Dict[str, Any] = Depends(get_server_state),
+    worker_task = Depends(get_worker_task),
+    request_queue: Queue = Depends(get_request_queue)
+):
+    """健康检查"""
+    is_worker_running = bool(worker_task and not worker_task.done())
+    launch_mode = os.environ.get('LAUNCH_MODE', 'unknown')
+    browser_page_critical = launch_mode != "direct_debug_no_browser"
+    
+    core_ready_conditions = [not server_state["is_initializing"], server_state["is_playwright_ready"]]
+    if browser_page_critical:
+        core_ready_conditions.extend([server_state["is_browser_connected"], server_state["is_page_ready"]])
+    
+    is_core_ready = all(core_ready_conditions)
+    status_val = "OK" if is_core_ready and is_worker_running else "Error"
+    q_size = request_queue.qsize() if request_queue else -1
+    
+    status_message_parts = []
+    if server_state["is_initializing"]: status_message_parts.append("初始化进行中")
+    if not server_state["is_playwright_ready"]: status_message_parts.append("Playwright 未就绪")
+    if browser_page_critical:
+        if not server_state["is_browser_connected"]: status_message_parts.append("浏览器未连接")
+        if not server_state["is_page_ready"]: status_message_parts.append("页面未就绪")
+    if not is_worker_running: status_message_parts.append("Worker 未运行")
+    
+    status = {
+        "status": status_val,
+        "message": "",
+        "details": {**server_state, "workerRunning": is_worker_running, "queueLength": q_size, "launchMode": launch_mode, "browserAndPageCritical": browser_page_critical}
+    }
+    
+    if status_val == "OK":
+        status["message"] = f"服务运行中;队列长度: {q_size}。"
+        return JSONResponse(content=status, status_code=200)
+    else:
+        status["message"] = f"服务不可用;问题: {(', '.join(status_message_parts) or '未知原因')}. 队列长度: {q_size}."
+        return JSONResponse(content=status, status_code=503)
+
+
+# --- 模型列表端点 ---
+async def list_models(
+    logger: logging.Logger = Depends(get_logger),
+    model_list_fetch_event: Event = Depends(get_model_list_fetch_event),
+    page_instance: AsyncPage = Depends(get_page_instance),
+    parsed_model_list: List[Dict[str, Any]] = Depends(get_parsed_model_list),
+    excluded_model_ids: Set[str] = Depends(get_excluded_model_ids)
+):
+    """获取模型列表"""
+    logger.info("[API] 收到 /v1/models 请求。")
+    
+    if not model_list_fetch_event.is_set() and page_instance and not page_instance.is_closed():
+        logger.info("/v1/models: 模型列表事件未设置，尝试刷新页面...")
+        try:
+            await page_instance.reload(wait_until="domcontentloaded", timeout=20000)
+            await asyncio.wait_for(model_list_fetch_event.wait(), timeout=10.0)
+        except Exception as e:
+            logger.error(f"/v1/models: 刷新或等待模型列表时出错: {e}")
+        finally:
+            if not model_list_fetch_event.is_set():
+                model_list_fetch_event.set()
+    
+    if parsed_model_list:
+        final_model_list = [m for m in parsed_model_list if m.get("id") not in excluded_model_ids]
+        return {"object": "list", "data": final_model_list}
+    else:
+        logger.warning("模型列表为空，返回默认后备模型。")
+        return {"object": "list", "data": [{
+            "id": DEFAULT_FALLBACK_MODEL_ID, "object": "model", "created": int(time.time()),
+            "owned_by": "camoufox-proxy-fallback"
+        }]}
+
+
+# --- 聊天完成端点 ---
+async def chat_completions(
+    request: ChatCompletionRequest,
+    http_request: Request,
+    logger: logging.Logger = Depends(get_logger),
+    request_queue: Queue = Depends(get_request_queue),
+    server_state: Dict[str, Any] = Depends(get_server_state),
+    worker_task = Depends(get_worker_task)
+):
+    """处理聊天完成请求"""
+    req_id = ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=7))
+    logger.info(f"[{req_id}] 收到 /v1/chat/completions 请求 (Stream={request.stream})")
+    
+    launch_mode = os.environ.get('LAUNCH_MODE', 'unknown')
+    browser_page_critical = launch_mode != "direct_debug_no_browser"
+    
+    service_unavailable = server_state["is_initializing"] or \
+                          not server_state["is_playwright_ready"] or \
+                          (browser_page_critical and (not server_state["is_page_ready"] or not server_state["is_browser_connected"])) or \
+                          not worker_task or worker_task.done()
+    
+    if service_unavailable:
+        raise HTTPException(status_code=503, detail=f"[{req_id}] 服务当前不可用。请稍后重试。", headers={"Retry-After": "30"})
+    
+    result_future = Future()
+    await request_queue.put({
+        "req_id": req_id, "request_data": request, "http_request": http_request,
+        "result_future": result_future, "enqueue_time": time.time(), "cancelled": False
+    })
+    
+    try:
+        timeout_seconds = RESPONSE_COMPLETION_TIMEOUT / 1000 + 120
+        return await asyncio.wait_for(result_future, timeout=timeout_seconds)
+    except asyncio.TimeoutError:
+        raise HTTPException(status_code=504, detail=f"[{req_id}] 请求处理超时。")
+    except asyncio.CancelledError:
+        raise HTTPException(status_code=499, detail=f"[{req_id}] 请求被客户端取消。")
+    except HTTPException as http_exc:
+        # 对于客户端断开连接的情况，使用更友好的日志级别
+        if http_exc.status_code == 499:
+            logger.info(f"[{req_id}] 客户端断开连接: {http_exc.detail}")
+        else:
+            logger.warning(f"[{req_id}] HTTP异常: {http_exc.detail}")
+        raise http_exc
+    except Exception as e:
+        logger.exception(f"[{req_id}] 等待Worker响应时出错")
+        raise HTTPException(status_code=500, detail=f"[{req_id}] 服务器内部错误: {e}")
+
+
+# --- 取消请求相关 ---
+async def cancel_queued_request(req_id: str, request_queue: Queue, logger: logging.Logger) -> bool:
+    """取消队列中的请求"""
+    items_to_requeue = []
+    found = False
+    try:
+        while not request_queue.empty():
+            item = request_queue.get_nowait()
+            if item.get("req_id") == req_id:
+                logger.info(f"[{req_id}] 在队列中找到请求，标记为已取消。")
+                item["cancelled"] = True
+                if (future := item.get("result_future")) and not future.done():
+                    future.set_exception(HTTPException(status_code=499, detail=f"[{req_id}] Request cancelled."))
+                found = True
+            items_to_requeue.append(item)
+    finally:
+        for item in items_to_requeue:
+            await request_queue.put(item)
+    return found
+
+
+async def cancel_request(
+    req_id: str,
+    logger: logging.Logger = Depends(get_logger),
+    request_queue: Queue = Depends(get_request_queue)
+):
+    """取消请求端点"""
+    logger.info(f"[{req_id}] 收到取消请求。")
+    if await cancel_queued_request(req_id, request_queue, logger):
+        return JSONResponse(content={"success": True, "message": f"Request {req_id} marked as cancelled."})
+    else:
+        return JSONResponse(status_code=404, content={"success": False, "message": f"Request {req_id} not found in queue."})
+
+
+# --- 队列状态端点 ---
+async def get_queue_status(
+    request_queue: Queue = Depends(get_request_queue),
+    processing_lock: Lock = Depends(get_processing_lock)
+):
+    """获取队列状态"""
+    queue_items = list(request_queue._queue)
+    return JSONResponse(content={
+        "queue_length": len(queue_items),
+        "is_processing_locked": processing_lock.locked(),
+        "items": sorted([
+            {
+                "req_id": item.get("req_id", "unknown"),
+                "enqueue_time": item.get("enqueue_time", 0),
+                "wait_time_seconds": round(time.time() - item.get("enqueue_time", 0), 2),
+                "is_streaming": item.get("request_data").stream,
+                "cancelled": item.get("cancelled", False)
+            } for item in queue_items
+        ], key=lambda x: x.get("enqueue_time", 0))
+    })
+
+
+# --- WebSocket日志端点 ---
+async def websocket_log_endpoint(
+    websocket: WebSocket,
+    logger: logging.Logger = Depends(get_logger),
+    log_ws_manager: WebSocketConnectionManager = Depends(get_log_ws_manager)
+):
+    """WebSocket日志端点"""
+    if not log_ws_manager:
+        await websocket.close(code=1011)
+        return
+    
+    client_id = str(uuid.uuid4())
+    try:
+        await log_ws_manager.connect(client_id, websocket)
+        while True:
+            await websocket.receive_text() # Keep connection alive
+    except WebSocketDisconnect:
+        pass
+    except Exception as e:
+        logger.error(f"日志 WebSocket (客户端 {client_id}) 发生异常: {e}", exc_info=True)
+    finally:
+        log_ws_manager.disconnect(client_id)
+
+
+# --- API密钥管理数据模型 ---
+class ApiKeyRequest(BaseModel):
+    key: str
+
+class ApiKeyTestRequest(BaseModel):
+    key: str
+
+
+# --- API密钥管理端点 ---
+async def get_api_keys(logger: logging.Logger = Depends(get_logger)):
+    """获取API密钥列表"""
+    from api_utils import auth_utils
+    try:
+        auth_utils.initialize_keys()
+        keys_info = [{"value": key, "status": "有效"} for key in auth_utils.API_KEYS]
+        return JSONResponse(content={"success": True, "keys": keys_info, "total_count": len(keys_info)})
+    except Exception as e:
+        logger.error(f"获取API密钥列表失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def add_api_key(request: ApiKeyRequest, logger: logging.Logger = Depends(get_logger)):
+    """添加API密钥"""
+    from api_utils import auth_utils
+    key_value = request.key.strip()
+    if not key_value or len(key_value) < 8:
+        raise HTTPException(status_code=400, detail="无效的API密钥格式。")
+    
+    auth_utils.initialize_keys()
+    if key_value in auth_utils.API_KEYS:
+        raise HTTPException(status_code=400, detail="该API密钥已存在。")
+
+    try:
+        # --- MODIFIED LINE ---
+        # Use the centralized path from auth_utils
+        key_file_path = auth_utils.KEY_FILE_PATH
+        with open(key_file_path, 'a+', encoding='utf-8') as f:
+            f.seek(0)
+            if f.read(): f.write("\n")
+            f.write(key_value)
+        
+        auth_utils.initialize_keys()
+        logger.info(f"API密钥已添加: {key_value[:4]}...{key_value[-4:]}")
+        return JSONResponse(content={"success": True, "message": "API密钥添加成功", "key_count": len(auth_utils.API_KEYS)})
+    except Exception as e:
+        logger.error(f"添加API密钥失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def test_api_key(request: ApiKeyTestRequest, logger: logging.Logger = Depends(get_logger)):
+    """测试API密钥"""
+    from api_utils import auth_utils
+    key_value = request.key.strip()
+    if not key_value:
+        raise HTTPException(status_code=400, detail="API密钥不能为空。")
+    
+    auth_utils.initialize_keys()
+    is_valid = auth_utils.verify_api_key(key_value)
+    logger.info(f"API密钥测试: {key_value[:4]}...{key_value[-4:]} - {'有效' if is_valid else '���效'}")
+    return JSONResponse(content={"success": True, "valid": is_valid, "message": "密钥有效" if is_valid else "密钥无效或不存在"})
+
+
+async def delete_api_key(request: ApiKeyRequest, logger: logging.Logger = Depends(get_logger)):
+    """删除API密钥"""
+    from api_utils import auth_utils
+    key_value = request.key.strip()
+    if not key_value:
+        raise HTTPException(status_code=400, detail="API密钥不能为空。")
+
+    auth_utils.initialize_keys()
+    if key_value not in auth_utils.API_KEYS:
+        raise HTTPException(status_code=404, detail="API密钥不存在。")
+
+    try:
+        # --- MODIFIED LINE ---
+        # Use the centralized path from auth_utils
+        key_file_path = auth_utils.KEY_FILE_PATH
+        with open(key_file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+        
+        with open(key_file_path, 'w', encoding='utf-8') as f:
+            f.writelines(line for line in lines if line.strip() != key_value)
+            
+        auth_utils.initialize_keys()
+        logger.info(f"API密钥已删除: {key_value[:4]}...{key_value[-4:]}")
+        return JSONResponse(content={"success": True, "message": "API密钥删除成功", "key_count": len(auth_utils.API_KEYS)})
+    except Exception as e:
+        logger.error(f"删除API密钥失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

AIStudioProxyAPI/api_utils/utils.py

@@ -0,0 +1,428 @@
+"""
+API工具函数模块
+包含SSE生成、流处理、token统计和请求验证等工具函数
+"""
+
+import asyncio
+import json
+import time
+import datetime
+from typing import Any, Dict, List, Optional, AsyncGenerator
+from asyncio import Queue
+from models import Message
+import re
+import base64
+import requests
+import os
+import hashlib
+
+
+# --- SSE生成函数 ---
+def generate_sse_chunk(delta: str, req_id: str, model: str) -> str:
+    """生成SSE数据块"""
+    chunk_data = {
+        "id": f"chatcmpl-{req_id}",
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [{"index": 0, "delta": {"content": delta}, "finish_reason": None}]
+    }
+    return f"data: {json.dumps(chunk_data)}\n\n"
+
+
+def generate_sse_stop_chunk(req_id: str, model: str, reason: str = "stop", usage: dict = None) -> str:
+    """生成SSE停止块"""
+    stop_chunk_data = {
+        "id": f"chatcmpl-{req_id}",
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [{"index": 0, "delta": {}, "finish_reason": reason}]
+    }
+    
+    # 添加usage信息（如果提供）
+    if usage:
+        stop_chunk_data["usage"] = usage
+    
+    return f"data: {json.dumps(stop_chunk_data)}\n\ndata: [DONE]\n\n"
+
+
+def generate_sse_error_chunk(message: str, req_id: str, error_type: str = "server_error") -> str:
+    """生成SSE错误块"""
+    error_chunk = {"error": {"message": message, "type": error_type, "param": None, "code": req_id}}
+    return f"data: {json.dumps(error_chunk)}\n\n"
+
+
+# --- 流处理工具函数 ---
+async def use_stream_response(req_id: str) -> AsyncGenerator[Any, None]:
+    """使用流响应（从服务器的全局队列获取数据）"""
+    from server import STREAM_QUEUE, logger
+    import queue
+    
+    if STREAM_QUEUE is None:
+        logger.warning(f"[{req_id}] STREAM_QUEUE is None, 无法使用流响应")
+        return
+    
+    logger.info(f"[{req_id}] 开始使用流响应")
+    
+    empty_count = 0
+    max_empty_retries = 300  # 30秒超时
+    data_received = False
+    
+    try:
+        while True:
+            try:
+                # 从队列中获取数据
+                data = STREAM_QUEUE.get_nowait()
+                if data is None:  # 结束标志
+                    logger.info(f"[{req_id}] 接收到流结束标志")
+                    break
+                
+                # 重置空计数器
+                empty_count = 0
+                data_received = True
+                logger.debug(f"[{req_id}] 接收到流数据: {type(data)} - {str(data)[:200]}...")
+                
+                # 检查是否是JSON字符串形式的结束标志
+                if isinstance(data, str):
+                    try:
+                        parsed_data = json.loads(data)
+                        if parsed_data.get("done") is True:
+                            logger.info(f"[{req_id}] 接收到JSON格式的完成标志")
+                            yield parsed_data
+                            break
+                        else:
+                            yield parsed_data
+                    except json.JSONDecodeError:
+                        # 如果不是JSON，直接返回字符串
+                        logger.debug(f"[{req_id}] 返回非JSON字符串数据")
+                        yield data
+                else:
+                    # 直接返回数据
+                    yield data
+                    
+                    # 检查字典类型的结束标志
+                    if isinstance(data, dict) and data.get("done") is True:
+                        logger.info(f"[{req_id}] 接收到字典格式的完成标志")
+                        break
+                
+            except (queue.Empty, asyncio.QueueEmpty):
+                empty_count += 1
+                if empty_count % 50 == 0:  # 每5秒记录一次等待状态
+                    logger.info(f"[{req_id}] 等待流数据... ({empty_count}/{max_empty_retries})")
+                
+                if empty_count >= max_empty_retries:
+                    if not data_received:
+                        logger.error(f"[{req_id}] 流响应队列空读取次数达到上限且未收到任何数据，可能是辅助流未启动或出错")
+                    else:
+                        logger.warning(f"[{req_id}] 流响应队列空读取次数达到上限 ({max_empty_retries})，结束读取")
+                    
+                    # 返回超时完成信号，而不是简单退出
+                    yield {"done": True, "reason": "internal_timeout", "body": "", "function": []}
+                    return
+                    
+                await asyncio.sleep(0.1)  # 100ms等待
+                continue
+                
+    except Exception as e:
+        logger.error(f"[{req_id}] 使用流响应时出错: {e}")
+        raise
+    finally:
+        logger.info(f"[{req_id}] 流响应使用完成，数据接收状态: {data_received}")
+
+
+async def clear_stream_queue():
+    """清空流队列（与原始参考文件保持一致）"""
+    from server import STREAM_QUEUE, logger
+    import queue
+
+    if STREAM_QUEUE is None:
+        logger.info("流队列未初始化或已被禁用，跳过清空操作。")
+        return
+
+    while True:
+        try:
+            data_chunk = await asyncio.to_thread(STREAM_QUEUE.get_nowait)
+            # logger.info(f"清空流式队列缓存，丢弃数据: {data_chunk}")
+        except queue.Empty:
+            logger.info("流式队列已清空 (捕获到 queue.Empty)。")
+            break
+        except Exception as e:
+            logger.error(f"清空流式队列时发生意外错误: {e}", exc_info=True)
+            break
+    logger.info("流式队列缓存清空完毕。")
+
+
+# --- Helper response generator ---
+async def use_helper_get_response(helper_endpoint: str, helper_sapisid: str) -> AsyncGenerator[str, None]:
+    """使用Helper服务获取响应的生成器"""
+    from server import logger
+    import aiohttp
+
+    logger.info(f"正在尝试使用Helper端点: {helper_endpoint}")
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            headers = {
+                'Content-Type': 'application/json',
+                'Cookie': f'SAPISID={helper_sapisid}' if helper_sapisid else ''
+            }
+            
+            async with session.get(helper_endpoint, headers=headers) as response:
+                if response.status == 200:
+                    async for chunk in response.content.iter_chunked(1024):
+                        if chunk:
+                            yield chunk.decode('utf-8', errors='ignore')
+                else:
+                    logger.error(f"Helper端点返回错误状态: {response.status}")
+                    
+    except Exception as e:
+        logger.error(f"使用Helper端点时出错: {e}")
+
+
+# --- 请求验证函数 ---
+def validate_chat_request(messages: List[Message], req_id: str) -> Dict[str, Optional[str]]:
+    """验证聊天请求"""
+    from server import logger
+    
+    if not messages:
+        raise ValueError(f"[{req_id}] 无效请求: 'messages' 数组缺失或为空。")
+    
+    if not any(msg.role != 'system' for msg in messages):
+        raise ValueError(f"[{req_id}] 无效请求: 所有消息都是系统消息。至少需要一条用户或助手消息。")
+    
+    # 返回验证结果
+    return {
+        "error": None,
+        "warning": None
+    }
+
+
+def extract_base64_to_local(base64_data: str) -> str:
+    output_dir = os.path.join(os.path.dirname(__file__), '..', 'upload_images')
+    match = re.match(r"data:image/(\w+);base64,(.*)", base64_data)
+    if not match:
+        print("错误: Base64 数据格式不正确。")
+        return None
+
+    image_type = match.group(1)  # 例如 "png", "jpeg"
+    encoded_image_data = match.group(2)
+
+    try:
+        # 解码 Base64 字符串
+        decoded_image_data = base64.b64decode(encoded_image_data)
+    except base64.binascii.Error as e:
+        print(f"错误: Base64 解码失败 - {e}")
+        return None
+
+    # 计算图片数据的 MD5 值
+    md5_hash = hashlib.md5(decoded_image_data).hexdigest()
+
+    # 确定文件扩展名和完整文件路径
+    file_extension = f".{image_type}"
+    output_filepath = os.path.join(output_dir, f"{md5_hash}{file_extension}")
+
+    # 确保输出目录存在
+    os.makedirs(output_dir, exist_ok=True)
+
+    if os.path.exists(output_filepath):
+        print(f"文件已存在，跳过保存: {output_filepath}")
+        return output_filepath
+
+    # 保存图片到文件
+    try:
+        with open(output_filepath, "wb") as f:
+            f.write(decoded_image_data)
+        print(f"图片已成功保存到: {output_filepath}")
+        return output_filepath
+    except IOError as e:
+        print(f"错误: 保存文件失败 - {e}")
+        return None
+
+
+# --- 提示准备函数 ---
+def prepare_combined_prompt(messages: List[Message], req_id: str) -> str:
+    """准备组合提示"""
+    from server import logger
+    
+    logger.info(f"[{req_id}] (准备提示) 正在从 {len(messages)} 条消息准备组合提示 (包括历史)。")
+    
+    combined_parts = []
+    system_prompt_content: Optional[str] = None
+    processed_system_message_indices = set()
+    images_list = []  # 将 image_list 的初始化移到循环外部
+
+    # 处理系统消息
+    for i, msg in enumerate(messages):
+        if msg.role == 'system':
+            content = msg.content
+            if isinstance(content, str) and content.strip():
+                system_prompt_content = content.strip()
+                processed_system_message_indices.add(i)
+                logger.info(f"[{req_id}] (准备提示) 在索引 {i} 找到并使用系统提示: '{system_prompt_content[:80]}...'")
+                system_instr_prefix = "系统指令:\n"
+                combined_parts.append(f"{system_instr_prefix}{system_prompt_content}")
+            else:
+                logger.info(f"[{req_id}] (准备提示) 在索引 {i} 忽略非字符串或空的系统消息。")
+                processed_system_message_indices.add(i)
+            break
+    
+    role_map_ui = {"user": "用户", "assistant": "助手", "system": "系统", "tool": "工具"}
+    turn_separator = "\n---\n"
+    
+    # 处理其他消息
+    for i, msg in enumerate(messages):
+        if i in processed_system_message_indices:
+            continue
+        
+        if msg.role == 'system':
+            logger.info(f"[{req_id}] (准备提示) 跳过在索引 {i} 的后续系统消息。")
+            continue
+        
+        if combined_parts:
+            combined_parts.append(turn_separator)
+        
+        role = msg.role or 'unknown'
+        role_prefix_ui = f"{role_map_ui.get(role, role.capitalize())}:\n"
+        current_turn_parts = [role_prefix_ui]
+        
+        content = msg.content or ''
+        content_str = ""
+        
+        if isinstance(content, str):
+            content_str = content.strip()
+        elif isinstance(content, list):
+            # 处理多模态内容
+            text_parts = []
+            for item in content:
+                if hasattr(item, 'type') and item.type == 'text':
+                    text_parts.append(item.text or '')
+                elif isinstance(item, dict) and item.get('type') == 'text':
+                    text_parts.append(item.get('text', ''))
+                elif hasattr(item, 'type') and item.type == 'image_url':
+                    image_url_value = item.image_url.url
+                    if image_url_value.startswith("data:image/"):
+                        try:
+                            # 提取 Base64 字符串
+                            image_full_path = extract_base64_to_local(image_url_value)
+                            images_list.append(image_full_path)
+                        except (ValueError, requests.exceptions.RequestException, Exception) as e:
+                            print(f"处理 Base64 图片并上传到 Imgur 失败: {e}")
+                else:
+                    logger.warning(f"[{req_id}] (准备提示) 警告: 在索引 {i} 的消息中忽略非文本或未知类型的 content item")
+            content_str = "\n".join(text_parts).strip()
+        else:
+            logger.warning(f"[{req_id}] (准备提示) 警告: 角色 {role} 在索引 {i} 的内容类型意外 ({type(content)}) 或为 None。")
+            content_str = str(content or "").strip()
+        
+        if content_str:
+            current_turn_parts.append(content_str)
+        
+        # 处理工具调用
+        tool_calls = msg.tool_calls
+        if role == 'assistant' and tool_calls:
+            if content_str:
+                current_turn_parts.append("\n")
+            
+            tool_call_visualizations = []
+            for tool_call in tool_calls:
+                if hasattr(tool_call, 'type') and tool_call.type == 'function':
+                    function_call = tool_call.function
+                    func_name = function_call.name if function_call else None
+                    func_args_str = function_call.arguments if function_call else None
+                    
+                    try:
+                        parsed_args = json.loads(func_args_str if func_args_str else '{}')
+                        formatted_args = json.dumps(parsed_args, indent=2, ensure_ascii=False)
+                    except (json.JSONDecodeError, TypeError):
+                        formatted_args = func_args_str if func_args_str is not None else "{}"
+                    
+                    tool_call_visualizations.append(
+                        f"请求调用函数: {func_name}\n参数:\n{formatted_args}"
+                    )
+            
+            if tool_call_visualizations:
+                current_turn_parts.append("\n".join(tool_call_visualizations))
+        
+        if len(current_turn_parts) > 1 or (role == 'assistant' and tool_calls):
+            combined_parts.append("".join(current_turn_parts))
+        elif not combined_parts and not current_turn_parts:
+            logger.info(f"[{req_id}] (准备提示) 跳过角色 {role} 在索引 {i} 的空消息 (且无工具调用)。")
+        elif len(current_turn_parts) == 1 and not combined_parts:
+            logger.info(f"[{req_id}] (准备提示) 跳过角色 {role} 在索引 {i} 的空消息 (只有前缀)。")
+    
+    final_prompt = "".join(combined_parts)
+    if final_prompt:
+        final_prompt += "\n"
+    
+    preview_text = final_prompt[:300].replace('\n', '\\n')
+    logger.info(f"[{req_id}] (准备提示) 组合提示长度: {len(final_prompt)}。预览: '{preview_text}...'")
+    
+    return final_prompt,images_list
+
+
+def estimate_tokens(text: str) -> int:
+    """
+    估算文本的token数量
+    使用简单的字符计数方法：
+    - 英文：大约4个字符 = 1个token
+    - 中文：大约1.5个字符 = 1个token  
+    - 混合文本：采用加权平均
+    """
+    if not text:
+        return 0
+    
+    # 统计中文字符数量（包括中文标点）
+    chinese_chars = sum(1 for char in text if '\u4e00' <= char <= '\u9fff' or '\u3000' <= char <= '\u303f' or '\uff00' <= char <= '\uffef')
+    
+    # 统计非中文字符数量
+    non_chinese_chars = len(text) - chinese_chars
+    
+    # 计算token估算
+    chinese_tokens = chinese_chars / 1.5  # 中文大约1.5字符/token
+    english_tokens = non_chinese_chars / 4.0  # 英文大约4字符/token
+    
+    return max(1, int(chinese_tokens + english_tokens))
+
+
+def calculate_usage_stats(messages: List[dict], response_content: str, reasoning_content: str = None) -> dict:
+    """
+    计算token使用统计
+    
+    Args:
+        messages: 请求中的消息列表
+        response_content: 响应内容
+        reasoning_content: 推理内容（可选）
+    
+    Returns:
+        包含token使用统计的字典
+    """
+    # 计算输入token（prompt tokens）
+    prompt_text = ""
+    for message in messages:
+        role = message.get("role", "")
+        content = message.get("content", "")
+        prompt_text += f"{role}: {content}\n"
+    
+    prompt_tokens = estimate_tokens(prompt_text)
+    
+    # 计算输出token（completion tokens）
+    completion_text = response_content or ""
+    if reasoning_content:
+        completion_text += reasoning_content
+    
+    completion_tokens = estimate_tokens(completion_text)
+    
+    # 总token数
+    total_tokens = prompt_tokens + completion_tokens
+    
+    return {
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "total_tokens": total_tokens
+    } 
+
+
+def generate_sse_stop_chunk_with_usage(req_id: str, model: str, usage_stats: dict, reason: str = "stop") -> str:
+    """生成带usage统计的SSE停止块"""
+    return generate_sse_stop_chunk(req_id, model, reason, usage_stats) 

AIStudioProxyAPI/browser_utils/__init__.py

@@ -0,0 +1,56 @@
+# --- browser_utils/__init__.py ---
+# 浏览器操作工具模块
+from .initialization import _initialize_page_logic, _close_page_logic, signal_camoufox_shutdown, enable_temporary_chat_mode
+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,
+    _verify_ui_state_settings,
+    _force_ui_state_settings,
+    _force_ui_state_with_retry,
+    _verify_and_apply_ui_state
+)
+from .script_manager import ScriptManager, script_manager
+
+__all__ = [
+    # 初始化相关
+    '_initialize_page_logic',
+    '_close_page_logic', 
+    'signal_camoufox_shutdown',
+    'enable_temporary_chat_mode',
+    
+    # 页面操作相关
+    '_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',
+    '_verify_ui_state_settings',
+    '_force_ui_state_settings',
+    '_force_ui_state_with_retry',
+    '_verify_and_apply_ui_state',
+
+    # 脚本管理相关
+    'ScriptManager',
+    'script_manager'
+]

AIStudioProxyAPI/browser_utils/initialization.py

@@ -0,0 +1,669 @@
+# --- 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
+
+                # 添加特殊标记，表示这是通过网络拦截注入的模型
+                # 在模型数组的末尾添加一个特殊字段作为标记
+                if len(new_model) > 10:  # 确保有足够的位置
+                    new_model.append("__NETWORK_INJECTED__")  # 添加网络注入标记
+                else:
+                    # 如果模型数组长度不够，扩展到足够长度
+                    while len(new_model) <= 10:
+                        new_model.append(None)
+                    new_model.append("__NETWORK_INJECTED__")
+
+                # 添加到开头
+                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 键继续..."
+                # NEW: If SUPPRESS_LOGIN_WAIT is set, skip waiting for user input.
+                if os.environ.get("SUPPRESS_LOGIN_WAIT", "").lower() in ("1", "true", "yes"):
+                    logger.info("检测到 SUPPRESS_LOGIN_WAIT 标志，跳过等待用户输入。")
+                else:
+                    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("   ✅ 登录成功！请不要操作浏览器窗口，等待后续提示。")
+
+                    # 登录成功后，调用认证保存逻辑
+                    if os.environ.get('AUTO_SAVE_AUTH', 'false').lower() == 'true':
+                        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('[data-test-id="model-name"]')
+            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("   ⚠️ 等待模型列表响应超时，但继续处理认证保存...")
+
+    # 检查是否有预设的文件名用于保存
+    save_auth_filename = os.environ.get('SAVE_AUTH_FILENAME', '').strip()
+    if save_auth_filename:
+        logger.info(f"   检测到 SAVE_AUTH_FILENAME 环境变量: '{save_auth_filename}'。将自动保存认证文件。")
+        await _handle_auth_file_save_with_filename(temp_context, save_auth_filename)
+        return
+
+    # If not auto-saving, proceed with interactive prompts
+    await _interactive_auth_save(temp_context, launch_mode, loop)
+
+
+async def _interactive_auth_save(temp_context, launch_mode, loop):
+    """处理认证文件保存的交互式提示"""
+    # 检查是否启用自动确认
+    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)
+        logger.info(f"   认证状态已成功保存到: {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_with_filename(temp_context, filename: str):
+    """处理认证文件保存（使用提供的文件名）"""
+    os.makedirs(SAVED_AUTH_DIR, exist_ok=True)
+
+    # Clean the filename and add .json if needed
+    final_auth_filename = filename.strip()
+    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)
+        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)
+
+
+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)
+        logger.info(f"   认证状态已成功保存到: {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 enable_temporary_chat_mode(page: AsyncPage):
+    """
+    检查并启用 AI Studio 界面的“临时聊天”模式。
+    这是一个独立的UI操作，应该在页面完全稳定后调用。
+    """
+    try:
+        logger.info("-> (UI Op) 正在检查并启用 '临时聊天' 模式...")
+        
+        incognito_button_locator = page.locator('button[aria-label="Temporary chat toggle"]')
+        
+        await incognito_button_locator.wait_for(state="visible", timeout=10000)
+        
+        button_classes = await incognito_button_locator.get_attribute("class")
+        
+        if button_classes and 'ms-button-active' in button_classes:
+            logger.info("-> (UI Op) '临时聊天' 模式已激活。")
+        else:
+            logger.info("-> (UI Op) '临时聊天' 模式未激活，正在点击...")
+            await incognito_button_locator.click(timeout=5000, force=True)
+            await asyncio.sleep(1)
+            
+            updated_classes = await incognito_button_locator.get_attribute("class")
+            if updated_classes and 'ms-button-active' in updated_classes:
+                logger.info("✅ (UI Op) '临时聊天' 模式已成功启用。")
+            else:
+                logger.warning("⚠️ (UI Op) 点击后 '临时聊天' 模式状态验证失败。")
+
+    except Exception as e:
+        logger.warning(f"⚠️ (UI Op) 启用 '临时聊天' 模式时出错: {e}")

AIStudioProxyAPI/browser_utils/model_management.py

@@ -0,0 +1,619 @@
+# --- 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")
+
+# ==================== 强制UI状态设置功能 ====================
+
+async def _verify_ui_state_settings(page: AsyncPage, req_id: str = "unknown") -> dict:
+    """
+    验证UI状态设置是否正确
+
+    Args:
+        page: Playwright页面对象
+        req_id: 请求ID用于日志
+
+    Returns:
+        dict: 包含验证结果的字典
+    """
+    try:
+        logger.info(f"[{req_id}] 验证UI状态设置...")
+
+        # 获取当前localStorage设置
+        prefs_str = await page.evaluate("() => localStorage.getItem('aiStudioUserPreference')")
+
+        if not prefs_str:
+            logger.warning(f"[{req_id}] localStorage.aiStudioUserPreference 不存在")
+            return {
+                'exists': False,
+                'isAdvancedOpen': None,
+                'areToolsOpen': None,
+                'needsUpdate': True,
+                'error': 'localStorage不存在'
+            }
+
+        try:
+            prefs = json.loads(prefs_str)
+            is_advanced_open = prefs.get('isAdvancedOpen')
+            are_tools_open = prefs.get('areToolsOpen')
+
+            # 检查是否需要更新
+            needs_update = (is_advanced_open is not True) or (are_tools_open is not True)
+
+            result = {
+                'exists': True,
+                'isAdvancedOpen': is_advanced_open,
+                'areToolsOpen': are_tools_open,
+                'needsUpdate': needs_update,
+                'prefs': prefs
+            }
+
+            logger.info(f"[{req_id}] UI状态验证结果: isAdvancedOpen={is_advanced_open}, areToolsOpen={are_tools_open} (期望: True), needsUpdate={needs_update}")
+            return result
+
+        except json.JSONDecodeError as e:
+            logger.error(f"[{req_id}] 解析localStorage JSON失败: {e}")
+            return {
+                'exists': False,
+                'isAdvancedOpen': None,
+                'areToolsOpen': None,
+                'needsUpdate': True,
+                'error': f'JSON解析失败: {e}'
+            }
+
+    except Exception as e:
+        logger.error(f"[{req_id}] 验证UI状态设置时发生错误: {e}")
+        return {
+            'exists': False,
+            'isAdvancedOpen': None,
+            'areToolsOpen': None,
+            'needsUpdate': True,
+            'error': f'验证失败: {e}'
+        }
+
+async def _force_ui_state_settings(page: AsyncPage, req_id: str = "unknown") -> bool:
+    """
+    强制设置UI状态
+
+    Args:
+        page: Playwright页面对象
+        req_id: 请求ID用于日志
+
+    Returns:
+        bool: 设置是否成功
+    """
+    try:
+        logger.info(f"[{req_id}] 开始强制设置UI状态...")
+
+        # 首先验证当前状态
+        current_state = await _verify_ui_state_settings(page, req_id)
+
+        if not current_state['needsUpdate']:
+            logger.info(f"[{req_id}] UI状态已正确设置，无需更新")
+            return True
+
+        # 获取现有preferences或创建新的
+        prefs = current_state.get('prefs', {})
+
+        # 强制设置关键配置
+        prefs['isAdvancedOpen'] = True
+        prefs['areToolsOpen'] = True
+
+        # 保存到localStorage
+        prefs_str = json.dumps(prefs)
+        await page.evaluate("(prefsStr) => localStorage.setItem('aiStudioUserPreference', prefsStr)", prefs_str)
+
+        logger.info(f"[{req_id}] 已强制设置: isAdvancedOpen=true, areToolsOpen=true")
+
+        # 验证设置是否成功
+        verify_state = await _verify_ui_state_settings(page, req_id)
+        if not verify_state['needsUpdate']:
+            logger.info(f"[{req_id}] ✅ UI状态设置验证成功")
+            return True
+        else:
+            logger.warning(f"[{req_id}] ⚠️ UI状态设置验证失败，可能需要重试")
+            return False
+
+    except Exception as e:
+        logger.error(f"[{req_id}] 强制设置UI状态时发生错误: {e}")
+        return False
+
+async def _force_ui_state_with_retry(page: AsyncPage, req_id: str = "unknown", max_retries: int = 3, retry_delay: float = 1.0) -> bool:
+    """
+    带重试机制的UI状态强制设置
+
+    Args:
+        page: Playwright页面对象
+        req_id: 请求ID用于日志
+        max_retries: 最大重试次数
+        retry_delay: 重试延迟（秒）
+
+    Returns:
+        bool: 设置是否最终成功
+    """
+    for attempt in range(1, max_retries + 1):
+        logger.info(f"[{req_id}] 尝试强制设置UI状态 (第 {attempt}/{max_retries} 次)")
+
+        success = await _force_ui_state_settings(page, req_id)
+        if success:
+            logger.info(f"[{req_id}] ✅ UI状态设置在第 {attempt} 次尝试中成功")
+            return True
+
+        if attempt < max_retries:
+            logger.warning(f"[{req_id}] ⚠️ 第 {attempt} 次尝试失败，{retry_delay}秒后重试...")
+            await asyncio.sleep(retry_delay)
+        else:
+            logger.error(f"[{req_id}] ❌ UI状态设置在 {max_retries} 次尝试后仍然失败")
+
+    return False
+
+async def _verify_and_apply_ui_state(page: AsyncPage, req_id: str = "unknown") -> bool:
+    """
+    验证并应用UI状态设置的完整流程
+
+    Args:
+        page: Playwright页面对象
+        req_id: 请求ID用于日志
+
+    Returns:
+        bool: 操作是否成功
+    """
+    try:
+        logger.info(f"[{req_id}] 开始验证并应用UI状态设置...")
+
+        # 首先验证当前状态
+        state = await _verify_ui_state_settings(page, req_id)
+
+        logger.info(f"[{req_id}] 当前UI状态: exists={state['exists']}, isAdvancedOpen={state['isAdvancedOpen']}, areToolsOpen={state['areToolsOpen']}, needsUpdate={state['needsUpdate']}")
+
+        if state['needsUpdate']:
+            logger.info(f"[{req_id}] 检测到UI状态需要更新，正在应用强制设置...")
+            return await _force_ui_state_with_retry(page, req_id)
+        else:
+            logger.info(f"[{req_id}] UI状态已正确设置，无需更新")
+            return True
+
+    except Exception as e:
+        logger.error(f"[{req_id}] 验证并应用UI状态设置时发生错误: {e}")
+        return False
+
+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}] 应用强制UI状态设置...")
+        ui_state_success = await _verify_and_apply_ui_state(page, req_id)
+        if not ui_state_success:
+            logger.warning(f"[{req_id}] UI状态设置失败，但继续执行模型切换流程")
+
+        # 为了保持兼容性，也更新当前的prefs对象
+        current_prefs_for_modification["isAdvancedOpen"] = True
+        current_prefs_for_modification["areToolsOpen"] = True
+        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}] 页面已导航到新聊天并加载完成，输入框可见")
+
+        # 页面加载后再次验证UI状态设置
+        logger.info(f"[{req_id}] 页面加载完成，验证UI状态设置...")
+        final_ui_state_success = await _verify_and_apply_ui_state(page, req_id)
+        if final_ui_state_success:
+            logger.info(f"[{req_id}] ✅ UI状态最终验证成功")
+        else:
+            logger.warning(f"[{req_id}] ⚠️ UI状态最终验证失败，但继续执行模型切换流程")
+        
+        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
+
+            try:
+                model_name_locator = page.locator('[data-test-id="model-name"]')
+                actual_displayed_model_id_on_page_raw = await model_name_locator.first.inner_text(timeout=5000)
+                actual_displayed_model_id_on_page = actual_displayed_model_id_on_page_raw.strip()
+                
+                target_model_id = model_id
+
+                if actual_displayed_model_id_on_page == target_model_id:
+                    page_display_match = True
+                    logger.info(f"[{req_id}] ✅ 页面显示模型ID ('{actual_displayed_model_id_on_page}') 与期望ID ('{target_model_id}') 一致。")
+                else:
+                    page_display_match = False
+                    logger.error(f"[{req_id}] ❌ 页面显示模型ID ('{actual_displayed_model_id_on_page}') 与期望ID ('{target_model_id}') 不一致。")
+            
+            except Exception as e_disp:
+                page_display_match = False # 读取失败则认为不匹配
+                logger.warning(f"[{req_id}] 读取页面显示的当前模型ID时出错: {e_disp}。将无法验证页面显示。")
+
+            if page_display_match:
+                try:
+                    logger.info(f"[{req_id}] 模型切换成功，重新启用 '临时聊天' 模式...")
+                    incognito_button_locator = page.locator('button[aria-label="Temporary chat toggle"]')
+                    
+                    await incognito_button_locator.wait_for(state="visible", timeout=5000)
+                    
+                    button_classes = await incognito_button_locator.get_attribute("class")
+                    
+                    if button_classes and 'ms-button-active' in button_classes:
+                        logger.info(f"[{req_id}] '临时聊天' 模式已处于激活状态。")
+                    else:
+                        logger.info(f"[{req_id}] '临时聊天' 模式未激活，正在点击以开启...")
+                        await incognito_button_locator.click(timeout=3000)
+                        await asyncio.sleep(0.5)
+                        
+                        updated_classes = await incognito_button_locator.get_attribute("class")
+                        if updated_classes and 'ms-button-active' in updated_classes:
+                             logger.info(f"[{req_id}] ✅ '临时聊天' 模式已成功重新启用。")
+                        else:
+                             logger.warning(f"[{req_id}] ⚠️ 点击后 '临时聊天' 模式状态验证失败，可能未成功重新开启。")
+                
+                except Exception as e:
+                    logger.warning(f"[{req_id}] ⚠️ 模型切换后重新启用 '临时聊天' 模式失败: {e}")
+                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('[data-test-id="model-name"]')
+            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 current_displayed_name_for_revert_stripped != "无法读取":
+            model_id_to_revert_to = current_displayed_name_for_revert_stripped
+            logger.info(f"[{req_id}] 恢复：页面当前显示的ID是 '{model_id_to_revert_to}'，将直接用于恢复。")
+        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
+            # 使用新的强制设置功能
+            logger.info(f"[{req_id}] 恢复：应用强制UI状态设置...")
+            ui_state_success = await _verify_and_apply_ui_state(page, req_id)
+            if not ui_state_success:
+                logger.warning(f"[{req_id}] 恢复：UI状态设置失败，但继续执行恢复流程")
+
+            # 为了保持兼容性，也更新当前的prefs对象
+            base_prefs_for_final_revert["isAdvancedOpen"] = True
+            base_prefs_for_final_revert["areToolsOpen"] = True
+            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)
+
+            # 恢复后再次验证UI状态
+            logger.info(f"[{req_id}] 恢复：页面加载完成，验证UI状态设置...")
+            final_ui_state_success = await _verify_and_apply_ui_state(page, req_id)
+            if final_ui_state_success:
+                logger.info(f"[{req_id}] ✅ 恢复：UI状态最终验证成功")
+            else:
+                logger.warning(f"[{req_id}] ⚠️ 恢复：UI状态最终验证失败")
+
+            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}")
+                else:
+                    # 使用新的UI状态验证功能
+                    ui_state = await _verify_ui_state_settings(page, "initial")
+                    if ui_state['needsUpdate']:
+                        needs_reload_and_storage_update = True
+                        reason_for_reload = f"UI状态需要更新: isAdvancedOpen={ui_state['isAdvancedOpen']}, areToolsOpen={ui_state['areToolsOpen']} (期望: True)"
+                        logger.info(f"   判定需要刷新和存储更新: {reason_for_reload}")
+                    else:
+                        server.current_ai_studio_model_id = prompt_model_path.split('/')[-1]
+                        logger.info(f"   ✅ localStorage 有效且UI状态正确。初始模型 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}")
+
+                    # 页面重新加载后验证UI状态
+                    logger.info(f"   页面重新加载完成，验证UI状态设置...")
+                    reload_ui_state_success = await _verify_and_apply_ui_state(page, "reload")
+                    if reload_ui_state_success:
+                        logger.info(f"   ✅ 重新加载后UI状态验证成功")
+                    else:
+                        logger.warning(f"   ⚠️ 重新加载后UI状态验证失败")
+
+                    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('[data-test-id="model-name"]')
+        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。")
+        
+        found_model_id_from_display = displayed_model_name
+        logger.info(f"   页面显示的直接是模型ID: '{found_model_id_from_display}'")
+        
+        new_model_value = found_model_id_from_display
+        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 失败，将创建新的偏好设置。")
+            
+            # 使用新的强制设置功能
+            logger.info(f"     应用强制UI状态设置...")
+            ui_state_success = await _verify_and_apply_ui_state(page, "set_model")
+            if not ui_state_success:
+                logger.warning(f"     UI状态设置失败，使用传统方法")
+                prefs_to_set["isAdvancedOpen"] = True
+                prefs_to_set["areToolsOpen"] = True
+            else:
+                # 确保prefs_to_set也包含正确的设置
+                prefs_to_set["isAdvancedOpen"] = True
+                prefs_to_set["areToolsOpen"] = True
+            logger.info(f"     强制 isAdvancedOpen: true, areToolsOpen: true")
+            
+            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')} (期望: True), promptModel: '{prefs_to_set.get('promptModel', '未设置/保留原样')}'。")
+    except Exception as e_set_disp:
+        logger.error(f"   尝试从页面显示设置模型时出错: {e_set_disp}", exc_info=True) 

AIStudioProxyAPI/browser_utils/more_modles.js

@@ -0,0 +1,393 @@
+// ==UserScript==
+// @name         Google AI Studio 模型注入器
+// @namespace    http://tampermonkey.net/
+// @version      1.6.5
+// @description  向 Google AI Studio 注入自定义模型，支持主题表情图标。拦截 XHR/Fetch 请求，处理数组结构的 JSON 数据
+// @author       Generated by AI / HCPTangHY / Mozi / wisdgod / UserModified
+// @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';
+
+    // ==================== 配置区域 ====================
+    // 脚本已经失效
+
+    const SCRIPT_VERSION = "none";
+    const LOG_PREFIX = `[AI Studio 注入器 ${SCRIPT_VERSION}]`;
+    const ANTI_HIJACK_PREFIX = ")]}'\n";
+
+    // 模型配置列表
+    // 已按要求将 jfdksal98a 放到 blacktooth 的下面
+    const MODELS_TO_INJECT = [
+
+        //下面模型已经全部失效，留下来怀念
+        // { name: 'models/gemini-2.5-pro-preview-03-25', displayName: `✨ Gemini 2.5 Pro 03-25 (Script ${SCRIPT_VERSION})`, description: `Model injected by script ${SCRIPT_VERSION}` },
+        // { name: 'models/gemini-2.5-pro-exp-03-25', displayName: `✨ Gemini 2.5 Pro 03-25 (Script ${SCRIPT_VERSION})`, description: `Model injected by script ${SCRIPT_VERSION}` },
+        // { name: 'models/gemini-2.5-pro-preview-06-05', displayName: `✨ Gemini 2.5 Pro 03-25 (Script ${SCRIPT_VERSION})`, description: `Model injected by script ${SCRIPT_VERSION}` },
+        // { name: 'models/blacktooth-ab-test', displayName: `🏴‍☠️ Blacktooth (脚本 ${SCRIPT_VERSION})`, description: `由脚本 ${SCRIPT_VERSION} 注入的模型` },
+        // { name: 'models/jfdksal98a', displayName: `🪐 jfdksal98a (脚本 ${SCRIPT_VERSION})`, description: `由脚本 ${SCRIPT_VERSION} 注入的模型` },
+        // { name: 'models/gemini-2.5-pro-preview-03-25', displayName: `✨ Gemini 2.5 Pro 03-25 (脚本 ${SCRIPT_VERSION})`, description: `由脚本 ${SCRIPT_VERSION} 注入的模型` },
+        // { name: 'models/goldmane-ab-test', displayName: `🦁 Goldmane (脚本 ${SCRIPT_VERSION})`, description: `由脚本 ${SCRIPT_VERSION} 注入的模型` },
+        // { name: 'models/claybrook-ab-test', displayName: `💧 Claybrook (脚本 ${SCRIPT_VERSION})`, description: `由脚本 ${SCRIPT_VERSION} 注入的模型` },
+        // { name: 'models/frostwind-ab-test', displayName: `❄️ Frostwind (脚本 ${SCRIPT_VERSION})`, description: `由脚本 ${SCRIPT_VERSION} 注入的模型` },
+        // { name: 'models/calmriver-ab-test', displayName: `🌊 Calmriver (脚本 ${SCRIPT_VERSION})`, description: `由脚本 ${SCRIPT_VERSION} 注入的模型` }
+    ];
+
+    // JSON 结构中的字段索引
+    const MODEL_FIELDS = {
+        NAME: 0,
+        DISPLAY_NAME: 3,
+        DESCRIPTION: 4,
+        METHODS: 7
+    };
+
+    // ==================== 工具函数 ====================
+
+    /**
+     * 检查 URL 是否为目标 API 端点
+     * @param {string} url - 要检查的 URL
+     * @returns {boolean}
+     */
+    function isTargetURL(url) {
+        return url && typeof url === 'string' &&
+               url.includes('alkalimakersuite') &&
+               url.includes('/ListModels');
+    }
+
+    /**
+     * 递归查找模型列表数组
+     * @param {any} obj - 要搜索的对象
+     * @returns {Array|null} 找到的模型数组或 null
+     */
+    function findModelListArray(obj) {
+        if (!obj) return null;
+
+        // 检查是否为目标模型数组
+        if (Array.isArray(obj) && obj.length > 0 && obj.every(
+            item => Array.isArray(item) &&
+                    typeof item[MODEL_FIELDS.NAME] === 'string' &&
+                    String(item[MODEL_FIELDS.NAME]).startsWith('models/')
+        )) {
+            return obj;
+        }
+
+        // 递归搜索子对象
+        if (typeof obj === 'object') {
+            for (const key in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, key) &&
+                    typeof obj[key] === 'object' &&
+                    obj[key] !== null) {
+                    const result = findModelListArray(obj[key]);
+                    if (result) return result;
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 查找合适的模板模型
+     * @param {Array} modelsArray - 模型数组
+     * @returns {Array|null} 模板模型或 null
+     */
+    function findTemplateModel(modelsArray) {
+        // 优先查找包含特定关键词的模型
+        const templateModel =
+            modelsArray.find(m => Array.isArray(m) &&
+                                 m[MODEL_FIELDS.NAME] &&
+                                 String(m[MODEL_FIELDS.NAME]).includes('pro') &&
+                                 Array.isArray(m[MODEL_FIELDS.METHODS])) ||
+            modelsArray.find(m => Array.isArray(m) &&
+                                 m[MODEL_FIELDS.NAME] &&
+                                 String(m[MODEL_FIELDS.NAME]).includes('flash') &&
+                                 Array.isArray(m[MODEL_FIELDS.METHODS])) ||
+            modelsArray.find(m => Array.isArray(m) &&
+                                 m[MODEL_FIELDS.NAME] &&
+                                 Array.isArray(m[MODEL_FIELDS.METHODS]));
+
+        return templateModel;
+    }
+
+    /**
+     * 更新已存在模型的显示名称
+     * @param {Array} existingModel - 现有模型
+     * @param {Object} modelToInject - 要注入的模型配置
+     * @returns {boolean} 是否进行了更新
+     */
+    function updateExistingModel(existingModel, modelToInject) {
+        if (!existingModel || existingModel[MODEL_FIELDS.DISPLAY_NAME] === modelToInject.displayName) {
+            return false;
+        }
+
+        // 提取基础名称（去除版本号和表情）
+        // 更新正则表达式以匹配 vX.Y.Z 格式
+        const cleanName = (name) => String(name)
+            .replace(/ \(脚本 v\d+\.\d+(\.\d+)?(-beta\d*)?\)/, '')
+            // 包含所有当前使用的表情，包括新增的 🏴‍☠️, 🤖, 🪐
+            .replace(/^[✨🦁💧❄️🌊🐉🏴‍☠️🤖🪐]\s*/, '')
+            .trim();
+
+        const baseExistingName = cleanName(existingModel[MODEL_FIELDS.DISPLAY_NAME]);
+        const baseInjectName = cleanName(modelToInject.displayName);
+
+        if (baseExistingName === baseInjectName) {
+            // 仅更新版本号和表情
+            existingModel[MODEL_FIELDS.DISPLAY_NAME] = modelToInject.displayName;
+            console.log(LOG_PREFIX, `已更新表情/版本号: ${modelToInject.displayName}`);
+        } else {
+            // 标记为原始模型
+            existingModel[MODEL_FIELDS.DISPLAY_NAME] = modelToInject.displayName + " (原始)";
+            console.log(LOG_PREFIX, `已更新官方模型 ${modelToInject.name} 的显示名称`);
+        }
+        return true;
+    }
+
+    /**
+     * 创建新模型
+     * @param {Array} templateModel - 模板模型
+     * @param {Object} modelToInject - 要注入的模型配置
+     * @param {string} templateName - 模板名称
+     * @returns {Array} 新模型数组
+     */
+    function createNewModel(templateModel, modelToInject, templateName) {
+        const newModel = structuredClone(templateModel);
+
+        newModel[MODEL_FIELDS.NAME] = modelToInject.name;
+        newModel[MODEL_FIELDS.DISPLAY_NAME] = modelToInject.displayName;
+        newModel[MODEL_FIELDS.DESCRIPTION] = `${modelToInject.description} (基于 ${templateName} 结构)`;
+
+        if (!Array.isArray(newModel[MODEL_FIELDS.METHODS])) {
+            newModel[MODEL_FIELDS.METHODS] = [
+                "generateContent",
+                "countTokens",
+                "createCachedContent",
+                "batchGenerateContent"
+            ];
+        }
+
+        return newModel;
+    }
+
+    // ==================== 核心处理函数 ====================
+
+    /**
+     * 处理并修改 JSON 数据
+     * @param {Object} jsonData - 原始 JSON 数据
+     * @param {string} url - 请求 URL
+     * @returns {Object} 包含处理后数据和修改标志的对象
+     */
+    function processJsonData(jsonData, url) {
+        let modificationMade = false;
+        const modelsArray = findModelListArray(jsonData);
+
+        if (!modelsArray || !Array.isArray(modelsArray)) {
+            console.warn(LOG_PREFIX, '在 JSON 中未找到有效的模型列表结构:', url);
+            return { data: jsonData, modified: false };
+        }
+
+        // 查找模板模型
+        const templateModel = findTemplateModel(modelsArray);
+        const templateName = templateModel?.[MODEL_FIELDS.NAME] || 'unknown';
+
+        if (!templateModel) {
+            console.warn(LOG_PREFIX, '未找到合适的模板模型，无法注入新模型');
+        }
+
+        // 反向遍历以保持显示顺序 (配置中靠前的模型显示在最上面)
+        [...MODELS_TO_INJECT].reverse().forEach(modelToInject => {
+            const existingModel = modelsArray.find(
+                model => Array.isArray(model) && model[MODEL_FIELDS.NAME] === modelToInject.name
+            );
+
+            if (!existingModel) {
+                // 注入新模型
+                if (!templateModel) {
+                    console.warn(LOG_PREFIX, `无法注入 ${modelToInject.name}：缺少模板`);
+                    return;
+                }
+
+                const newModel = createNewModel(templateModel, modelToInject, templateName);
+                modelsArray.unshift(newModel); // unshift 将模型添加到数组开头
+                modificationMade = true;
+                console.log(LOG_PREFIX, `成功注入: ${modelToInject.displayName}`);
+            } else {
+                // 更新现���模型
+                if (updateExistingModel(existingModel, modelToInject)) {
+                    modificationMade = true;
+                }
+            }
+        });
+
+        return { data: jsonData, modified: modificationMade };
+    }
+
+    /**
+     * 修改响应体
+     * @param {string} originalText - 原始响应文本
+     * @param {string} url - 请求 URL
+     * @returns {string} 修改后的响应文本
+     */
+    function modifyResponseBody(originalText, url) {
+        if (!originalText || typeof originalText !== 'string') {
+            return originalText;
+        }
+
+        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;
+                }
+                return newBody;
+            }
+        } catch (error) {
+            console.error(LOG_PREFIX, '处理响应体时出错:', url, error);
+        }
+
+        return originalText;
+    }
+
+    // ==================== 请求拦截 ====================
+
+    // 拦截 Fetch API
+    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] 拦截到目标请求:', 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] 处理错误:', e);
+            }
+        }
+        return response;
+    };
+
+    // 拦截 XMLHttpRequest
+    const xhrProto = XMLHttpRequest.prototype;
+    const originalOpen = xhrProto.open;
+    const originalResponseTextDescriptor = Object.getOwnPropertyDescriptor(xhrProto, 'responseText');
+    const originalResponseDescriptor = Object.getOwnPropertyDescriptor(xhrProto, 'response');
+    let interceptionCount = 0;
+
+    // 重写 open 方法
+    xhrProto.open = function(method, url) {
+        this._interceptorUrl = url;
+        this._isTargetXHR = isTargetURL(url);
+
+        if (this._isTargetXHR) {
+            interceptionCount++;
+            console.log(LOG_PREFIX, `[XHR] 检测到目标请求 (${interceptionCount})：`, url);
+        }
+
+        return originalOpen.apply(this, arguments);
+    };
+
+    /**
+     * 处理 XHR 响应
+     * @param {XMLHttpRequest} xhr - XHR 对象
+     * @param {any} originalValue - 原始响应值
+     * @param {string} type - 响应类型
+     * @returns {any} 处理后的响应值
+     */
+    const handleXHRResponse = (xhr, originalValue, type = 'text') => {
+        if (!xhr._isTargetXHR || xhr.readyState !== 4 || xhr.status !== 200) {
+            return originalValue;
+        }
+
+        const cacheKey = '_modifiedResponseCache_' + type;
+
+        if (xhr[cacheKey] === undefined) {
+            const originalText = (type === 'text' || typeof originalValue !== 'object' || originalValue === null)
+                ? String(originalValue || '')
+                : JSON.stringify(originalValue);
+
+            xhr[cacheKey] = modifyResponseBody(originalText, xhr._interceptorUrl);
+        }
+
+        const cachedResponse = xhr[cacheKey];
+
+        try {
+            if (type === 'json' && typeof cachedResponse === 'string') {
+                const textToParse = cachedResponse.replace(ANTI_HIJACK_PREFIX, '');
+                return textToParse ? JSON.parse(textToParse) : null;
+            }
+        } catch (e) {
+            console.error(LOG_PREFIX, '[XHR] 解析缓存的 JSON 时出错:', e);
+            return originalValue;
+        }
+
+        return cachedResponse;
+    };
+
+    // 重写 responseText 属性
+    if (originalResponseTextDescriptor?.get) {
+        Object.defineProperty(xhrProto, 'responseText', {
+            get: function() {
+                const originalText = originalResponseTextDescriptor.get.call(this);
+
+                if (this.responseType && this.responseType !== 'text' && this.responseType !== "") {
+                    return originalText;
+                }
+
+                return handleXHRResponse(this, originalText, 'text');
+            },
+            configurable: true
+        });
+    }
+
+    // 重写 response 属性
+    if (originalResponseDescriptor?.get) {
+        Object.defineProperty(xhrProto, 'response', {
+            get: function() {
+                const originalResponse = originalResponseDescriptor.get.call(this);
+
+                if (this.responseType === 'json') {
+                    return handleXHRResponse(this, originalResponse, 'json');
+                }
+
+                if (!this.responseType || this.responseType === 'text' || this.responseType === "") {
+                    return handleXHRResponse(this, originalResponse, 'text');
+                }
+
+                return originalResponse;
+            },
+            configurable: true
+        });
+    }
+
+    console.log(LOG_PREFIX, '脚本已激活，Fetch 和 XHR 拦截已启用');
+})();

AIStudioProxyAPI/browser_utils/operations.py

@@ -0,0 +1,783 @@
+# --- 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:
+                    # 检查是否已经有通过网络拦截注入的模型
+                    has_network_injected_models = False
+                    if models_array_container:
+                        for entry_in_container in models_array_container:
+                            if isinstance(entry_in_container, list) and len(entry_in_container) > 10:
+                                # 检查是否有网络注入标记
+                                if "__NETWORK_INJECTED__" in entry_in_container:
+                                    has_network_injected_models = True
+                                    break
+
+                    if has_network_injected_models and not is_in_login_flow:
+                        logger.info("检测到网络拦截已注入模型")
+
+                    # 注意：不再在后端添加注入模型
+                    # 因为如果前端没有通过网络拦截注入，说明前端页面上没有这些模型
+                    # 后端返回这些模型也无法实际使用，所以只依赖网络拦截注入
+
+                    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 

AIStudioProxyAPI/browser_utils/page_controller.py

@@ -0,0 +1,914 @@
+"""
+PageController模块
+封装了所有与Playwright页面直接交互的复杂逻辑。
+"""
+import asyncio
+from typing import Callable, List, Dict, Any, Optional
+
+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,USE_URL_CONTEXT_SELECTOR,UPLOAD_BUTTON_SELECTOR,
+    SET_THINKING_BUDGET_TOGGLE_SELECTOR, THINKING_BUDGET_INPUT_SELECTOR,
+    GROUNDING_WITH_GOOGLE_SEARCH_TOGGLE_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,
+    ENABLE_URL_CONTEXT, ENABLE_THINKING_BUDGET, DEFAULT_THINKING_BUDGET, ENABLE_GOOGLE_SEARCH
+)
+from models import ClientDisconnectedError
+from .operations import save_error_snapshot, _wait_for_response_completion, _get_final_response_content
+from .initialization import enable_temporary_chat_mode
+
+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")
+
+        # 确保工具面板已展开，以便调整高级设置
+        await self._ensure_tools_panel_expanded(check_client_disconnected)
+
+        # 调整URL CONTEXT
+        if ENABLE_URL_CONTEXT:
+            await self._open_url_content(check_client_disconnected)
+        else:
+            self.logger.info(f"[{self.req_id}] URL Context 功能已禁用，跳过调整。")
+
+        # 调整“思考预算”
+        await self._handle_thinking_budget(request_params, check_client_disconnected)
+
+        # 调整 Google Search 开关
+        await self._adjust_google_search(request_params, check_client_disconnected)
+
+    async def _handle_thinking_budget(self, request_params: Dict[str, Any], check_client_disconnected: Callable):
+        """处理思考预算的调整逻辑。"""
+        reasoning_effort = request_params.get('reasoning_effort')
+
+        # 检查用户是否明确禁用了思考预算
+        should_disable_budget = isinstance(reasoning_effort, str) and reasoning_effort.lower() == 'none'
+
+        if should_disable_budget:
+            self.logger.info(f"[{self.req_id}] 用户通过 reasoning_effort='none' 明确禁用思考预算。")
+            await self._control_thinking_budget_toggle(should_be_checked=False, check_client_disconnected=check_client_disconnected)
+        elif reasoning_effort is not None:
+            # 用户指定了非 'none' 的值，则开启并设置
+            self.logger.info(f"[{self.req_id}] 用户指定了 reasoning_effort: {reasoning_effort}，将启用并设置思考预算。")
+            await self._control_thinking_budget_toggle(should_be_checked=True, check_client_disconnected=check_client_disconnected)
+            await self._adjust_thinking_budget(reasoning_effort, check_client_disconnected)
+        else:
+            # 用户未指定，根据默认配置
+            self.logger.info(f"[{self.req_id}] 用户未指定 reasoning_effort，根据默认配置 ENABLE_THINKING_BUDGET: {ENABLE_THINKING_BUDGET}。")
+            await self._control_thinking_budget_toggle(should_be_checked=ENABLE_THINKING_BUDGET, check_client_disconnected=check_client_disconnected)
+            if ENABLE_THINKING_BUDGET:
+                # 如果默认开启，则使用默认值
+                await self._adjust_thinking_budget(None, check_client_disconnected)
+
+    def _parse_thinking_budget(self, reasoning_effort: Optional[Any]) -> Optional[int]:
+        """从 reasoning_effort 解析出 token_budget。"""
+        token_budget = None
+        if reasoning_effort is None:
+            token_budget = DEFAULT_THINKING_BUDGET
+            self.logger.info(f"[{self.req_id}] 'reasoning_effort' 为空，使用默认思考预算: {token_budget}")
+        elif isinstance(reasoning_effort, int):
+            token_budget = reasoning_effort
+        elif isinstance(reasoning_effort, str):
+            if reasoning_effort.lower() == 'none':
+                token_budget = DEFAULT_THINKING_BUDGET
+                self.logger.info(f"[{self.req_id}] 'reasoning_effort' 为 'none' 字符串，使用默认思考预算: {token_budget}")
+            else:
+                effort_map = {
+                    "low": 1000,
+                    "medium": 8000,
+                    "high": 24000
+                }
+                token_budget = effort_map.get(reasoning_effort.lower())
+                if token_budget is None:
+                    try:
+                        token_budget = int(reasoning_effort)
+                    except (ValueError, TypeError):
+                        pass # token_budget remains None
+        
+        if token_budget is None:
+             self.logger.warning(f"[{self.req_id}] 无法从 '{reasoning_effort}' (类型: {type(reasoning_effort)}) 解析出有效的 token_budget。")
+
+        return token_budget
+
+    async def _adjust_thinking_budget(self, reasoning_effort: Optional[Any], check_client_disconnected: Callable):
+        """根据 reasoning_effort 调整思考预算。"""
+        self.logger.info(f"[{self.req_id}] 检查并调整思考预算，输入值: {reasoning_effort}")
+        
+        token_budget = self._parse_thinking_budget(reasoning_effort)
+
+        if token_budget is None:
+            self.logger.warning(f"[{self.req_id}] 无效的 reasoning_effort 值: '{reasoning_effort}'。跳过调整。")
+            return
+
+        budget_input_locator = self.page.locator(THINKING_BUDGET_INPUT_SELECTOR)
+        
+        try:
+            await expect_async(budget_input_locator).to_be_visible(timeout=5000)
+            await self._check_disconnect(check_client_disconnected, "思考预算调整 - 输入框可见后")
+            
+            self.logger.info(f"[{self.req_id}] 设置思考预算为: {token_budget}")
+            await budget_input_locator.fill(str(token_budget), timeout=5000)
+            await self._check_disconnect(check_client_disconnected, "思考预算调整 - 填充输入框后")
+
+            # 验证
+            await asyncio.sleep(0.1)
+            new_value_str = await budget_input_locator.input_value(timeout=3000)
+            if int(new_value_str) == token_budget:
+                self.logger.info(f"[{self.req_id}] ✅ 思考预算已成功更新为: {new_value_str}")
+            else:
+                self.logger.warning(f"[{self.req_id}] ⚠️ 思考预算更新后验证失败。页面显示: {new_value_str}, 期望: {token_budget}")
+
+        except Exception as e:
+            self.logger.error(f"[{self.req_id}] ❌ 调整思考预算时出错: {e}")
+            if isinstance(e, ClientDisconnectedError):
+                raise
+
+    def _should_enable_google_search(self, request_params: Dict[str, Any]) -> bool:
+        """根据请求参数或默认配置决定是否应启用 Google Search。"""
+        if 'tools' in request_params and request_params.get('tools') is not None:
+            tools = request_params.get('tools')
+            has_google_search_tool = False
+            if isinstance(tools, list):
+                for tool in tools:
+                    if isinstance(tool, dict):
+                        if tool.get('google_search_retrieval') is not None:
+                            has_google_search_tool = True
+                            break
+                        if tool.get('function', {}).get('name') == 'googleSearch':
+                            has_google_search_tool = True
+                            break
+            self.logger.info(f"[{self.req_id}] 请求中包含 'tools' 参数。检测到 Google Search 工具: {has_google_search_tool}。")
+            return has_google_search_tool
+        else:
+            self.logger.info(f"[{self.req_id}] 请求中不包含 'tools' 参数。使用默认配置 ENABLE_GOOGLE_SEARCH: {ENABLE_GOOGLE_SEARCH}。")
+            return ENABLE_GOOGLE_SEARCH
+
+    async def _adjust_google_search(self, request_params: Dict[str, Any], check_client_disconnected: Callable):
+        """根据请求参数或默认配置，双向控制 Google Search 开关。"""
+        self.logger.info(f"[{self.req_id}] 检查并调整 Google Search 开关...")
+
+        should_enable_search = self._should_enable_google_search(request_params)
+
+        toggle_selector = GROUNDING_WITH_GOOGLE_SEARCH_TOGGLE_SELECTOR
+        
+        try:
+            toggle_locator = self.page.locator(toggle_selector)
+            await expect_async(toggle_locator).to_be_visible(timeout=5000)
+            await self._check_disconnect(check_client_disconnected, "Google Search 开关 - 元素可见后")
+
+            is_checked_str = await toggle_locator.get_attribute("aria-checked")
+            is_currently_checked = is_checked_str == "true"
+            self.logger.info(f"[{self.req_id}] Google Search 开关当前状态: '{is_checked_str}'。期望状态: {should_enable_search}")
+
+            if should_enable_search != is_currently_checked:
+                action = "打开" if should_enable_search else "关闭"
+                self.logger.info(f"[{self.req_id}] Google Search 开关状态与期望不符。正在点击以{action}...")
+                await toggle_locator.click(timeout=CLICK_TIMEOUT_MS)
+                await self._check_disconnect(check_client_disconnected, f"Google Search 开关 - 点击{action}后")
+                await asyncio.sleep(0.5) # 等待UI更新
+                new_state = await toggle_locator.get_attribute("aria-checked")
+                if (new_state == "true") == should_enable_search:
+                    self.logger.info(f"[{self.req_id}] ✅ Google Search 开关已成功{action}。")
+                else:
+                    self.logger.warning(f"[{self.req_id}] ⚠️ Google Search 开关{action}失败。当前状态: '{new_state}'")
+            else:
+                self.logger.info(f"[{self.req_id}] Google Search 开关已处于期望状态，无需操作。")
+
+        except Exception as e:
+            self.logger.error(f"[{self.req_id}] ❌ 操作 'Google Search toggle' 开关时发生错误: {e}")
+            if isinstance(e, ClientDisconnectedError):
+                 raise
+
+    async def _ensure_tools_panel_expanded(self, check_client_disconnected: Callable):
+        """确保包含高级工具（URL上下文、思考预算等）的面板是展开的。"""
+        self.logger.info(f"[{self.req_id}] 检查并确保工具面板已展开...")
+        try:
+            collapse_tools_locator = self.page.locator('button[aria-label="Expand or collapse tools"]')
+            await expect_async(collapse_tools_locator).to_be_visible(timeout=5000)
+            
+            grandparent_locator = collapse_tools_locator.locator("xpath=../..")
+            class_string = await grandparent_locator.get_attribute("class", timeout=3000)
+
+            if class_string and "expanded" not in class_string.split():
+                self.logger.info(f"[{self.req_id}] 工具面板未展开，正在点击以展开...")
+                await collapse_tools_locator.click(timeout=CLICK_TIMEOUT_MS)
+                await self._check_disconnect(check_client_disconnected, "展开工具面板后")
+                # 等待展开动画完成
+                await expect_async(grandparent_locator).to_have_class(re.compile(r'.*expanded.*'), timeout=5000)
+                self.logger.info(f"[{self.req_id}] ✅ 工具面板已成功展开。")
+            else:
+                self.logger.info(f"[{self.req_id}] 工具面板已处于展开状态。")
+        except Exception as e:
+            self.logger.error(f"[{self.req_id}] ❌ 展开工具面板时发生错误: {e}")
+            # 即使出错，也继续尝试执行后续操作，但记录错误
+            if isinstance(e, ClientDisconnectedError):
+                raise
+
+    async def _open_url_content(self,check_client_disconnected: Callable):
+        """仅负责打开 URL Context 开关，前提是面板已展开。"""
+        try:
+            self.logger.info(f"[{self.req_id}] 检查并启用 URL Context 开关...")
+            use_url_content_selector = self.page.locator(USE_URL_CONTEXT_SELECTOR)
+            await expect_async(use_url_content_selector).to_be_visible(timeout=5000)
+            
+            is_checked = await use_url_content_selector.get_attribute("aria-checked")
+            if "false" == is_checked:
+                self.logger.info(f"[{self.req_id}] URL Context 开关未开启，正在点击以开启...")
+                await use_url_content_selector.click(timeout=CLICK_TIMEOUT_MS)
+                await self._check_disconnect(check_client_disconnected, "点击URLCONTEXT后")
+                self.logger.info(f"[{self.req_id}] ✅ URL Context 开关已点击。")
+            else:
+                self.logger.info(f"[{self.req_id}] URL Context 开关已处于开启状态。")
+        except Exception as e:
+            self.logger.error(f"[{self.req_id}] ❌ 操作 USE_URL_CONTEXT_SELECTOR 时发生错误:{e}。")
+            if isinstance(e, ClientDisconnectedError):
+                raise
+
+    async def _control_thinking_budget_toggle(self, should_be_checked: bool, check_client_disconnected: Callable):
+        """
+        根据 should_be_checked 的值，控制 "Thinking Budget" 滑块开关的状态。
+        """
+        toggle_selector = SET_THINKING_BUDGET_TOGGLE_SELECTOR
+        self.logger.info(f"[{self.req_id}] 控制 'Thinking Budget' 开关，期望状态: {'选中' if should_be_checked else '未选中'}...")
+
+        try:
+            toggle_locator = self.page.locator(toggle_selector)
+            await expect_async(toggle_locator).to_be_visible(timeout=5000)
+            await self._check_disconnect(check_client_disconnected, "思考预算开关 - 元素可见后")
+
+            is_checked_str = await toggle_locator.get_attribute("aria-checked")
+            current_state_is_checked = is_checked_str == "true"
+            self.logger.info(f"[{self.req_id}] 思考预算开关当前 'aria-checked' 状态: {is_checked_str} (当前是否选中: {current_state_is_checked})")
+
+            if current_state_is_checked != should_be_checked:
+                action = "启用" if should_be_checked else "禁用"
+                self.logger.info(f"[{self.req_id}] 思考预算开关当前状态与期望不符，正在点击以{action}...")
+                await toggle_locator.click(timeout=CLICK_TIMEOUT_MS)
+                await self._check_disconnect(check_client_disconnected, f"思考预算开关 - 点击{action}后")
+
+                await asyncio.sleep(0.5)
+                new_state_str = await toggle_locator.get_attribute("aria-checked")
+                new_state_is_checked = new_state_str == "true"
+
+                if new_state_is_checked == should_be_checked:
+                    self.logger.info(f"[{self.req_id}] ✅ 'Thinking Budget' 开关已成功{action}。新状态: {new_state_str}")
+                else:
+                    self.logger.warning(f"[{self.req_id}] ⚠️ 'Thinking Budget' 开关{action}后验证失败。期望状态: '{should_be_checked}', 实际状态: '{new_state_str}'")
+            else:
+                self.logger.info(f"[{self.req_id}] 'Thinking Budget' 开关已处于期望状态，无需操作。")
+
+        except Exception as e:
+            self.logger.error(f"[{self.req_id}] ❌ 操作 'Thinking Budget toggle' 开关时发生错误: {e}")
+            if isinstance(e, ClientDisconnectedError):
+                raise
+    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)
+                self.logger.info(f"[{self.req_id}] 聊天已清空，重新启用 '临时聊天' 模式...")
+                await enable_temporary_chat_mode(self.page)
+
+        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,image_list: List, 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")
+
+            # 上传
+            if len(image_list) > 0:
+                try:
+                    # 1. 监听文件选择器
+                    #    page.expect_file_chooser() 会返回一个上下文管理器
+                    #    当文件选择器出现时，它会得到 FileChooser 对象
+                    function_btn_localtor = self.page.locator('button[aria-label="Insert assets such as images, videos, files, or audio"]')
+                    await function_btn_localtor.click()
+                    #asyncio.sleep(0.5)
+                    async with self.page.expect_file_chooser() as fc_info:
+                        # 2. 点击那个会触发文件选择的普通按钮
+                        upload_btn_localtor = self.page.locator(UPLOAD_BUTTON_SELECTOR)
+                        await upload_btn_localtor.click()
+                        print("点击了 JS 上传按钮，等待文件选择器...")
+
+                    # 3. 获取文件选择器对象
+                    file_chooser = await fc_info.value
+                    print("文件选择器已出现。")
+
+                    # 4. 设置要上传的文件
+                    await file_chooser.set_files(image_list)
+                    print(f"已将 '{image_list}' 设置到文件选择器。")
+
+                    #asyncio.sleep(0.2)
+                    acknow_btn_locator = self.page.locator('button[aria-label="Agree to the copyright acknowledgement"]')
+                    if await acknow_btn_locator.count() > 0:
+                        await acknow_btn_locator.click()
+
+                except Exception as e:
+                    print(f"在上传文件时发生错误: {e}")
+
+            # 等待发送按钮启用
+            wait_timeout_ms_submit_enabled = 100000
+            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

AIStudioProxyAPI/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()

AIStudioProxyAPI/certs/ca.crt

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDezCCAmOgAwIBAgIUG8OzexRwcoAo18YNsf3/t4cPKoQwDQYJKoZIhvcNAQEL
+BQAwZTELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcM
+DVNhbiBGcmFuY2lzY28xETAPBgNVBAoMCFByb3h5IENBMRYwFAYDVQQDDA1Qcm94
+eSBDQSBSb290MB4XDTI1MDUxOTEwMDgxNFoXDTM1MDUxNzEwMDgxNFowZTELMAkG
+A1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDVNhbiBGcmFu
+Y2lzY28xETAPBgNVBAoMCFByb3h5IENBMRYwFAYDVQQDDA1Qcm94eSBDQSBSb290
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqpXNSaRrG9X6fin8Nk7G
+fiKO59tiFfbZZt5ls/Mc59oq60GFRfKW/oLqyntbjNHHIeUOhEI8317D+RZJA2IE
+PGcYf7ANlrzD8sPlRHl3mkSqwmmV3CtTOGpznxbHSFF02QMvF4pHTrALkJXJhXnb
+Ofo1z6i6dkCMU7nCvZTgcsvg/kay7XsLZwU165PJwMj0QjyAdI4WIVr6gr3mH9/a
+WMmLc9NU+rA4GT5n9dj/ljbd5+9KeBcZGwb4O5pcaxJENQ7+5TwsoJFbLT88IGSQ
+Wbgb99MebxD6gqxoA3j8+gnXADtIeKokbeNPblEig3p68KHJ51iChvq/tbe92Xon
+uQIDAQABoyMwITAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBpjANBgkq
+hkiG9w0BAQsFAAOCAQEAdxHc3yFi8qOqltnKoFoo0LF2Zh2y4yUDQeC2ACIhuam+
+DqfTag1oNw0Sa0o3JVQHoi1B5UslU3gB/aMqP1swVMOpw9okzStcXjKjUVSNYyTB
+fT27Ddtf4/5ftZjsdI5TznQGiv00zPh+tsi5oqCPmF6azDTXiezyx3fhR9mqdXsq
+W3rCZO/xIhKutGkRxNMBWAXXl5nAlW6FXJObZ3DRKRWjXhydk8zNQSxnxy8Z01nb
+1Frtuh/+9S9JeKX1jYKFFUzmumAq/nXY6X3yqCwbNgnqpwETXPM9DVzzs8wDC/OJ
+xDXzdHmtgRK9dHcnoT4YYUR27UX3OPS+ZGraR5RJpw==
+-----END CERTIFICATE-----

AIStudioProxyAPI/certs/ca.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCqlc1JpGsb1fp+
+Kfw2TsZ+Io7n22IV9tlm3mWz8xzn2irrQYVF8pb+gurKe1uM0cch5Q6EQjzfXsP5
+FkkDYgQ8Zxh/sA2WvMPyw+VEeXeaRKrCaZXcK1M4anOfFsdIUXTZAy8XikdOsAuQ
+lcmFeds5+jXPqLp2QIxTucK9lOByy+D+RrLtewtnBTXrk8nAyPRCPIB0jhYhWvqC
+veYf39pYyYtz01T6sDgZPmf12P+WNt3n70p4FxkbBvg7mlxrEkQ1Dv7lPCygkVst
+PzwgZJBZuBv30x5vEPqCrGgDePz6CdcAO0h4qiRt409uUSKDenrwocnnWIKG+r+1
+t73Zeie5AgMBAAECggEASQwc/IwL0b+vpJcWCatyFFF4IJExT3aFYieaJZTVq/Mg
+rd1A1NMtFY+6OzrX2VV7kGgl7zzuFDjgcqm4Wlp+td7v/r3FE+eBgVOhudDKBqWg
++d987Osgl+f92wJGFBHNl6Blag8sueVpDmEWCrJDzm/22xXFwx2g+blySvyVoJI6
+oxYE8xVu2oBG/B4CuVbJNEUNNYek39kGroTGEn+cpZJOq/NnGpatz684FstbrEiN
+xMQzl0qlI785d0DRGShApzh1hCUa+8uJJc+qACZEU+XS9MKeNzbCgc6VeEEVOytd
+7Zv0Eknt4X+E0jWdUslvHHqOgw+zN/cEpgz1GamKgQKBgQDVbbXIoNkEmN9Yd8CQ
+PjhE9Fbae0bcfYwjJY3crw+HRPs5cvi2OTsasNlZb562pSHBf3MFgCNbHb6aA+UX
+qdIeyV33a43mag1Z68Qa5pqKnCqIjY840lSDb4oqWdBesxtjj0dWOU7K2Tqu+dq4
+2ekGcLmIuPj0q6DCvNgyk6GyEwKBgQDMnGHYaP+1zW0TfNQcZgSMLMgnC3pcBCfP
+/2HDwVPVzZzNyV+N/VFtCiMD9f7cI0Bd9xAK67VOpIEF24S8fZbl77HvRzr65LkW
+HVm1XmuyTx7hseB59LMudVl9hwIcHzod+jQmXlEhuQZFOBbRgO6OIh4oGV9Z0/Xl
+Wsrc8hTYgwKBgQCIg48V0ARf02RwktBhstqNCHiRcO6nU8qSJJAzyum0zSOf4HFD
+JSIv9VRgx2uOSdtoiBvLNeXnfwQOQVWEqEPVG1n2Sx5NdiIqFQqvZjcNV8xA4cLt
+RmN2Wp7WbfJA0HFBYkDv3uIOD5pgl0IWoJNTYkDaOe5LmYfPZ7klyJZRbwKBgESM
+T6t04dZCkDxrIZSyCOv9RMDv83pIWh4w7MvsRO3oCJRY1o53Q4RIVRrKmyudE79n
+OhSuivth2Wfg90M+wAMgnngPYQ8U+X0TMC63B1WhdDMgqJezBySVY/nN9UL+ozXP
+0RDZoEyv9A3UkLB3hXRQsdG1TmCFxmekVzpWT+2JAoGAUC6/Jv8IgTq2i7sNOdY4
+HK1aJErgV15B26thFk23tfEpW6YhvCEhIsc30/n0NRczQwbgqXCZ7HSvmG9YU93K
+YDzR1hwoQ4K7NE95je9YYMmrjncL2LZFXxpnS2PdbRoi2eDh4JgTfYB93zoDgDey
+hCTKeTi+JBGdvZ93pxTCowo=
+-----END PRIVATE KEY-----

AIStudioProxyAPI/config/__init__.py

@@ -0,0 +1,90 @@
+"""
+配置模块统一入口
+导出所有配置项，便于其他模块导入使用
+"""
+
+# 从各个配置文件导入所有配置项
+from .constants import *
+from .timeouts import *
+from .selectors import *
+from .settings import *
+
+# 显式导出主要配置项（用于IDE自动完成和类型检查）
+__all__ = [
+    # 常量配置
+    'MODEL_NAME',
+    'CHAT_COMPLETION_ID_PREFIX', 
+    'DEFAULT_FALLBACK_MODEL_ID',
+    'DEFAULT_TEMPERATURE',
+    'DEFAULT_MAX_OUTPUT_TOKENS',
+    'DEFAULT_TOP_P',
+    'DEFAULT_STOP_SEQUENCES',
+    'AI_STUDIO_URL_PATTERN',
+    'MODELS_ENDPOINT_URL_CONTAINS',
+    'USER_INPUT_START_MARKER_SERVER',
+    'USER_INPUT_END_MARKER_SERVER',
+    'EXCLUDED_MODELS_FILENAME',
+    'STREAM_TIMEOUT_LOG_STATE',
+    
+    # 超时配置
+    'RESPONSE_COMPLETION_TIMEOUT',
+    'INITIAL_WAIT_MS_BEFORE_POLLING',
+    'POLLING_INTERVAL',
+    'POLLING_INTERVAL_STREAM',
+    'SILENCE_TIMEOUT_MS',
+    'POST_SPINNER_CHECK_DELAY_MS',
+    'FINAL_STATE_CHECK_TIMEOUT_MS',
+    'POST_COMPLETION_BUFFER',
+    'CLEAR_CHAT_VERIFY_TIMEOUT_MS',
+    'CLEAR_CHAT_VERIFY_INTERVAL_MS',
+    'CLICK_TIMEOUT_MS',
+    'CLIPBOARD_READ_TIMEOUT_MS',
+    'WAIT_FOR_ELEMENT_TIMEOUT_MS',
+    'PSEUDO_STREAM_DELAY',
+    
+    # 选择器配置
+    'PROMPT_TEXTAREA_SELECTOR',
+    'INPUT_SELECTOR',
+    'INPUT_SELECTOR2',
+    'SUBMIT_BUTTON_SELECTOR',
+    'CLEAR_CHAT_BUTTON_SELECTOR',
+    'CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR',
+    'RESPONSE_CONTAINER_SELECTOR',
+    'RESPONSE_TEXT_SELECTOR',
+    'LOADING_SPINNER_SELECTOR',
+    'OVERLAY_SELECTOR',
+    'ERROR_TOAST_SELECTOR',
+    'EDIT_MESSAGE_BUTTON_SELECTOR',
+    'MESSAGE_TEXTAREA_SELECTOR',
+    'FINISH_EDIT_BUTTON_SELECTOR',
+    'MORE_OPTIONS_BUTTON_SELECTOR',
+    'COPY_MARKDOWN_BUTTON_SELECTOR',
+    'COPY_MARKDOWN_BUTTON_SELECTOR_ALT',
+    'MAX_OUTPUT_TOKENS_SELECTOR',
+    'STOP_SEQUENCE_INPUT_SELECTOR',
+    'MAT_CHIP_REMOVE_BUTTON_SELECTOR',
+    'TOP_P_INPUT_SELECTOR',
+    'TEMPERATURE_INPUT_SELECTOR',
+    'USE_URL_CONTEXT_SELECTOR',
+    'UPLOAD_BUTTON_SELECTOR',
+    
+    # 设置配置
+    'DEBUG_LOGS_ENABLED',
+    'TRACE_LOGS_ENABLED',
+    'AUTO_SAVE_AUTH',
+    'AUTH_SAVE_TIMEOUT',
+    'AUTO_CONFIRM_LOGIN',
+    'AUTH_PROFILES_DIR',
+    'ACTIVE_AUTH_DIR',
+    'SAVED_AUTH_DIR',
+    'LOG_DIR',
+    'APP_LOG_FILE_PATH',
+    'NO_PROXY_ENV',
+    'ENABLE_SCRIPT_INJECTION',
+    'USERSCRIPT_PATH',
+
+    # 工具函数
+    'get_environment_variable',
+    'get_boolean_env',
+    'get_int_env',
+] 

AIStudioProxyAPI/config/constants.py

@@ -0,0 +1,53 @@
+"""
+常量配置模块
+包含所有固定的常量定义，如模型名称、标记符、文件名等
+"""
+
+import os
+import json
+from dotenv import load_dotenv
+
+# 加载 .env 文件
+load_dotenv()
+
+# --- 模型相关常量 ---
+MODEL_NAME = os.environ.get('MODEL_NAME', 'AI-Studio_Proxy_API')
+CHAT_COMPLETION_ID_PREFIX = os.environ.get('CHAT_COMPLETION_ID_PREFIX', 'chatcmpl-')
+DEFAULT_FALLBACK_MODEL_ID = os.environ.get('DEFAULT_FALLBACK_MODEL_ID', "no model list")
+
+# --- 默认参数值 ---
+DEFAULT_TEMPERATURE = float(os.environ.get('DEFAULT_TEMPERATURE', '1.0'))
+DEFAULT_MAX_OUTPUT_TOKENS = int(os.environ.get('DEFAULT_MAX_OUTPUT_TOKENS', '65536'))
+DEFAULT_TOP_P = float(os.environ.get('DEFAULT_TOP_P', '0.95'))
+# --- 默认功能开关 ---
+ENABLE_URL_CONTEXT = os.environ.get('ENABLE_URL_CONTEXT', 'false').lower() in ('true', '1', 'yes')
+ENABLE_THINKING_BUDGET = os.environ.get('ENABLE_THINKING_BUDGET', 'false').lower() in ('true', '1', 'yes')
+DEFAULT_THINKING_BUDGET = int(os.environ.get('DEFAULT_THINKING_BUDGET', '8192'))
+ENABLE_GOOGLE_SEARCH = os.environ.get('ENABLE_GOOGLE_SEARCH', 'false').lower() in ('true', '1', 'yes')
+
+# 默认停止序列 - 支持 JSON 格式配置
+try:
+    DEFAULT_STOP_SEQUENCES = json.loads(os.environ.get('DEFAULT_STOP_SEQUENCES', '["用户:"]'))
+except (json.JSONDecodeError, TypeError):
+    DEFAULT_STOP_SEQUENCES = ["用户:"]  # 回退到默认值
+
+# --- URL模式 ---
+AI_STUDIO_URL_PATTERN = os.environ.get('AI_STUDIO_URL_PATTERN', 'aistudio.google.com/')
+MODELS_ENDPOINT_URL_CONTAINS = os.environ.get('MODELS_ENDPOINT_URL_CONTAINS', "MakerSuiteService/ListModels")
+
+# --- 输入标记符 ---
+USER_INPUT_START_MARKER_SERVER = os.environ.get('USER_INPUT_START_MARKER_SERVER', "__USER_INPUT_START__")
+USER_INPUT_END_MARKER_SERVER = os.environ.get('USER_INPUT_END_MARKER_SERVER', "__USER_INPUT_END__")
+
+# --- 文件名常量 ---
+EXCLUDED_MODELS_FILENAME = os.environ.get('EXCLUDED_MODELS_FILENAME', "excluded_models.txt")
+
+# --- 流状态配置 ---
+STREAM_TIMEOUT_LOG_STATE = {
+    "consecutive_timeouts": 0,
+    "last_error_log_time": 0.0,  # 使用 time.monotonic()
+    "suppress_until_time": 0.0,  # 使用 time.monotonic()
+    "max_initial_errors": int(os.environ.get('STREAM_MAX_INITIAL_ERRORS', '3')),
+    "warning_interval_after_suppress": float(os.environ.get('STREAM_WARNING_INTERVAL_AFTER_SUPPRESS', '60.0')),
+    "suppress_duration_after_initial_burst": float(os.environ.get('STREAM_SUPPRESS_DURATION_AFTER_INITIAL_BURST', '400.0')),
+}

AIStudioProxyAPI/config/selectors.py

@@ -0,0 +1,49 @@
+"""
+CSS选择器配置模块
+包含所有用于页面元素定位的CSS选择器
+"""
+
+# --- 输入相关选择器 ---
+PROMPT_TEXTAREA_SELECTOR = 'ms-prompt-input-wrapper ms-autosize-textarea textarea'
+INPUT_SELECTOR = PROMPT_TEXTAREA_SELECTOR
+INPUT_SELECTOR2 = PROMPT_TEXTAREA_SELECTOR
+
+# --- 按钮选择器 ---
+SUBMIT_BUTTON_SELECTOR = 'button[aria-label="Run"].run-button'
+CLEAR_CHAT_BUTTON_SELECTOR = 'button[data-test-clear="outside"][aria-label="New chat"]'
+CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR = 'button.ms-button-primary:has-text("Discard and continue")'
+UPLOAD_BUTTON_SELECTOR = 'button[aria-label^="Insert assets"]'
+
+# --- 响应相关选择器 ---
+RESPONSE_CONTAINER_SELECTOR = 'ms-chat-turn .chat-turn-container.model'
+RESPONSE_TEXT_SELECTOR = 'ms-cmark-node.cmark-node'
+
+# --- 加载和状态选择器 ---
+LOADING_SPINNER_SELECTOR = 'button[aria-label="Run"].run-button svg .stoppable-spinner'
+OVERLAY_SELECTOR = '.mat-mdc-dialog-inner-container'
+
+# --- 错误提示选择器 ---
+ERROR_TOAST_SELECTOR = 'div.toast.warning, div.toast.error'
+
+# --- 编辑相关选择器 ---
+EDIT_MESSAGE_BUTTON_SELECTOR = 'ms-chat-turn:last-child .actions-container button.toggle-edit-button'
+MESSAGE_TEXTAREA_SELECTOR = 'ms-chat-turn:last-child ms-text-chunk ms-autosize-textarea'
+FINISH_EDIT_BUTTON_SELECTOR = 'ms-chat-turn:last-child .actions-container button.toggle-edit-button[aria-label="Stop editing"]'
+
+# --- 菜单和复制相关选择器 ---
+MORE_OPTIONS_BUTTON_SELECTOR = 'div.actions-container div ms-chat-turn-options div > button'
+COPY_MARKDOWN_BUTTON_SELECTOR = 'button.mat-mdc-menu-item:nth-child(4)'
+COPY_MARKDOWN_BUTTON_SELECTOR_ALT = 'div[role="menu"] button:has-text("Copy Markdown")'
+
+# --- 设置相关选择器 ---
+MAX_OUTPUT_TOKENS_SELECTOR = 'input[aria-label="Maximum output tokens"]'
+STOP_SEQUENCE_INPUT_SELECTOR = 'input[aria-label="Add stop token"]'
+MAT_CHIP_REMOVE_BUTTON_SELECTOR = 'mat-chip-set mat-chip-row button[aria-label*="Remove"]'
+TOP_P_INPUT_SELECTOR = 'ms-slider input[type="number"][max="1"]'
+TEMPERATURE_INPUT_SELECTOR = 'ms-slider input[type="number"][max="2"]'
+USE_URL_CONTEXT_SELECTOR = 'button[aria-label="Browse the url context"]'
+SET_THINKING_BUDGET_TOGGLE_SELECTOR = 'button[aria-label="Toggle thinking budget between auto and manual"]'
+# Thinking budget slider input
+THINKING_BUDGET_INPUT_SELECTOR = '//div[contains(@class, "settings-item") and .//p[normalize-space()="Set thinking budget"]]/following-sibling::div//input[@type="number"]'
+# --- Google Search Grounding ---
+GROUNDING_WITH_GOOGLE_SEARCH_TOGGLE_SELECTOR = 'div[data-test-id="searchAsAToolTooltip"] mat-slide-toggle button'

AIStudioProxyAPI/config/settings.py

@@ -0,0 +1,54 @@
+"""
+主要设置配置模块
+包含环境变量配置、路径配置、代理配置等运行时设置
+"""
+
+import os
+from dotenv import load_dotenv
+
+# 加载 .env 文件
+load_dotenv()
+
+# --- 全局日志控制配置 ---
+DEBUG_LOGS_ENABLED = os.environ.get('DEBUG_LOGS_ENABLED', 'false').lower() in ('true', '1', 'yes')
+TRACE_LOGS_ENABLED = os.environ.get('TRACE_LOGS_ENABLED', 'false').lower() in ('true', '1', 'yes')
+
+# --- 认证相关配置 ---
+AUTO_SAVE_AUTH = os.environ.get('AUTO_SAVE_AUTH', '').lower() in ('1', 'true', 'yes')
+AUTH_SAVE_TIMEOUT = int(os.environ.get('AUTH_SAVE_TIMEOUT', '30'))
+AUTO_CONFIRM_LOGIN = os.environ.get('AUTO_CONFIRM_LOGIN', 'true').lower() in ('1', 'true', 'yes')
+
+# --- 路径配置 ---
+AUTH_PROFILES_DIR = os.path.join(os.path.dirname(__file__), '..', 'auth_profiles')
+ACTIVE_AUTH_DIR = os.path.join(AUTH_PROFILES_DIR, 'active')
+SAVED_AUTH_DIR = os.path.join(AUTH_PROFILES_DIR, 'saved')
+LOG_DIR = os.path.join(os.path.dirname(__file__), '..', 'logs')
+APP_LOG_FILE_PATH = os.path.join(LOG_DIR, 'app.log')
+
+def get_environment_variable(key: str, default: str = '') -> str:
+    """获取环境变量值"""
+    return os.environ.get(key, default)
+
+def get_boolean_env(key: str, default: bool = False) -> bool:
+    """获取布尔型环境变量"""
+    value = os.environ.get(key, '').lower()
+    if default:
+        return value not in ('false', '0', 'no', 'off')
+    else:
+        return value in ('true', '1', 'yes', 'on')
+
+def get_int_env(key: str, default: int = 0) -> int:
+    """获取整型环境变量"""
+    try:
+        return int(os.environ.get(key, str(default)))
+    except (ValueError, TypeError):
+        return default
+
+# --- 代理配置 ---
+# 注意：代理配置现在在 api_utils/app.py 中动态设置，根据 STREAM_PORT 环境变量决定
+NO_PROXY_ENV = os.environ.get('NO_PROXY')
+
+# --- 脚本注入配置 ---
+ENABLE_SCRIPT_INJECTION = get_boolean_env('ENABLE_SCRIPT_INJECTION', True)
+USERSCRIPT_PATH = get_environment_variable('USERSCRIPT_PATH', 'browser_utils/more_modles.js')
+# 注意：MODEL_CONFIG_PATH 已废弃，现在直接从油猴脚本解析模型数据

AIStudioProxyAPI/config/timeouts.py

@@ -0,0 +1,40 @@
+"""
+超时和时间配置模块
+包含所有超时时间、轮询间隔等时间相关配置
+"""
+
+import os
+from dotenv import load_dotenv
+
+# 加载 .env 文件
+load_dotenv()
+
+# --- 响应等待配置 ---
+RESPONSE_COMPLETION_TIMEOUT = int(os.environ.get('RESPONSE_COMPLETION_TIMEOUT', '300000'))  # 5 minutes total timeout (in ms)
+INITIAL_WAIT_MS_BEFORE_POLLING = int(os.environ.get('INITIAL_WAIT_MS_BEFORE_POLLING', '500'))  # ms, initial wait before polling for response completion
+
+# --- 轮询间隔配置 ---
+POLLING_INTERVAL = int(os.environ.get('POLLING_INTERVAL', '300'))  # ms
+POLLING_INTERVAL_STREAM = int(os.environ.get('POLLING_INTERVAL_STREAM', '180'))  # ms
+
+# --- 静默超时配置 ---
+SILENCE_TIMEOUT_MS = int(os.environ.get('SILENCE_TIMEOUT_MS', '60000'))  # ms
+
+# --- 页面操作超时配置 ---
+POST_SPINNER_CHECK_DELAY_MS = int(os.environ.get('POST_SPINNER_CHECK_DELAY_MS', '500'))
+FINAL_STATE_CHECK_TIMEOUT_MS = int(os.environ.get('FINAL_STATE_CHECK_TIMEOUT_MS', '1500'))
+POST_COMPLETION_BUFFER = int(os.environ.get('POST_COMPLETION_BUFFER', '700'))
+
+# --- 清理聊天相关超时 ---
+CLEAR_CHAT_VERIFY_TIMEOUT_MS = int(os.environ.get('CLEAR_CHAT_VERIFY_TIMEOUT_MS', '5000'))
+CLEAR_CHAT_VERIFY_INTERVAL_MS = int(os.environ.get('CLEAR_CHAT_VERIFY_INTERVAL_MS', '2000'))
+
+# --- 点击和剪贴板操作超时 ---
+CLICK_TIMEOUT_MS = int(os.environ.get('CLICK_TIMEOUT_MS', '3000'))
+CLIPBOARD_READ_TIMEOUT_MS = int(os.environ.get('CLIPBOARD_READ_TIMEOUT_MS', '3000'))
+
+# --- 元素等待超时 ---
+WAIT_FOR_ELEMENT_TIMEOUT_MS = int(os.environ.get('WAIT_FOR_ELEMENT_TIMEOUT_MS', '10000'))  # Timeout for waiting for elements like overlays
+
+# --- 流相关配置 ---
+PSEUDO_STREAM_DELAY = float(os.environ.get('PSEUDO_STREAM_DELAY', '0.01'))

AIStudioProxyAPI/deprecated_javascript_version/README.md

@@ -0,0 +1,233 @@
+# AI Studio Proxy Server (Javascript Version - DEPRECATED)
+
+**⚠️ 警告：此 Javascript 版本 (`server.cjs`, `auto_connect_aistudio.cjs`) 已被弃用且不再维护。推荐使用项目根目录下的 Python 版本，该版本采用了模块化架构设计，具有更好的稳定性和可维护性。**
+
+**📖 查看最新文档**: 请参考项目根目录下的 [`README.md`](../README.md) 了解当前Python版本的完整使用说明。
+
+---
+
+[点击查看项目使用演示视频](https://drive.google.com/file/d/1efR-cNG2CNboNpogHA1ASzmx45wO579p/view?usp=drive_link)
+
+这是一个 Node.js + Playwright 服务器，通过模拟 OpenAI API 的方式来访问 Google AI Studio 网页版，服务器无缝交互转发 Gemini 对话。这使得兼容 OpenAI API 的客户端（如 Open WebUI, NextChat 等）可以使用 AI Studio 的无限额度及能力。
+
+## ✨ 特性 (Javascript 版本)
+
+*   **OpenAI API 兼容**: 提供 `/v1/chat/completions` 和 `/v1/models` 端点，兼容大多数 OpenAI 客户端。
+*   **流式响应**: 支持 `stream=true`，实现打字机效果。
+*   **非流式响应**: 支持 `stream=false`，一次性返回完整 JSON 响应。
+*   **系统提示词 (System Prompt)**: 支持通过请求体中的 `messages` 数组的 `system` 角色或额外的 `system_prompt` 字段传递系统提示词。
+*   **内部 Prompt 优化**: 自动包装用户输入，指导 AI Studio 输出特定格式（流式为 Markdown 代码块，非流式为 JSON），并包含起始标记 `<<<START_RESPONSE>>>` 以便解析。
+*   **自动连接脚本 (`auto_connect_aistudio.cjs`)**:
+    *   自动查找并启动 Chrome/Chromium 浏览器，开启调试端口，**并设置特定窗口宽度 (460px)** 以优化布局，确保"清空聊天"按钮可见。
+    *   自动检测并尝试连接已存在的 Chrome 调试实例。
+    *   提供交互式选项，允许用户选择连接现有实例或自动结束冲突进程。
+    *   自动查找或打开 AI Studio 的 `New chat` 页面。
+    *   自动启动 `server.cjs`。
+*   **服务端 (`server.cjs`)**:
+    *   连接到由 `auto_connect_aistudio.cjs` 管理的 Chrome 实例。
+    *   **自动清空上下文**: 当检测到来自客户端的请求可能是"新对话"时（基于消息历史长度），自动模拟点击 AI Studio 页面上的"Clear chat"按钮及其确认对话框，并验证清空效果，以实现更好的会话隔离。
+    *   处理 API 请求，通过 Playwright 操作 AI Studio 页面。
+    *   解析 AI Studio 的响应，提取有效内容。
+    *   提供简单的 Web UI (`/`) 进行基本测试。
+    *   提供健康检查端点 (`/health`)。
+*   **错误快照**: 在 Playwright 操作、响应解析或**清空聊天**出错时，自动在项目根目录下的 `errors/` 目录下保存页面截图和 HTML，方便调试。(注意: Python 版本错误快照在 `errors_py/`)
+*   **依赖检测**: 两个脚本在启动时都会检查所需依赖，并提供安装指导。
+*   **跨平台设计**: 旨在支持 macOS, Linux 和 Windows (WSL 推荐)。
+
+## ⚠️ 重要提示 (Javascript 版本)
+
+*   **非官方项目**: 本项目与 Google 无关，依赖于对 AI Studio Web 界面的自动化操作，可能因 AI Studio 页面更新而失效。
+*   **自动清空功能的脆弱性**: 自动清空上下文的功能依赖于精确的 UI 元素选择器 (`CLEAR_CHAT_BUTTON_SELECTOR`, `CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR` 在 `server.cjs` 中)。如果 AI Studio 页面结构发生变化，此功能可能会失效。届时需要更新这些选择器。
+*   **不支持历史编辑/分叉**: 即使实现了新对话的上下文清空，本代理仍然无法支持客户端进行历史消息编辑并从该点重新生成对话的功能。AI Studio 内部维护的对话历史是线性的。
+*   **固定窗口宽度**: `auto_connect_aistudio.cjs` 会以固定的宽度 (460px) 启动 Chrome 窗口，以确保清空按钮可见。
+*   **安全性**: 启动 Chrome 时开启了远程调试端口 (默认为 `8848`)，请确保此端口仅在受信任的网络环境中使用，或通过防火墙规则限制访问。切勿将此端口暴露到公网。
+*   **稳定性**: 由于依赖浏览器自动化，其稳定性不如官方 API。长时间运行或频繁请求可能导致页面无响应或连接中断，可能需要重启浏览器或服务器。
+*   **AI Studio 限制**: AI Studio 本身可能有请求频率限制、内容策略限制等，代理服务器无法绕过这些限制。
+*   **参数配置**: **像模型选择、温度、输出长度等参数，需要您直接在 AI Studio 页面的右侧设置面板中进行调整。本代理服务器目前不处理或转发这些通过 API 请求传递的参数。** 您需要预先在 AI Studio Web UI 中设置好所需的模型和参数。
+
+## 🛠️ 配置 (Javascript 版本)
+
+虽然不建议频繁修改，但了解以下常量可能有助于理解脚本行为或在特殊情况下进行调整：
+
+**`auto_connect_aistudio.cjs`:**
+
+*   `DEBUGGING_PORT`: (默认 `8848`) Chrome 浏览器启动时使用的远程调试端口。
+*   `TARGET_URL`: (默认 `'https://aistudio.google.com/prompts/new_chat'`) 脚本尝试打开或导航到的 AI Studio 页面。
+*   `SERVER_SCRIPT_FILENAME`: (默认 `'server.cjs'`) 由此脚本自动启动的 API 服务器文件名。
+*   `CONNECT_TIMEOUT_MS`: (默认 `20000`) 连接到 Chrome 调试端口的超时时间 (毫秒)。
+*   `NAVIGATION_TIMEOUT_MS`: (默认 `35000`) Playwright 等待页面导航完成的超时时间 (毫秒)。
+*   `--window-size=460,...`: 启动 Chrome 时传递的参数，固定宽度以保证 UI 元素（如清空按钮）位置相对稳定。
+
+**`server.cjs`:**
+
+*   `SERVER_PORT`: (默认 `2048`) API 服务器监听的端口。
+*   `AI_STUDIO_URL_PATTERN`: (默认 `'aistudio.google.com/'`) 用于识别 AI Studio 页面的 URL 片段。
+*   `RESPONSE_COMPLETION_TIMEOUT`: (默认 `300000`) 等待 AI Studio 响应完成的总超时时间 (毫秒，5分钟)。
+*   `POLLING_INTERVAL`: (默认 `300`) 轮询检查 AI Studio 页面状态的间隔 (毫秒)。
+*   `SILENCE_TIMEOUT_MS`: (默认 `3000`) 判断 AI Studio 是否停止输出的静默超时时间 (毫秒)。
+*   `CLEAR_CHAT_VERIFY_TIMEOUT_MS`: (默认 `5000`) 等待并验证清空聊天操作完成的超时时间 (毫秒)。
+*   **CSS 选择器**: (`INPUT_SELECTOR`, `SUBMIT_BUTTON_SELECTOR`, `RESPONSE_CONTAINER_SELECTOR`, `LOADING_SPINNER_SELECTOR`, `ERROR_TOAST_SELECTOR`, `CLEAR_CHAT_BUTTON_SELECTOR`, `CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR`) 这些常量定义了脚本用于查找页面元素的选择器。**修改这些值需要具备前端知识，并且如果 AI Studio 页面更新，这些是最可能需要调整的部分。**
+
+## ⚙️ Prompt 内部处理 (Javascript 版本)
+
+为了让代理能够解析 AI Studio 的输出，`server.cjs` 会在将你的 Prompt 发送到 AI Studio 前进行包装，加入特定的指令，要求 AI：
+
+1.  **对于非流式请求 (`stream=false`)**: 将整个回复包裹在一个 JSON 对象中，格式为 `{"response": "<<<START_RESPONSE>>>[AI的实际回复]"}`。
+2.  **对于流式请求 (`stream=true`)**: 将整个回复（包括开始和结束）包裹在一个 Markdown 代码块 (```) 中，并在实际回复前加上标记 `<<<START_RESPONSE>>>`，形如：
+    ```markdown
+    ```
+    <<<START_RESPONSE>>>[AI的实际回复第一部分]
+    [AI的实际回复第二部分]
+    ...
+    ```
+    ```
+
+`server.cjs` 会查找 `<<<START_RESPONSE>>>` 标记来提取真正的回复内容。这意味着你通过 API 得到的回复是经过这个内部处理流程的，AI Studio 页面的原始输出格式会被改变。
+
+## 🚀 开始使用 (Javascript 版本)
+
+### 1. 先决条件
+
+*   **Node.js**: v16 或更高版本。
+*   **NPM / Yarn / PNPM**: 用于安装依赖。
+*   **Google Chrome / Chromium**: 需要安装浏览器本体。
+*   **Google AI Studio 账号**: 并能正常访问和使用。
+
+### 2. 安装
+
+1.  **进入弃用版本目录**:
+    ```bash
+    cd deprecated_javascript_version
+    ```
+
+2.  **安装依赖**:
+    根据 `package.json` 文件，脚本运行需要以下核心依赖：
+    *   `express`: Web 框架，用于构建 API 服务器。
+    *   `cors`: 处理跨域资源共享。
+    *   `playwright`: 浏览器自动化库。
+    *   `@playwright/test`: Playwright 的测试库，`server.cjs` 使用其 `expect` 功能进行断言。
+
+    使用你的包管理器安装：
+    ```bash
+    npm install
+    # 或
+    yarn install
+    # 或
+    pnpm install
+    ```
+
+### 3. 运行
+
+只需要运行 `auto_connect_aistudio.cjs` 脚本即可启动所有服务：
+
+```bash
+node auto_connect_aistudio.cjs
+```
+
+这个脚本会执行以下操作：
+
+1.  **检查依赖**: 确认上述 Node.js 模块已安装，且 `server.cjs` 文件存在。
+2.  **检查 Chrome 调试端口 (`8848`)**:
+    *   如果端口空闲，尝试自动查找并启动一个新的 Chrome 实例（窗口宽度固定为 460px），并打开远程调试端口。
+    *   如果端口被占用，询问用户是连接现有实例还是尝试清理端口后启动新实例。
+3.  **连接 Playwright**: 尝试连接到 Chrome 的调试端口 (`http://127.0.0.1:8848`)。
+4.  **管理 AI Studio 页面**: 查找或打开 AI Studio 的 `New chat` 页面 (`https://aistudio.google.com/prompts/new_chat`)，并尝试置于前台。
+5.  **启动 API 服务器**: 如果以上步骤成功，脚本会自动在后台启动 `node server.cjs`。
+
+当 `server.cjs` 成功启动并连接到 Playwright 后，您将在终端看到类似以下的输出（来自 `server.cjs`）：
+
+```
+=============================================================
+          🚀 AI Studio Proxy Server (vX.XX - Queue & Auto Clear) 🚀
+=============================================================
+🔗 监听地址: http://localhost:2048
+   - Web UI (测试): http://localhost:2048/
+   - API 端点:   http://localhost:2048/v1/chat/completions
+   - 模型接口:   http://localhost:2048/v1/models
+   - 健康检查:   http://localhost:2048/health
+-------------------------------------------------------------
+✅ Playwright 连接成功，服务已准备就绪！
+-------------------------------------------------------------
+```
+*(版本号可能不同)*
+
+此时，代理服务已准备就绪，监听在 `http://localhost:2048`。
+
+### 4. 配置客户端 (以 Open WebUI 为例)
+
+1.  打开 Open WebUI。
+2.  进入 "设置" -> "连接"。
+3.  在 "模型" 部分，点击 "添加模型"。
+4.  **模型名称**: 输入你想要的名字，例如 `aistudio-gemini-cjs`。
+5.  **API 基础 URL**: 输入代理服务器的地址，例如 `http://localhost:2048/v1` (注意包含 `/v1`)。
+6.  **API 密钥**: 留空或输入任意字符 (服务器不验证)。
+7.  保存设置。
+8.  现在，你应该可以在 Open WebUI 中选择 `aistudio-gemini-cjs` 模型并开始聊天了。
+
+### 5. 使用测试脚本 (可选)
+
+本目录下提供了一个 `test.js` 脚本，用于在命令行中直接与代理进行交互式聊天。
+
+1.  **安装额外依赖**: `test.js` 使用了 OpenAI 的官方 Node.js SDK。
+    ```bash
+    npm install openai
+    # 或 yarn add openai / pnpm add openai
+    ```
+2.  **检查配置**: 打开 `test.js`，确认 `LOCAL_PROXY_URL` 指向你的代理服务器地址 (`http://127.0.0.1:2048/v1/`)。`DUMMY_API_KEY` 可以保持不变。
+3.  **运行测试**: 在 `deprecated_javascript_version` 目录下运行：
+    ```bash
+    node test.js
+    ```
+    之后就可以在命令行输入问题进行测试了。输入 `exit` 退出。
+
+## 💻 多平台指南 (Javascript 版本)
+
+*   **macOS**:
+    *   `auto_connect_aistudio.cjs` 通常能自动找到 Chrome。
+    *   防火墙可能会提示是否允许 Node.js 接受网络连接，请允许。
+*   **Linux**:
+    *   确保已安装 `google-chrome-stable` 或 `chromium-browser`。
+    *   如果脚本找不到 Chrome，你可能需要修改 `auto_connect_aistudio.cjs` 中的 `getChromePath` 函数，手动指定路径，或者创建一个符号链接 (`/usr/bin/google-chrome`) 指向实际的 Chrome 可执行文件。
+    *   某些 Linux 发行版可能需要安装额外的 Playwright 依赖库，参考 [Playwright Linux 文档](https://playwright.dev/docs/intro#system-requirements)。运行 `npx playwright install-deps` 可能有助于安装。
+*   **Windows**:
+    *   **强烈建议使用 WSL (Windows Subsystem for Linux)**。在 WSL 中按照 Linux 指南操作通常更顺畅。
+    *   **直接在 Windows 上运行 (不推荐)**:
+        *   `auto_connect_aistudio.cjs` 可能需要手动修改 `getChromePath` 函数来指定 Chrome 的完整路径 (例如 `C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe`)。注意路径中的反斜杠需要转义 (`\\`)。
+        *   防火墙设置需要允许 Node.js 和 Chrome 监听和连接端口 (`8848` 和 `2048`)。
+        *   由于文件系统和权限差异，可能会遇到未知问题，例如端口检查或进程结束操作 (`taskkill`) 失败。
+
+## 🔧 故障排除 (Javascript 版本)
+
+*   **`auto_connect_aistudio.cjs` 启动失败或报错**:
+    *   **依赖未找到**: 确认运行了 `npm install` 等命令。
+    *   **Chrome 路径找不到**: 确认 Chrome/Chromium 已安装，并按需修改 `getChromePath` 函数或创建符号链接 (Linux)。
+    *   **端口 (`8848`) 被占用且无法自动清理**: 根据脚本提示，使用系统工具（如 `lsof -i :8848` / `tasklist | findstr "8848"`）手动查找并结束占用端口的进程。
+    *   **连接 Playwright 超时**: 确认 Chrome 是否已成功启动并监听 `8848` 端口，防火墙是否阻止本地连接 `127.0.0.1:8848`。查看 `auto_connect_aistudio.cjs` 中的 `CONNECT_TIMEOUT_MS` 是否足够。
+    *   **打开/导航 AI Studio 页面失败**: 检查网络连接，尝试手动在浏览器中打开 `https://aistudio.google.com/prompts/new_chat` 并完成登录。查看 `NAVIGATION_TIMEOUT_MS` 是否足够。
+    *   **窗口大小问题**: 如果 460px 宽度导致问题，可以尝试修改 `auto_connect_aistudio.cjs` 中的 `--window-size` 参数，但这可能影响自动清空功能。
+*   **`server.cjs` 启动时提示端口被占用 (`EADDRINUSE`)**:
+    *   检查是否有其他程序 (包括旧的服务器实例) 正在使用 `2048` 端口。关闭冲突程序或修改 `server.cjs` 中的 `SERVER_PORT`。
+*   **服务器日志显示 Playwright 未就绪或连接失败 (在 `server.cjs` 启动后)**:
+    *   通常意味着 `auto_connect_aistudio.cjs` 启动的 Chrome 实例意外关闭或无响应。检查 Chrome 窗口是否还在，AI Studio 页面是否崩溃。
+    *   尝试关闭所有相关进程（`node` 和 `chrome`），然后重新运行 `node auto_connect_aistudio.cjs`。
+    *   检查根目录下的 `errors/` 目录是否有截图和 HTML 文件，它们可能包含 AI Studio 页面的错误信息或状态。
+*   **客户端 (如 Open WebUI) 无法连接或请求失败**: 
+    *   确认 API 基础 URL 配置正确 (`http://localhost:2048/v1`)。
+    *   检查 `server.cjs` 运行的终端是否有错误输出。
+    *   确保客户端和服务器在同一网络中，且防火墙没有阻止从客户端到服务器 `2048` 端口的连接。
+*   **API 请求返回 5xx 错误**: 
+    *   **503 Service Unavailable / Playwright not ready**: `server.cjs` 无法连接到 Chrome。
+    *   **504 Gateway Timeout**: 请求处理时间超过了 `RESPONSE_COMPLETION_TIMEOUT`。可能是 AI Studio 响应慢或卡住了。
+    *   **502 Bad Gateway / AI Studio Error**: `server.cjs` 在 AI Studio 页面上检测到了错误提示 (`toast` 消息)，或无法正确解析 AI 的响应。检查 `errors/` 快照。
+    *   **500 Internal Server Error**: `server.cjs` 内部发生未捕获的错误。检查服务器日志和 `errors/` 快照。
+*   **AI 回复不完整、格式错误或包含 `<<<START_RESPONSE>>>` 标记**: 
+    *   AI Studio 的 Web UI 输出不稳定。服务器尽力解析，但可能失败。
+    *   非流式请求：如果返回的 JSON 中缺少 `response` 字段或无法解析，服务器可能返回空内容或原始 JSON 字符串。检查 `errors/` 快照确认 AI Studio 页面的实际输出。
+    *   流式请求：如果 AI 未按预期输出 Markdown 代码块或起始标记，流式传输可能提前中断或包含非预期内容。
+    *   尝试调整 Prompt 或稍后重试。
+*   **自动清空上下文失败**:
+    *   服务器日志出现 "清空聊天记录或验证时出错" 或 "验证超时" 的警告。
+    *   **原因**: AI Studio 网页更新导致 `server.cjs` 中的 `CLEAR_CHAT_BUTTON_SELECTOR` 或 `CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR` 失效。
+    *   **解决**: 检查 `errors/` 快照，使用浏览器开发者工具检查实际页面元素，并更新 `server.cjs` 文件顶部的选择器常量。
+    *   **原因**: 清空操作本身耗时超过了 `CLEAR_CHAT_VERIFY_TIMEOUT_MS`。
+    *   **解决**: 如果网络或机器较慢，可以尝试在 `server.cjs` 中适当增加这个超时时间。 

AIStudioProxyAPI/deprecated_javascript_version/auto_connect_aistudio.cjs

@@ -0,0 +1,595 @@
+#!/usr/bin/env node
+
+// auto_connect_aistudio.js (v2.9 - Refined Launch & Page Handling + Beautified Output)
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const readline = require('readline');
+
+// --- Configuration ---
+const DEBUGGING_PORT = 8848;
+const TARGET_URL = 'https://aistudio.google.com/prompts/new_chat'; // Target page
+const SERVER_SCRIPT_FILENAME = 'server.cjs'; // Corrected script name
+const CONNECTION_RETRIES = 5;
+const RETRY_DELAY_MS = 4000;
+const CONNECT_TIMEOUT_MS = 20000; // Timeout for connecting to CDP
+const NAVIGATION_TIMEOUT_MS = 35000; // Increased timeout for page navigation
+const CDP_ADDRESS = `http://127.0.0.1:${DEBUGGING_PORT}`;
+
+// --- ANSI Colors ---
+const RESET = '\x1b[0m';
+const BRIGHT = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const BLUE = '\x1b[34m';
+const MAGENTA = '\x1b[35m';
+const CYAN = '\x1b[36m';
+
+// --- Globals ---
+const SERVER_SCRIPT_PATH = path.join(__dirname, SERVER_SCRIPT_FILENAME);
+let playwright; // Loaded in checkDependencies
+
+// --- Platform-Specific Chrome Path ---
+function getChromePath() {
+    switch (process.platform) {
+        case 'darwin':
+            return '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+        case 'win32':
+            // 尝试 Program Files 和 Program Files (x86)
+            const winPaths = [
+                path.join(process.env.ProgramFiles || '', 'Google\Chrome\Application\chrome.exe'),
+                path.join(process.env['ProgramFiles(x86)'] || '', 'Google\Chrome\Application\chrome.exe')
+            ];
+            return winPaths.find(p => fs.existsSync(p));
+        case 'linux':
+            // 尝试常见的 Linux 路径
+            const linuxPaths = [
+                '/usr/bin/google-chrome',
+                '/usr/bin/google-chrome-stable',
+                '/opt/google/chrome/chrome',
+                // Add path for Flatpak installation if needed
+                // '/var/lib/flatpak/exports/bin/com.google.Chrome'
+            ];
+            return linuxPaths.find(p => fs.existsSync(p));
+        default:
+            return null; // 不支持的平台
+    }
+}
+
+const chromeExecutablePath = getChromePath();
+
+// --- 端口检查函数 ---
+function isPortInUse(port) {
+    const platform = process.platform;
+    let command;
+    // console.log(`${DIM}   检查端口 ${port}...${RESET}`); // Optional: Verbose check
+    try {
+        if (platform === 'win32') {
+            // 在 Windows 上，查找监听状态的 TCP 端口
+            command = `netstat -ano | findstr LISTENING | findstr :${port}`;
+            execSync(command); // 如果找到，不会抛出错误
+            return true;
+        } else if (platform === 'darwin' || platform === 'linux') {
+            // 在 macOS 或 Linux 上，查找监听该端口的进程
+            command = `lsof -i tcp:${port} -sTCP:LISTEN`;
+            execSync(command); // 如果找到，不会抛出错误
+            return true;
+        }
+    } catch (error) {
+        // 如果命令执行失败（通常意味着找不到匹配的进程），则端口未被占用
+        // console.log(`端口 ${port} 检查命令执行失败或未找到进程:`, error.message.split('\n')[0]); // 可选的调试信息
+        return false;
+    }
+    // 对于不支持的平台，保守地假设端口未被占用
+    return false;
+}
+
+// --- 查找占用端口的 PID --- (新增)
+function findPidsUsingPort(port) {
+    const platform = process.platform;
+    const pids = [];
+    let command;
+    try {
+        console.log(`${DIM}   正在查找占用端口 ${port} 的进程...${RESET}`);
+        if (platform === 'win32') {
+            command = `netstat -ano | findstr LISTENING | findstr :${port}`;
+            const output = execSync(command).toString();
+            const lines = output.trim().split('\n');
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                const pid = parts[parts.length - 1]; // PID is the last column
+                if (pid && !isNaN(pid)) {
+                    pids.push(pid);
+                }
+            }
+        } else { // macOS or Linux
+            command = `lsof -t -i tcp:${port} -sTCP:LISTEN`;
+            const output = execSync(command).toString();
+            const lines = output.trim().split('\n');
+            for (const line of lines) {
+                const pid = line.trim();
+                if (pid && !isNaN(pid)) {
+                    pids.push(pid);
+                }
+            }
+        }
+        if (pids.length > 0) {
+             console.log(`   ${YELLOW}找到占用端口 ${port} 的 PID: ${pids.join(', ')}${RESET}`);
+        } else {
+             console.log(`   ${GREEN}未找到明确监听端口 ${port} 的进程。${RESET}`);
+        }
+    } catch (error) {
+        // 命令失败通常意味着没有找到进程
+        console.log(`   ${GREEN}查找端口 ${port} 进程的命令执行失败或无结果。${RESET}`);
+    }
+    return [...new Set(pids)]; // 返回去重后的 PID 列表
+}
+
+// --- 结束进程 --- (新增)
+function killProcesses(pids) {
+    if (pids.length === 0) return true; // 没有进程需要结束
+
+    const platform = process.platform;
+    let success = true;
+    console.log(`${YELLOW}   正在尝试结束 PID: ${pids.join(', ')}...${RESET}`);
+
+    for (const pid of pids) {
+        try {
+            if (platform === 'win32') {
+                execSync(`taskkill /F /PID ${pid}`);
+                console.log(`   ${GREEN}✅ 成功结束 PID ${pid} (Windows)${RESET}`);
+            } else { // macOS or Linux
+                execSync(`kill -9 ${pid}`);
+                console.log(`   ${GREEN}✅ 成功结束 PID ${pid} (macOS/Linux)${RESET}`);
+            }
+        } catch (error) {
+            console.warn(`   ${RED}⚠️ 结束 PID ${pid} 时出错: ${error.message.split('\n')[0]}${RESET}`);
+            // 可能原因：进程已不存在、权限不足等
+            success = false; // 标记至少有一个失败了
+        }
+    }
+    return success;
+}
+
+// --- 创建 Readline Interface ---
+function askQuestion(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+
+    return new Promise(resolve => rl.question(query, ans => {
+        rl.close();
+        resolve(ans);
+    }))
+}
+
+// --- 步骤 1: 检查 Playwright 依赖 ---
+async function checkDependencies() {
+    console.log(`${CYAN}-------------------------------------------------${RESET}`);
+    console.log(`${CYAN}--- 步骤 1: 检查依赖项 ---${RESET}`);
+    console.log('将检查以下模块是否已安装:');
+    const requiredModules = ['express', 'playwright', '@playwright/test', 'cors'];
+    const missingModules = [];
+    let allFound = true;
+
+    for (const moduleName of requiredModules) {
+        process.stdout.write(`   - ${moduleName} ... `);
+        try {
+            require.resolve(moduleName); // Use require.resolve for checking existence without loading
+            console.log(`${GREEN}✓ 已找到${RESET}`); // Green checkmark
+        } catch (error) {
+            if (error.code === 'MODULE_NOT_FOUND') {
+                console.log(`${RED}❌ 未找到${RESET}`); // Red X
+                missingModules.push(moduleName);
+                allFound = false;
+            } else {
+                console.log(`${RED}❌ 检查时出错: ${error.message}${RESET}`);
+                allFound = false;
+                // Consider exiting if it's not MODULE_NOT_FOUND?
+                // return false;
+            }
+        }
+    }
+
+    process.stdout.write(`   - 服务器脚本 (${SERVER_SCRIPT_FILENAME}) ... `);
+    if (!fs.existsSync(SERVER_SCRIPT_PATH)) {
+        console.log(`${RED}❌ 未找到${RESET}`); // Red X
+        console.error(`     ${RED}错误: 未在预期路径找到 '${SERVER_SCRIPT_FILENAME}' 文件。${RESET}`);
+        console.error(`     预期路径: ${SERVER_SCRIPT_PATH}`);
+        console.error(`     请确保 '${SERVER_SCRIPT_FILENAME}' 与此脚本位于同一目录。`);
+        allFound = false;
+    } else {
+        console.log(`${GREEN}✓ 已找到${RESET}`); // Green checkmark
+    }
+
+    if (!allFound) {
+        console.log(`\n${RED}-------------------------------------------------${RESET}`);
+        console.error(`${RED}❌ 错误: 依赖项检查未通过！${RESET}`);
+        if (missingModules.length > 0) {
+            console.error(`   ${RED}缺少以下 Node.js 模块: ${missingModules.join(', ')}${RESET}`);
+            console.log('   请根据您使用的包管理器运行以下命令安装依赖：');
+            console.log(`      ${MAGENTA}npm install ${missingModules.join(' ')}${RESET}`);
+            console.log('      或');
+            console.log(`      ${MAGENTA}yarn add ${missingModules.join(' ')}${RESET}`);
+            console.log('      或');
+            console.log(`      ${MAGENTA}pnpm install ${missingModules.join(' ')}${RESET}`);
+            console.log('   (如果已安装但仍提示未找到，请尝试删除 node_modules 目录和 package-lock.json/yarn.lock 文件后重新安装)');
+        }
+        if (!fs.existsSync(SERVER_SCRIPT_PATH)) {
+             console.error(`   ${RED}缺少必要的服务器脚本文件: ${SERVER_SCRIPT_FILENAME}${RESET}`);
+             console.error(`   请确保它和 auto_connect_aistudio.cjs 在同一个文件夹内。`);
+        }
+        console.log(`${RED}-------------------------------------------------${RESET}`);
+        return false;
+    }
+
+    console.log(`\n${GREEN}✅ 所有依赖检查通过。${RESET}`);
+    playwright = require('playwright'); // Load playwright only after checks
+    return true;
+}
+
+// --- 步骤 2: 检查并启动 Chrome ---
+async function launchChrome() {
+    console.log(`${CYAN}-------------------------------------------------${RESET}`);
+    console.log(`${CYAN}--- 步骤 2: 启动或连接 Chrome (调试端口 ${DEBUGGING_PORT}) ---${RESET}`);
+
+    // 首先检查端口是否被占用
+    if (isPortInUse(DEBUGGING_PORT)) {
+        console.log(`${YELLOW}⚠️ 警告: 端口 ${DEBUGGING_PORT} 已被占用。${RESET}`);
+        console.log('   这通常意味着已经有一个 Chrome 实例在监听此端口。');
+        const question = `选择操作: [Y/n]
+  ${GREEN}Y (默认): 尝试连接现有 Chrome 实例并启动 API 服务器。${RESET}
+  ${YELLOW}n:        自动强行结束占用端口 ${DEBUGGING_PORT} 的进程，然后启动新的 Chrome 实例。${RESET}
+请输入选项 [Y/n]: `;
+        const answer = await askQuestion(question);
+
+        if (answer.toLowerCase() === 'n') {
+            console.log(`\n好的，您选择了启动新实例。将尝试自动清理端口...`);
+            const pids = findPidsUsingPort(DEBUGGING_PORT);
+            if (pids.length > 0) {
+                const killSuccess = killProcesses(pids);
+                if (killSuccess) {
+                    console.log(`   ${GREEN}✅ 尝试结束进程完成。等待 1 秒检查端口...${RESET}`);
+                    await new Promise(resolve => setTimeout(resolve, 1000)); // 短暂等待
+                    if (isPortInUse(DEBUGGING_PORT)) {
+                        console.error(`${RED}❌ 错误: 尝试结束后，端口 ${DEBUGGING_PORT} 仍然被占用。${RESET}`);
+                        console.error('   可能原因：权限不足，或进程未能正常终止。请尝试手动结束进程。' );
+                         // 提供手动清理提示
+                         console.log(`${YELLOW}提示: 您可以使用以下命令查找进程 ID (PID):${RESET}`);
+                         if (process.platform === 'win32') {
+                             console.log(`  - 在 CMD 或 PowerShell 中: netstat -ano | findstr :${DEBUGGING_PORT}`);
+                             console.log('  - 找到 PID 后，使用: taskkill /F /PID <PID>');
+                         } else { // macOS or Linux
+                             console.log(`  - 在终端中: lsof -t -i:${DEBUGGING_PORT}`);
+                             console.log('  - 找到 PID 后，使用: kill -9 <PID>');
+                         }
+                         await askQuestion('请在手动结束进程后，按 Enter 键重试脚本...');
+                         process.exit(1); // 退出，让用户处理后重跑
+                    } else {
+                        console.log(`   ${GREEN}✅ 端口 ${DEBUGGING_PORT} 现在空闲。${RESET}`);
+                        // 端口已清理，继续执行下面的 Chrome 启动流程
+                    }
+                } else {
+                    console.error(`${RED}❌ 错误: 尝试结束部分或全部占用端口的进程失败。${RESET}`);
+                    console.error('   请检查日志中的具体错误信息，可能需要手动结束进程。');
+                    await askQuestion('请在手动结束进程后，按 Enter 键重试脚本...');
+                    process.exit(1); // 退出，让用户处理后重跑
+                }
+            } else {
+                console.log(`${YELLOW}   虽然端口被占用，但未能找到具体监听的进程 PID。可能情况复杂，建议手动检查。${RESET}` );
+                 await askQuestion('请手动检查并确保端口空闲后，按 Enter 键重试脚本...');
+                 process.exit(1); // 退出
+            }
+            // 如果代码执行到这里，意味着端口清理成功，将继续启动 Chrome
+            console.log(`\n准备启动新的 Chrome 实例...`);
+
+        } else {
+            console.log(`\n好的，将尝试连接到现有的 Chrome 实例...`);
+            return 'use_existing'; // 特殊返回值，告知主流程跳过启动，直接连接
+        }
+    }
+
+    // --- 如果端口未被占用，或者用户选择 'n' 且自动清理成功 ---
+
+    if (!chromeExecutablePath) {
+        console.error(`${RED}❌ 错误: 未能在当前操作系统 (${process.platform}) 的常见路径找到 Chrome 可执行文件。${RESET}`);
+        console.error('   请确保已安装 Google Chrome，或修改脚本中的 getChromePath 函数以指向正确的路径。');
+        if (process.platform === 'win32') {
+             console.error('   (已尝试查找 %ProgramFiles% 和 %ProgramFiles(x86)% 下的路径)');
+        } else if (process.platform === 'linux') {
+             console.error('   (已尝试查找 /usr/bin/google-chrome, /usr/bin/google-chrome-stable, /opt/google/chrome/chrome)');
+        }
+        return false;
+    }
+
+    console.log(`   ${GREEN}找到 Chrome 路径:${RESET} ${chromeExecutablePath}`);
+
+    // 只有在明确需要启动新实例时才提示关闭其他实例
+    // (如果上面选择了 'n' 并清理成功，这里 isPortInUse 应该返回 false)
+    if (!isPortInUse(DEBUGGING_PORT)) {
+         console.log(`${YELLOW}⚠️ 重要提示：为了确保新的调试端口生效，建议先手动完全退出所有*其他*可能干扰的 Google Chrome 实例。${RESET}`);
+         console.log('   (在 macOS 上通常是 Cmd+Q，Windows/Linux 上是关闭所有窗口)');
+         await askQuestion('请确认已处理好其他 Chrome 实例，然后按 Enter 键继续启动...');
+    } else {
+         // 理论上不应该到这里，因为端口已被清理或选择了 use_existing
+         console.warn(`   ${YELLOW}警告：端口 ${DEBUGGING_PORT} 意外地仍被占用。继续尝试启动，但这极有可能失败。${RESET}`);
+         await askQuestion('请按 Enter 键继续尝试启动...');
+    }
+
+
+    console.log(`正在尝试启动 Chrome...`);
+    console.log(`  路径: "${chromeExecutablePath}"`);
+    // --- 修改：添加启动参数 ---
+    const chromeArgs = [
+        `--remote-debugging-port=${DEBUGGING_PORT}`,
+        `--window-size=460,800` // 指定宽度为 460px，高度暂定为 800px (可以根据需要调整)
+        // 你可以在这里添加其他需要的 Chrome 启动参数
+    ];
+    console.log(`  参数: ${chromeArgs.join(' ')}`); // 打印所有参数
+
+    try {
+        const chromeProcess = spawn(
+            chromeExecutablePath,
+            chromeArgs, // 使用包含窗口大小的参数数组
+            { detached: true, stdio: 'ignore' } // Detach to allow script to exit independently if needed
+        );
+        chromeProcess.unref(); // Allow parent process to exit independently
+
+        console.log(`${GREEN}✅ Chrome 启动命令已发送 (指定窗口大小)。稍后将尝试连接...${RESET}`);
+        console.log(`${DIM}⏳ 等待 3 秒让 Chrome 进程启动...${RESET}`);
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        return true; // 表示启动流程已尝试
+
+    } catch (error) {
+        console.error(`${RED}❌ 启动 Chrome 时出错: ${error.message}${RESET}`);
+        console.error(`   请检查路径 "${chromeExecutablePath}" 是否正确，以及是否有权限执行。`);
+        return false;
+    }
+}
+
+// --- 步骤 3: 连接 Playwright 并管理页面 (带重试) ---
+async function connectAndManagePage() {
+    console.log(`${CYAN}-------------------------------------------------${RESET}`);
+    console.log(`${CYAN}--- 步骤 3: 连接 Playwright 到 ${CDP_ADDRESS} (最多尝试 ${CONNECTION_RETRIES} 次) ---${RESET}`);
+    let browser = null;
+    let context = null;
+
+    for (let i = 0; i < CONNECTION_RETRIES; i++) {
+        try {
+            console.log(`\n${DIM}尝试连接 Playwright (第 ${i + 1}/${CONNECTION_RETRIES} 次)...${RESET}`);
+            browser = await playwright.chromium.connectOverCDP(CDP_ADDRESS, { timeout: CONNECT_TIMEOUT_MS });
+            console.log(`${GREEN}✅ 成功连接到 Chrome！${RESET}`);
+
+             // Simplified context fetching
+             await new Promise(resolve => setTimeout(resolve, 500)); // Short delay after connect
+             const contexts = browser.contexts();
+             if (contexts && contexts.length > 0) {
+                 context = contexts[0];
+                 console.log(`-> 获取到浏览器默认上下文。`);
+                 break; // Connection and context successful
+             } else {
+                 // This case should be rare if connectOverCDP succeeded with a responsive Chrome
+                 throw new Error('连接成功，但无法获取浏览器上下文。Chrome 可能没有响应或未完全初始化。');
+             }
+
+        } catch (error) {
+            console.warn(`   ${YELLOW}连接尝试 ${i + 1} 失败: ${error.message.split('\n')[0]}${RESET}`);
+             if (browser && browser.isConnected()) {
+                 // Should not happen if connectOverCDP failed, but good practice
+                 await browser.close().catch(e => console.error("尝试关闭连接失败的浏览器时出错:", e));
+             }
+             browser = null;
+             context = null;
+
+            if (i < CONNECTION_RETRIES - 1) {
+                console.log(`   ${YELLOW}可能原因: Chrome 未完全启动 / 端口 ${DEBUGGING_PORT} 未监听 / 端口被占用。${RESET}`);
+                console.log(`${DIM}   等待 ${RETRY_DELAY_MS / 1000} 秒后重试...${RESET}`);
+                await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
+            } else {
+                console.error(`\n${RED}❌ 在 ${CONNECTION_RETRIES} 次尝试后仍然无法连接。${RESET}`);
+                console.error('   请再次检查：');
+                console.error('   1. Chrome 是否真的已经通过脚本成功启动，并且窗口可见、已加载？(可能需要登录Google)');
+                console.error(`   2. 是否有其他程序占用了端口 ${DEBUGGING_PORT}？(检查命令: macOS/Linux: lsof -i :${DEBUGGING_PORT} | Windows: netstat -ano | findstr ${DEBUGGING_PORT})`);
+                console.error('   3. 启动 Chrome 时终端或系统是否有报错信息？');
+                console.error('   4. 防火墙或安全软件是否阻止了本地回环地址(127.0.0.1)的连接？');
+                return false;
+            }
+        }
+    }
+
+    if (!browser || !context) {
+         console.error(`${RED}-> 未能成功连接到浏览器或获取上下文。${RESET}`);
+         return false;
+    }
+
+    // --- 连接成功后的页面管理逻辑 ---
+    console.log(`\n${CYAN}--- 页面管理 ---${RESET}`);
+    try {
+        let targetPage = null;
+        let pages = [];
+        try {
+            pages = context.pages();
+        } catch (err) {
+             console.error(`${RED}❌ 获取现有页面列表时出错:${RESET}`, err);
+             console.log("   将尝试打开新页面...");
+        }
+
+        console.log(`${DIM}-> 检查 ${pages.length} 个已存在的页面...${RESET}`);
+        const aiStudioUrlPattern = 'aistudio.google.com/';
+        const loginUrlPattern = 'accounts.google.com/';
+
+        for (const page of pages) {
+            try {
+                if (!page.isClosed()) {
+                    const pageUrl = page.url();
+                    console.log(`${DIM}   检查页面: ${pageUrl}${RESET}`);
+                    // Prioritize AI Studio pages, then login pages
+                    if (pageUrl.includes(aiStudioUrlPattern)) {
+                         console.log(`-> ${GREEN}找到 AI Studio 页面:${RESET} ${pageUrl}`);
+                         targetPage = page;
+                         // Ensure it's the target URL if possible
+                         if (!pageUrl.includes('/prompts/new_chat')) {
+                              console.log(`${YELLOW}   非目标页面，尝试导航到 ${TARGET_URL}...${RESET}`);
+                              try {
+                                   await targetPage.goto(TARGET_URL, { waitUntil: 'domcontentloaded', timeout: NAVIGATION_TIMEOUT_MS });
+                                   console.log(`   ${GREEN}导航成功:${RESET} ${targetPage.url()}`);
+                              } catch (navError) {
+                                   console.warn(`   ${YELLOW}警告：导航到 ${TARGET_URL} 失败: ${navError.message.split('\n')[0]}${RESET}`);
+                                   console.warn(`   ${YELLOW}将使用当前页面 (${pageUrl})，请稍后手动确认。${RESET}`);
+                              }
+                         } else {
+                              console.log(`   ${GREEN}页面已在目标路径或子路径。${RESET}`);
+                         }
+                         break; // Found a good AI Studio page
+                    } else if (pageUrl.includes(loginUrlPattern) && !targetPage) {
+                        // Keep track of a login page if no AI studio page is found yet
+                        console.log(`-> ${YELLOW}发现 Google 登录页面，暂存。${RESET}`);
+                        targetPage = page;
+                        // Don't break here, keep looking for a direct AI Studio page
+                    }
+                 }
+             } catch (pageError) {
+                  if (!page.isClosed()) {
+                      console.warn(`   ${YELLOW}警告：评估或导航页面时出错: ${pageError.message.split('\n')[0]}${RESET}`);
+                  }
+                  // Avoid using a page that caused an error
+                  if (targetPage === page) {
+                      targetPage = null;
+                  }
+             }
+        }
+
+        // If after checking all pages, the best we found was a login page
+        if (targetPage && targetPage.url().includes(loginUrlPattern)) {
+            console.log(`-> ${YELLOW}未找到直接的 AI Studio 页面，将使用之前找到的登录页面。${RESET}`);
+            console.log(`   ${YELLOW}请确保在该页面手动完成登录。${RESET}`);
+        }
+
+        // If no suitable page was found at all
+        if (!targetPage) {
+            console.log(`-> ${YELLOW}未找到合适的现有页面。正在打开新页面并导航到 ${TARGET_URL}...${RESET}`);
+            try {
+                targetPage = await context.newPage();
+                console.log(`${DIM}   正在导航...${RESET}`);
+                await targetPage.goto(TARGET_URL, { waitUntil: 'domcontentloaded', timeout: NAVIGATION_TIMEOUT_MS });
+                console.log(`-> ${GREEN}新页面已打开并导航到:${RESET} ${targetPage.url()}`);
+            } catch (newPageError) {
+                 console.error(`${RED}❌ 打开或导航新页面到 ${TARGET_URL} 失败: ${newPageError.message}${RESET}`);
+                 console.error("   请检查网络连接，以及 Chrome 是否能正常访问该网址。可能需要手动登录。" );
+                 await browser.close().catch(e => {});
+                 return false;
+            }
+        }
+
+        try {
+            await targetPage.bringToFront();
+            console.log('-> 已尝试将目标页面置于前台。');
+        } catch (bringToFrontError) {
+            console.warn(`   ${YELLOW}警告：将页面置于前台失败: ${bringToFrontError.message.split('\n')[0]}${RESET}`);
+            console.warn(`   (这可能发生在窗口最小化或位于不同虚拟桌面上时，通常不影响连接)`);
+        }
+        await new Promise(resolve => setTimeout(resolve, 500)); // Small delay after bringToFront
+
+
+        console.log(`\n${BRIGHT}${GREEN}🎉 --- AI Studio 连接准备完成 --- 🎉${RESET}`);
+        console.log(`${GREEN}Chrome 已启动，Playwright 已连接，相关页面已找到或创建。${RESET}`);
+        console.log(`${YELLOW}请确保在 Chrome 窗口中 AI Studio 页面处于可交互状态 (例如，已登录Google, 无弹窗)。${RESET}`);
+
+        return true;
+
+    } catch (error) {
+        console.error(`\n${RED}❌ --- 步骤 3 页面管理失败 ---${RESET}`);
+        console.error('   在连接成功后，处理页面时发生错误:', error);
+        if (browser && browser.isConnected()) {
+             await browser.close().catch(e => console.error("关闭浏览器时出错:", e));
+        }
+        return false;
+    } finally {
+         // 这里不再打印即将退出的日志，因为脚本会继续运行 server.js
+         // console.log("-> auto_connect_aistudio.js 步骤3结束。");
+         // 不需要手动断开 browser 连接，因为是 connectOverCDP
+    }
+}
+
+
+// --- 步骤 4: 启动 API 服务器 ---
+function startApiServer() {
+    console.log(`${CYAN}-------------------------------------------------${RESET}`);
+    console.log(`${CYAN}--- 步骤 4: 启动 API 服务器 ('node ${SERVER_SCRIPT_FILENAME}') ---${RESET}`);
+    console.log(`${DIM}   脚本路径: ${SERVER_SCRIPT_PATH}${RESET}`);
+
+    if (!fs.existsSync(SERVER_SCRIPT_PATH)) {
+        console.error(`${RED}❌ 错误: 无法启动服务器，文件不存在: ${SERVER_SCRIPT_PATH}${RESET}`);
+        process.exit(1);
+    }
+
+    console.log(`${DIM}正在启动: node ${SERVER_SCRIPT_PATH}${RESET}`);
+
+    try {
+        const serverProcess = spawn('node', [SERVER_SCRIPT_PATH], {
+            stdio: 'inherit',
+            cwd: __dirname
+        });
+
+        serverProcess.on('error', (err) => {
+            console.error(`${RED}❌ 启动 '${SERVER_SCRIPT_FILENAME}' 失败: ${err.message}${RESET}`);
+            console.error(`请检查 Node.js 是否已安装并配置在系统 PATH 中，以及 '${SERVER_SCRIPT_FILENAME}' 文件是否有效。`);
+            process.exit(1);
+        });
+
+        serverProcess.on('exit', (code, signal) => {
+            console.log(`\n${MAGENTA}👋 '${SERVER_SCRIPT_FILENAME}' 进程已退出 (代码: ${code}, 信号: ${signal})。${RESET}`);
+            console.log("自动连接脚本执行结束。");
+            process.exit(code ?? 0);
+        });
+        // Don't print the success message here, let server.cjs print its own ready message
+        // console.log("✅ '${SERVER_SCRIPT_FILENAME}' 已启动。脚本将保持运行，直到服务器进程结束或被手动中断。");
+
+    } catch (error) {
+        console.error(`${RED}❌ 启动 '${SERVER_SCRIPT_FILENAME}' 时发生意外错误: ${error.message}${RESET}`);
+        process.exit(1);
+    }
+}
+
+
+// --- 主执行流程 ---
+(async () => {
+    console.log(`${MAGENTA}🚀 欢迎使用 AI Studio 自动连接与启动脚本 (跨平台优化, v2.9 自动端口清理) 🚀${RESET}`);
+    console.log(`${MAGENTA}=================================================${RESET}`);
+
+    if (!await checkDependencies()) {
+        process.exit(1);
+    }
+
+    console.log(`${MAGENTA}=================================================${RESET}`);
+
+    const launchResult = await launchChrome();
+
+    if (launchResult === false) {
+        console.log(`${RED}❌ 启动 Chrome 失败，脚本终止。${RESET}`);
+        process.exit(1);
+    }
+
+    // 如果 launchResult 是 'use_existing' 或 true, 都需要连接
+    console.log(`${MAGENTA}=================================================${RESET}`);
+    if (!await connectAndManagePage()) {
+         // 如果连接失败，并且我们是尝试连接到现有实例，给出更具体的提示
+         if (launchResult === 'use_existing') {
+             console.error(`${RED}❌ 连接到现有 Chrome 实例 (端口 ${DEBUGGING_PORT}) 失败。${RESET}`);
+             console.error('   请确认：');
+             console.error('   1. 占用该端口的确实是您想连接的 Chrome 实例。');
+             console.error('   2. 该 Chrome 实例是以 --remote-debugging-port 参数启动的。');
+             console.error('   3. Chrome 实例本身运行正常，没有崩溃或无响应。');
+         }
+         process.exit(1);
+    }
+
+    // 无论 Chrome 是新启动的还是已存在的，只要连接成功，就启动 API 服务器
+    console.log(`${MAGENTA}=================================================${RESET}`);
+    startApiServer();
+
+})(); 

AIStudioProxyAPI/deprecated_javascript_version/package.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.19.2",
+    "playwright": "^1.44.1",
+    "@playwright/test": "^1.44.1"
+  }
+}

AIStudioProxyAPI/deprecated_javascript_version/server.cjs

@@ -0,0 +1,1505 @@
+// server.cjs (优化版 v2.17 - 增加日志ID & 常量)
+
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const cors = require('cors');
+
+// --- 依赖检查 ---
+let playwright, expect;
+const requiredModules = ['express', 'playwright', '@playwright/test', 'cors'];
+const missingModules = [];
+
+for (const modName of requiredModules) {
+    try {
+        if (modName === 'playwright') {
+            playwright = require(modName);
+        } else if (modName === '@playwright/test') {
+            expect = require(modName).expect;
+        } else {
+            require(modName);
+        }
+        // console.log(`✅ 模块 ${modName} 已加载。`); // Optional: Log success
+    } catch (e) {
+        console.error(`❌ 模块 ${modName} 未找到。`);
+        missingModules.push(modName);
+    }
+}
+
+if (missingModules.length > 0) {
+    console.error("-------------------------------------------------------------");
+    console.error("❌ 错误：缺少必要的依赖模块！");
+    console.error("请根据您使用的包管理器运行以下命令安装依赖：");
+    console.error("-------------------------------------------------------------");
+    console.error(`   npm install ${missingModules.join(' ')}`);
+    console.error("   或");
+    console.error(`   yarn add ${missingModules.join(' ')}`);
+    console.error("   或");
+    console.error(`   pnpm install ${missingModules.join(' ')}`);
+    console.error("-------------------------------------------------------------");
+    process.exit(1);
+}
+
+// --- 配置 ---
+const SERVER_PORT = process.env.PORT || 2048;
+const CHROME_DEBUGGING_PORT = 8848;
+const CDP_ADDRESS = `http://127.0.0.1:${CHROME_DEBUGGING_PORT}`;
+const AI_STUDIO_URL_PATTERN = 'aistudio.google.com/';
+const RESPONSE_COMPLETION_TIMEOUT = 300000; // 5分钟总超时
+const POLLING_INTERVAL = 300; // 非流式/通用检查间隔
+const POLLING_INTERVAL_STREAM = 200; // 流式检查轮询间隔 (ms)
+// v2.12: Timeout for secondary checks *after* spinner disappears
+const POST_SPINNER_CHECK_DELAY_MS = 500; // Spinner消失后稍作等待再检查其他状态
+const FINAL_STATE_CHECK_TIMEOUT_MS = 1500; // 检查按钮和输入框最终状态的超时
+const SPINNER_CHECK_TIMEOUT_MS = 1000; // 检查Spinner状态的超时
+const POST_COMPLETION_BUFFER = 1000; // JSON模式下可以缩短检查后等待时间
+const SILENCE_TIMEOUT_MS = 1500; // 文本静默多久后认为稳定 (Spinner消失后)
+
+// --- 常量 ---
+const MODEL_NAME = 'google-ai-studio-via-playwright-cdp-json';
+const CHAT_COMPLETION_ID_PREFIX = 'chatcmpl-';
+
+// --- 选择器常量 ---
+const INPUT_SELECTOR = 'ms-prompt-input-wrapper textarea';
+const SUBMIT_BUTTON_SELECTOR = 'button[aria-label="Run"]';
+const RESPONSE_CONTAINER_SELECTOR = 'ms-chat-turn .chat-turn-container.model'; // 选择器指向 AI 模型回复的容器
+const RESPONSE_TEXT_SELECTOR = 'ms-cmark-node.cmark-node';
+const LOADING_SPINNER_SELECTOR = 'button[aria-label="Run"] svg .stoppable-spinner';
+const ERROR_TOAST_SELECTOR = 'div.toast.warning, div.toast.error';
+// !! 新增：清空聊天记录相关选择器 !!
+const CLEAR_CHAT_BUTTON_SELECTOR = 'button[aria-label="Clear chat"][data-test-clear="outside"]:has(span.material-symbols-outlined:has-text("refresh"))'; // 清空按钮 (带图标确认)
+const CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR = 'button.mdc-button:has-text("Continue")'; // 确认对话框中的 "Continue" 按钮
+// !! 新增：清空验证相关常量 !!
+const CLEAR_CHAT_VERIFY_TIMEOUT_MS = 5000; // 等待清空生效的总超时时间 (ms)
+const CLEAR_CHAT_VERIFY_INTERVAL_MS = 300; // 检查清空状态的轮询间隔 (ms)
+
+// v2.16: JSON Structure Prompt (Restored for non-streaming)
+const prepareAIStudioPrompt = (userPrompt, systemPrompt = null) => {
+    let fullPrompt = `
+IMPORTANT: Your entire response MUST be a single JSON object. Do not include any text outside of this JSON object.
+The JSON object must have a single key named "response".
+Inside the value of the "response" key (which is a string), you MUST put the exact marker "<<<START_RESPONSE>>>"" at the very beginning of your actual answer. There should be NO text before this marker within the response string.
+`;
+
+    if (systemPrompt && systemPrompt.trim() !== '') {
+        fullPrompt += `\nSystem Instruction: ${systemPrompt}\n`;
+    }
+
+    fullPrompt += `
+Example 1:
+User asks: "What is the capital of France?"
+Your response MUST be:
+{
+  "response": "<<<START_RESPONSE>>>The capital of France is Paris."
+}
+
+Example 2:
+User asks: "Write a python function to add two numbers"
+Your response MUST be:
+{
+  "response": "<<<START_RESPONSE>>>\\\`\\\`\\\`python\\\\ndef add(a, b):\\\\n  return a + b\\\\n\\\`\\\`\\\`"
+}
+
+Now, answer the following user prompt, ensuring your output strictly adheres to the JSON format AND the start marker requirement described above:
+
+User Prompt: "${userPrompt}"
+
+Your JSON Response:
+`;
+    return fullPrompt;
+};
+
+// v2.26: Use JSON prompt for streaming as well -> vNEXT: Use Markdown Code Block for streaming
+// vNEXT: Instruct AI to output *incomplete* JSON for streaming -> vNEXT: Instruct AI to output Markdown Code Block
+const prepareAIStudioPromptStream = (userPrompt, systemPrompt = null) => {
+    let fullPrompt = `
+IMPORTANT: For this streaming request, your entire response MUST be enclosed in a single markdown code block (like \`\`\` block \`\`\`).
+Inside this code block, your actual answer text MUST start immediately after the exact marker "<<<START_RESPONSE>>>".
+Start your response exactly with "\`\`\`\n<<<START_RESPONSE>>>" followed by your answer content.
+Continue outputting your answer content. You SHOULD include the final closing "\`\`\`" at the very end of your full response stream.
+`;
+
+    if (systemPrompt && systemPrompt.trim() !== '') {
+        fullPrompt += `\nSystem Instruction: ${systemPrompt}\n`;
+    }
+
+    fullPrompt += `
+Example 1 (Streaming):
+User asks: "What is the capital of France?"
+Your streamed response MUST look like this over time:
+Stream part 1: \`\`\`\n<<<START_RESPONSE>>>The capital
+Stream part 2:  of France is
+Stream part 3:  Paris.\n\`\`\`
+
+Example 2 (Streaming):
+User asks: "Write a python function to add two numbers"
+Your streamed response MUST look like this over time:
+Stream part 1: \`\`\`\n<<<START_RESPONSE>>>\`\`\`python\ndef add(a, b):
+Stream part 2: \n  return a + b\n
+Stream part 3: \`\`\`\n\`\`\`
+
+Now, answer the following user prompt, ensuring your output strictly adheres to the markdown code block, start marker, and streaming requirements described above:
+
+User Prompt: "${userPrompt}"
+
+Your Response (Streaming, within a markdown code block):
+`;
+    return fullPrompt;
+};
+
+const app = express();
+
+// --- 全局变量 ---
+let browser = null;
+let page = null;
+let isPlaywrightReady = false;
+let isInitializing = false;
+// v2.18: 请求队列和处理状态
+let requestQueue = [];
+let isProcessing = false;
+
+
+// --- Playwright 初始化函数 ---
+async function initializePlaywright() {
+    if (isPlaywrightReady || isInitializing) return;
+    isInitializing = true;
+    console.log(`--- 初始化 Playwright: 连接到 ${CDP_ADDRESS} ---`);
+
+    try {
+        browser = await playwright.chromium.connectOverCDP(CDP_ADDRESS, { timeout: 20000, ignoreHTTPSErrors: true });
+        console.log('✅ 成功连接到正在运行的 Chrome 实例！');
+
+        browser.once('disconnected', () => {
+            console.error('❌ Playwright 与 Chrome 的连接已断开！');
+            isPlaywrightReady = false;
+            browser = null;
+            page = null;
+            // v2.18: Clear queue on disconnect? Maybe not, let requests fail naturally.
+        });
+
+        await new Promise(resolve => setTimeout(resolve, 500));
+
+        const contexts = browser.contexts();
+        let context;
+        if (!contexts || contexts.length === 0) {
+             await new Promise(resolve => setTimeout(resolve, 1500));
+             const retryContexts = browser.contexts();
+             if (!retryContexts || retryContexts.length === 0) {
+                 throw new Error('无法获取浏览器上下文。请检查 Chrome 是否已正确启动并响应。');
+             }
+             context = retryContexts[0];
+        } else {
+             context = contexts[0];
+        }
+
+        let foundPage = null;
+        const pages = context.pages();
+        console.log(`-> 发现 ${pages.length} 个页面。正在搜索 AI Studio (匹配 "${AI_STUDIO_URL_PATTERN}")...`);
+        for (const p of pages) {
+            try {
+                 if (p.isClosed()) continue;
+                const url = p.url();
+                if (url.includes(AI_STUDIO_URL_PATTERN) && url.includes('/prompts/')) {
+                    console.log(`-> 找到 AI Studio 页面: ${url}`);
+                    foundPage = p;
+                    break;
+                }
+            } catch (pageError) {
+                 if (!p.isClosed()) {
+                     console.warn(`   警告：评估页面 URL 时出错: ${pageError.message.split('\\n')[0]}`);
+                 }
+            }
+        }
+
+        if (!foundPage) {
+            throw new Error(`未在已连接的 Chrome 中找到包含 "${AI_STUDIO_URL_PATTERN}" 和 "/prompts/" 的页面。请确保 auto_connect_aistudio.js 已成功运行，并且 AI Studio 页面 (例如 prompts/new_chat) 已打开。`);
+        }
+
+        page = foundPage;
+        console.log('-> 已定位到 AI Studio 页面。');
+        await page.bringToFront();
+        console.log('-> 尝试将页面置于前台。检查加载状态...');
+        await page.waitForLoadState('domcontentloaded', { timeout: 15000 });
+        console.log('-> 页面 DOM 已加载。');
+
+        try {
+            console.log("-> 尝试定位核心输入区域以确��页面就绪...");
+            await page.locator('ms-prompt-input-wrapper').waitFor({ state: 'visible', timeout: 15000 });
+             console.log("-> 核心输入区域容器已找到。");
+        } catch(initCheckError) {
+            console.warn(`⚠️ 初始化检查警告：未能快速定位到核心输入区域容器。页面可能仍在加载或结构有变: ${initCheckError.message.split('\\n')[0]}`);
+            await saveErrorSnapshot('init_check_fail');
+        }
+
+        isPlaywrightReady = true;
+        console.log('✅ Playwright 已准备就绪。');
+        // v2.18: Start processing queue if playwright just became ready and queue has items
+        if (requestQueue.length > 0 && !isProcessing) {
+             console.log(`[Queue] Playwright 就绪，队列中有 ${requestQueue.length} 个请求，开始处理...`);
+             processQueue();
+        }
+
+    } catch (error) {
+        console.error(`❌ 初始化 Playwright 失败: ${error.message}`);
+        await saveErrorSnapshot('init_fail');
+        isPlaywrightReady = false;
+        browser = null;
+        page = null;
+    } finally {
+        isInitializing = false;
+    }
+}
+
+// --- 中间件 ---
+app.use(cors());
+app.use(express.json({ limit: '20mb' }));
+app.use(express.urlencoded({ limit: '20mb', extended: true })); // Also for urlencoded
+
+// --- Web UI Route ---
+app.get('/', (req, res) => {
+    const htmlPath = path.join(__dirname, 'index.html');
+    if (fs.existsSync(htmlPath)) {
+        res.sendFile(htmlPath);
+    } else {
+        res.status(404).send('Error: index.html not found.');
+    }
+});
+
+// --- 健康检查 ---
+app.get('/health', (req, res) => {
+    const isConnected = browser?.isConnected() ?? false;
+    const isPageValid = page && !page.isClosed();
+    const queueLength = requestQueue.length;
+    const status = {
+        status: 'Unknown',
+        message: '',
+        playwrightReady: isPlaywrightReady,
+        browserConnected: isConnected,
+        pageValid: isPageValid,
+        initializing: isInitializing,
+        processing: isProcessing,
+        queueLength: queueLength
+    };
+
+    if (isPlaywrightReady && isPageValid && isConnected) {
+        status.status = 'OK';
+        status.message = `Server running, Playwright connected, page valid. Currently ${isProcessing ? 'processing' : 'idle'} with ${queueLength} item(s) in queue.`;
+        res.status(200).json(status);
+    } else {
+        status.status = 'Error';
+        const reasons = [];
+        if (!isPlaywrightReady) reasons.push("Playwright not initialized or ready");
+        if (!isPageValid) reasons.push("Target page not found or closed");
+        if (!isConnected) reasons.push("Browser disconnected");
+        if (isInitializing) reasons.push("Playwright is currently initializing");
+        status.message = `Service Unavailable. Issues: ${reasons.join(', ')}. Currently ${isProcessing ? 'processing' : 'idle'} with ${queueLength} item(s) in queue.`;
+        res.status(503).json(status);
+    }
+});
+
+// --- 新增：API 辅助函数 ---
+
+// 验证聊天请求
+// v2.19: Updated validation to handle array content (text parts only)
+function validateChatRequest(messages) {
+    const reqId = messages?.[0]?.reqId || 'validation'; // Get reqId if passed, fallback
+    if (!messages || !Array.isArray(messages) || messages.length === 0) {
+        throw new Error(`[${reqId}] Invalid request: "messages" array is missing or empty.`);
+    }
+    const lastUserMessage = messages.filter(msg => msg.role === 'user').pop();
+    if (!lastUserMessage) {
+        throw new Error(`[${reqId}] Invalid request: No user message found in the "messages" array.`);
+    }
+
+    let userPromptContentInput = lastUserMessage.content;
+    let processedUserPrompt = ""; // Initialize as empty string
+
+    // 1. Handle null/undefined content
+    if (userPromptContentInput === null || userPromptContentInput === undefined) {
+        console.warn(`[${reqId}] (Validation) Warning: Last user message content is null or undefined. Treating as empty string.`);
+        processedUserPrompt = "";
+    }
+    // 2. Handle string content (most common case)
+    else if (typeof userPromptContentInput === 'string') {
+        processedUserPrompt = userPromptContentInput;
+    }
+    // 3. Handle array content (attempt compatibility with OpenAI vision format)
+    else if (Array.isArray(userPromptContentInput)) {
+        console.log(`[${reqId}] (Validation) Info: Last user message content is an array. Processing text parts...`);
+        let textParts = [];
+        let unsupportedParts = false;
+        for (const item of userPromptContentInput) {
+            if (typeof item === 'object' && item !== null && item.type === 'text' && typeof item.text === 'string') {
+                textParts.push(item.text);
+            } else if (typeof item === 'object' && item !== null && item.type === 'image_url') {
+                console.warn(`[${reqId}] (Validation) Warning: Found 'image_url' content part. This proxy cannot process images via AI Studio web UI. Ignoring image.`);
+                unsupportedParts = true;
+                // Optionally, include the URL as text, but it might confuse the AI:
+                // textParts.push(`[Image URL (Unsupported): ${item.image_url?.url || 'N/A'}]`);
+            } else {
+                // Handle other unexpected items in the array - stringify them?
+                 console.warn(`[${reqId}] (Validation) Warning: Found unexpected item in content array (Type: ${typeof item}). Converting to JSON string.`);
+                 try {
+                      textParts.push(JSON.stringify(item));
+                      unsupportedParts = true;
+                 } catch (e) {
+                      console.error(`[${reqId}] (Validation) Error stringifying array item: ${e}. Skipping item.`);
+                 }
+            }
+        }
+        processedUserPrompt = textParts.join('\\n'); // Join text parts with newline
+        if (unsupportedParts) {
+             console.warn(`[${reqId}] (Validation) Warning: Some parts of the array content were unsupported or ignored (e.g., images). Only text parts were included in the final prompt.`);
+        }
+        if (!processedUserPrompt) {
+             console.warn(`[${reqId}] (Validation) Warning: Processed array content resulted in an empty prompt.`);
+        }
+    }
+    // 4. Handle other object types (fallback to JSON stringify)
+    else if (typeof userPromptContentInput === 'object' && userPromptContentInput !== null) {
+        console.warn(`[${reqId}] (Validation) Warning: Last user message content is an object but not a recognized array format. Converting to JSON string.`);
+        try {
+            processedUserPrompt = JSON.stringify(userPromptContentInput);
+        } catch (stringifyError) {
+            console.error(`[${reqId}] (Validation) Error stringifying object user content: ${stringifyError}. Falling back to empty string.`);
+            processedUserPrompt = "";
+        }
+    }
+    // 5. Handle other primitive types (e.g., number, boolean) - convert to string
+    else {
+        console.warn(`[${reqId}] (Validation) Warning: Last user message content is an unexpected primitive type (${typeof userPromptContentInput}). Converting to string.`);
+        processedUserPrompt = String(userPromptContentInput);
+    }
+
+    // Final check - should always be a string here
+    if (typeof processedUserPrompt !== 'string') {
+         console.error(`[${reqId}] (Validation) CRITICAL ERROR: Failed to process user prompt content into a string. Type after processing: ${typeof processedUserPrompt}. Using empty string.`);
+         processedUserPrompt = ""; // Safeguard
+    }
+
+
+    // Extract system prompt (remains the same logic)
+    const systemPromptContent = messages.find(msg => msg.role === 'system')?.content;
+    // Basic validation for system prompt (ensure it's a string if provided)
+    let processedSystemPrompt = null;
+    if (systemPromptContent !== null && systemPromptContent !== undefined) {
+        if (typeof systemPromptContent === 'string') {
+            processedSystemPrompt = systemPromptContent;
+        } else {
+            console.warn(`[${reqId}] (Validation) Warning: System prompt content is not a string (Type: ${typeof systemPromptContent}). Ignoring system prompt.`);
+            // Optionally stringify it: processedSystemPrompt = JSON.stringify(systemPromptContent);
+        }
+    }
+
+
+    return {
+        userPrompt: processedUserPrompt, // Ensure this is always a string
+        systemPrompt: processedSystemPrompt // Ensure this is null or a string
+    };
+}
+
+// 与页面交互并提交 Prompt
+async function interactAndSubmitPrompt(page, prompt, reqId) {
+    console.log(`[${reqId}] 开始页面交互...`);
+    const inputField = page.locator(INPUT_SELECTOR);
+    const submitButton = page.locator(SUBMIT_BUTTON_SELECTOR);
+    const loadingSpinner = page.locator(LOADING_SPINNER_SELECTOR); // Keep spinner locator here for later use
+
+    console.log(`[${reqId}]  - 等待输入框可用...`);
+        try {
+            await inputField.waitFor({ state: 'visible', timeout: 10000 });
+        } catch (e) {
+         console.error(`[${reqId}] ❌ 查找输入框失败！`);
+         await saveErrorSnapshot(`input_field_not_visible_${reqId}`);
+         throw new Error(`[${reqId}] Failed to find visible input field. Error: ${e.message}`);
+    }
+
+    console.log(`[${reqId}]  - 清空并填充输入框...`);
+        await inputField.fill(prompt, { timeout: 60000 });
+
+    console.log(`[${reqId}]  - 等待运行按钮可用...`);
+        try {
+            await expect(submitButton).toBeEnabled({ timeout: 10000 });
+        } catch (e) {
+        console.error(`[${reqId}] ❌ 等待运行按钮变为可用状态超时！`);
+        await saveErrorSnapshot(`submit_button_not_enabled_before_click_${reqId}`);
+        throw new Error(`[${reqId}] Submit button not enabled before click. Error: ${e.message}`);
+    }
+
+    console.log(`[${reqId}]  - 点击运行按钮...`);
+    await submitButton.click({ timeout: 10000 });
+
+    return { inputField, submitButton, loadingSpinner }; // Return locators
+}
+
+// 定位最新的回复元素
+async function locateResponseElements(page, { inputField, submitButton, loadingSpinner }, reqId) {
+    console.log(`[${reqId}] 定位 AI 回复元素...`);
+        let lastResponseContainer;
+    let responseElement;
+        let locatedResponseElements = false;
+
+        for (let i = 0; i < 3 && !locatedResponseElements; i++) {
+             try {
+             console.log(`[${reqId}]    尝试定位最新回复容器及文本元素 (第 ${i + 1} 次)`);
+                 await page.waitForTimeout(500 + i * 500); // 固有延迟
+
+             const isEndState = await checkEndConditionQuickly(page, loadingSpinner, inputField, submitButton, 250, reqId);
+             const locateTimeout = isEndState ? 3000 : 60000;
+                 if (isEndState) {
+                console.log(`[${reqId}]     -> 检测到结束条件已满足，使用 ${locateTimeout / 1000}s 超时进行定位。`);
+                 }
+
+             lastResponseContainer = page.locator(RESPONSE_CONTAINER_SELECTOR).last();
+                 await lastResponseContainer.waitFor({ state: 'attached', timeout: locateTimeout });
+
+             responseElement = lastResponseContainer.locator(RESPONSE_TEXT_SELECTOR);
+                 await responseElement.waitFor({ state: 'attached', timeout: locateTimeout });
+
+             console.log(`[${reqId}]    回复容器和文本元素定位成功。`);
+                 locatedResponseElements = true;
+             } catch (locateError) {
+             console.warn(`[${reqId}]    第 ${i + 1} 次定位回复元素失败: ${locateError.message.split('\n')[0]}`);
+                 if (i === 2) {
+                  await saveErrorSnapshot(`response_locate_fail_${reqId}`);
+                  throw new Error(`[${reqId}] Failed to locate response elements after multiple attempts.`);
+             }
+         }
+    }
+    if (!locatedResponseElements) throw new Error(`[${reqId}] Could not locate response elements.`);
+    return { responseElement, lastResponseContainer }; // Return located elements
+}
+
+// --- 新增：处理流式响应 (vNEXT: 标记优先，静默结束，无JSON处理) ---
+async function handleStreamingResponse(res, responseElement, page, { inputField, submitButton, loadingSpinner }, operationTimer, reqId, isRequestCancelled) {
+    console.log(`[${reqId}]   - 流式传输开始 (vNEXT: Marker priority, silence end, no JSON handling)...`); // TODO: Update version
+    let lastRawText = "";
+    let lastSentResponseContent = ""; // Tracks content *after* the marker that has been SENT
+    let responseStarted = false; // Tracks if <<<START_RESPONSE>>> has been seen
+    const startTime = Date.now();
+    let spinnerHasDisappeared = false;
+    let lastTextChangeTimestamp = Date.now();
+    const startMarker = '<<<START_RESPONSE>>>';
+    let streamFinishedNaturally = false;
+
+    while (Date.now() - startTime < RESPONSE_COMPLETION_TIMEOUT && !streamFinishedNaturally) {
+        // --- 添加检查：请求是否已取消 ---
+        const cancelled = isRequestCancelled(); // 调用检查函数
+        // 添加日志记录检查结果
+        // console.log(`[${reqId}]   (Streaming Loop Check) isRequestCancelled() returned: ${cancelled}`); // 可选：过于频繁，暂时注释掉
+        if (cancelled) {
+             console.log(`[${reqId}]   (Streaming) 检测到请求已取消 (isRequestCancelled() is true)，停止处理。`); // 修改日志
+             clearTimeout(operationTimer); // 确保定时器清除
+             if (!res.writableEnded) res.end(); // 确保响应结束
+             return; // 退出函数
+        }
+        // --- 结束检查 ---
+
+        const loopStartTime = Date.now();
+
+        // 1. Get current raw text
+        const currentRawText = await getRawTextContent(responseElement, lastRawText, reqId);
+
+        if (currentRawText !== lastRawText) {
+            lastTextChangeTimestamp = Date.now();
+            let potentialNewDelta = "";
+            let currentContentAfterMarker = "";
+
+            // 2. Marker Check & Delta Calculation
+            const markerIndex = currentRawText.indexOf(startMarker);
+            if (markerIndex !== -1) {
+                if (!responseStarted) {
+                    console.log(`[${reqId}]    (流式 Simple) 检测到 ${startMarker}，开始传输...`);
+                    responseStarted = true;
+                }
+                // Content after marker in the current raw text
+                currentContentAfterMarker = currentRawText.substring(markerIndex + startMarker.length);
+                // Calculate new content since last *sent* content
+                potentialNewDelta = currentContentAfterMarker.substring(lastSentResponseContent.length);
+            } else if(responseStarted) {
+                 // If marker was seen before, but now disappears (e.g., AI cleared output?), treat as no new delta.
+                 potentialNewDelta = "";
+                 console.warn(`[${reqId}] Marker disappeared after being seen. Raw: ${currentRawText.substring(0,100)}`);
+            }
+
+            // 3. Send Delta if found
+            if (potentialNewDelta) {
+                 // console.log(`[${reqId}]    (Send Stream Simple) Sending Delta (len: ${potentialNewDelta.length})`);
+                 sendStreamChunk(res, potentialNewDelta, reqId);
+                 lastSentResponseContent += potentialNewDelta; // Update tracking
+            }
+
+            // Update last raw text
+            lastRawText = currentRawText;
+
+        } // End if(currentRawText !== lastRawText)
+
+        // 4. Check Spinner status
+        if (!spinnerHasDisappeared) {
+            try {
+                await expect(loadingSpinner).toBeHidden({ timeout: 50 });
+                spinnerHasDisappeared = true;
+                lastTextChangeTimestamp = Date.now(); // Reset silence timer when spinner disappears
+                console.log(`[${reqId}]    Spinner 已消失，进入静默期检测...`);
+            } catch (e) { /* Spinner still visible */ }
+        }
+
+        // 5. Silence Check (Standard)
+        const isSilent = spinnerHasDisappeared && (Date.now() - lastTextChangeTimestamp > SILENCE_TIMEOUT_MS);
+
+        if (isSilent) {
+            console.log(`[${reqId}] Silence detected. Finishing stream.`);
+            streamFinishedNaturally = true;
+            break; // Exit loop
+        }
+
+        // 6. Control polling interval
+        const loopEndTime = Date.now();
+        const loopDuration = loopEndTime - loopStartTime;
+        const waitTime = Math.max(0, POLLING_INTERVAL_STREAM - loopDuration);
+        await page.waitForTimeout(waitTime);
+
+    } // --- End main loop ---
+
+    // --- Cleanup and End --- (如果循环是因取消而退出，下面的代码不会执行)
+    clearTimeout(operationTimer); // Clear the specific timer for THIS request
+
+    if (!streamFinishedNaturally && Date.now() - startTime >= RESPONSE_COMPLETION_TIMEOUT) {
+        // Timeout case
+        console.warn(`[${reqId}]   - 流式传输(Simple模式)因总超时 (${RESPONSE_COMPLETION_TIMEOUT / 1000}s) 结束。`);
+        await saveErrorSnapshot(`streaming_simple_timeout_${reqId}`);
+        if (!res.writableEnded) {
+            sendStreamError(res, "Stream processing timed out on server (Simple mode).", reqId);
+        }
+    } else if (streamFinishedNaturally && !res.writableEnded) {
+        // Natural end (Silence detected)
+        // --- Final Sync (Simple Mode) ---
+        // Check one last time for any content received after the last delta was sent but before silence was declared.
+        console.log(`[${reqId}]    (Simple Stream) Loop ended naturally, performing final sync check...`);
+        const finalRawText = await getRawTextContent(responseElement, lastRawText, reqId);
+        console.log(`[${reqId}]    (Simple Stream) Performing final marker check and delta calculation...`);
+        try {
+             let finalExtractedContent = ""; // Content after marker
+             const finalMarkerIndex = finalRawText.indexOf(startMarker);
+             if (finalMarkerIndex !== -1) {
+                  finalExtractedContent = finalRawText.substring(finalMarkerIndex + startMarker.length);
+             }
+
+             const finalDelta = finalExtractedContent.substring(lastSentResponseContent.length);
+
+            if (finalDelta){
+                 console.log(`[${reqId}]    (Final Sync Simple) Sending final delta (len: ${finalDelta.length})`);
+                 sendStreamChunk(res, finalDelta, reqId);
+            } else {
+                 console.log(`[${reqId}]    (Final Sync Simple) No final delta to send based on lastSent comparison.`);
+            }
+        } catch (e) { console.warn(`[${reqId}] (Simple Stream) Final sync error during marker/delta calc: ${e.message}`); }
+        // --- End Final Sync ---
+
+        res.write('data: [DONE]\n\n');
+        res.end();
+        console.log(`[${reqId}] ✅ 流式(Simple模式)响应 [DONE] 已发送。`);
+    } else if (res.writableEnded) {
+        console.log(`[${reqId}] 流(Simple模式)已提前结束 (writableEnded=true)，不再发送 [DONE]。`);
+    } else {
+         console.log(`[${reqId}] 流(Simple模式)结束时状态异常 (finishedNaturally=${streamFinishedNaturally}, writableEnded=${res.writableEnded})，不再发送 [DONE]。`);
+    }
+}
+
+// --- 新增：处理非流式响应 --- vNEXT: Restore JSON Parsing
+async function handleNonStreamingResponse(res, page, locators, operationTimer, reqId, isRequestCancelled) {
+    console.log(`[${reqId}]   - 等待 AI 处理完成 (检查 Spinner 消失 + 输入框空 + 按钮禁用)...`);
+            let processComplete = false;
+            const nonStreamStartTime = Date.now();
+    let finalStateCheckInitiated = false;
+    const { inputField, submitButton, loadingSpinner } = locators;
+
+    // Completion check logic
+            while (!processComplete && Date.now() - nonStreamStartTime < RESPONSE_COMPLETION_TIMEOUT) {
+                // --- 添加检查：请求是否已取消 ---
+                if (isRequestCancelled()) {
+                    console.log(`[${reqId}]   (Non-Streaming) 检测到请求已取消，停止等待完成状态。`);
+                    clearTimeout(operationTimer); // 确保定时器清除
+                    if (!res.headersSent) {
+                         // 如果头还没发送，可以发送一个取消错误
+                         res.status(499).json({ error: { message: `[${reqId}] Client closed request`, type: 'client_error' } });
+                    } else if (!res.writableEnded) {
+                         res.end(); // 否则只结束响应
+                    }
+                    return; // 退出函数
+                }
+                // --- 结束检查 ---
+
+                  let isSpinnerHidden = false;
+                  let isInputEmpty = false;
+                  let isButtonDisabled = false;
+
+                  try {
+                      await expect(loadingSpinner).toBeHidden({ timeout: SPINNER_CHECK_TIMEOUT_MS });
+                      isSpinnerHidden = true;
+                  } catch { /* Spinner still visible */ }
+
+                  if (isSpinnerHidden) {
+                      try {
+                          await expect(inputField).toHaveValue('', { timeout: FINAL_STATE_CHECK_TIMEOUT_MS });
+                          isInputEmpty = true;
+                      } catch { /* Input not empty */ }
+
+                      if (isInputEmpty) {
+                          try {
+                              await expect(submitButton).toBeDisabled({ timeout: FINAL_STATE_CHECK_TIMEOUT_MS });
+                              isButtonDisabled = true;
+                          } catch { /* Button not disabled */ }
+                      }
+                  }
+
+                  if (isSpinnerHidden && isInputEmpty && isButtonDisabled) {
+                      if (!finalStateCheckInitiated) {
+                          finalStateCheckInitiated = true;
+                console.log(`[${reqId}]    检测到潜在最终状态。等待 ${POST_COMPLETION_BUFFER}ms 进行确认...`); // Use constant
+                await page.waitForTimeout(POST_COMPLETION_BUFFER); // Wait a bit first
+                console.log(`[${reqId}]    ${POST_COMPLETION_BUFFER}ms 等待结束，重新检查状态...`);
+                try {
+                    await expect(loadingSpinner).toBeHidden({ timeout: 500 });
+                    await expect(inputField).toHaveValue('', { timeout: 500 });
+                    await expect(submitButton).toBeDisabled({ timeout: 500 });
+                    console.log(`[${reqId}]    状态确认成功。开始文本静默检查...`);
+
+                    // --- NEW: Text Silence Check ---
+                    let lastCheckText = '';
+                    let currentCheckText = '';
+                    let textStable = false;
+                    const silenceCheckStartTime = Date.now();
+                    // Re-locate response element here for the check
+                    const { responseElement: checkResponseElement } = await locateResponseElements(page, locators, reqId);
+
+                    while (Date.now() - silenceCheckStartTime < SILENCE_TIMEOUT_MS * 2) { // Check for up to 2*silence duration
+                        lastCheckText = currentCheckText;
+                        currentCheckText = await getRawTextContent(checkResponseElement, lastCheckText, reqId);
+                        if (currentCheckText === lastCheckText) {
+                             // Text hasn't changed since last check in this loop
+                             if (Date.now() - silenceCheckStartTime >= SILENCE_TIMEOUT_MS) {
+                                  // And enough time has passed
+                                  console.log(`[${reqId}]    文本内容静默 ${SILENCE_TIMEOUT_MS}ms，确认处理完成。`);
+                                  textStable = true;
+                                  break;
+                             }
+                        } else {
+                            // Text changed, reset silence timer within this check
+                            // silenceCheckStartTime = Date.now(); // Option: Reset timer on any change
+                            console.log(`[${reqId}]    (静默检查) 文本仍在变化...`);
+                        }
+                        await page.waitForTimeout(POLLING_INTERVAL); // Use standard poll interval for checks
+                    }
+
+                    if (textStable) {
+                         processComplete = true; // Mark process as complete
+                    } else {
+                         console.warn(`[${reqId}]    警告: 文本静默检查超时，可能仍在输出。将继续尝试解析。`);
+                         processComplete = true; // Proceed anyway after timeout, but log warning
+                    }
+                    // --- END NEW: Text Silence Check ---
+
+                } catch (recheckError) {
+                    console.log(`[${reqId}]    状态在确认期间发生变化 (${recheckError.message.split('\\n')[0]})。继续轮询...`);
+                    finalStateCheckInitiated = false;
+                }
+            }
+        } else {
+             if (finalStateCheckInitiated) {
+                 console.log(`[${reqId}]    最终状态不再满足，重置确认标志。`);
+                 finalStateCheckInitiated = false;
+             }
+             await page.waitForTimeout(POLLING_INTERVAL * 2); // Longer wait if not in final state check
+        }
+    } // --- End Completion check logic loop ---
+
+    // --- 添加检查：如果在循环结束后发现请求已取消 ---
+    if (isRequestCancelled()) {
+        console.log(`[${reqId}]   (Non-Streaming) 请求在等待完成后被取消，不再继续处理。`);
+        // 定时器和响应应该已经被上面的检查处理了，这里只退出
+        return;
+    }
+    // --- 结束检查 ---
+
+    // Check for Page Errors BEFORE attempting to parse JSON
+    console.log(`[${reqId}]   - 检查页面上是否存在错误提示...`);
+    const pageError = await detectAndExtractPageError(page, reqId);
+              if (pageError) {
+        console.error(`[${reqId}] ❌ 检测到 AI Studio 页面错误: ${pageError}`);
+        await saveErrorSnapshot(`page_error_detected_${reqId}`);
+        throw new Error(`[${reqId}] AI Studio Error: ${pageError}`);
+              }
+
+              if (!processComplete) {
+         console.warn(`[${reqId}]    警告：等待最终完成状态超时或未能稳定确认 (${(Date.now() - nonStreamStartTime) / 1000}s)。将直接尝试获取并解析JSON。`);
+          await saveErrorSnapshot(`nonstream_final_state_timeout_${reqId}`);
+               } else {
+         console.log(`[${reqId}]   - 开始获取并解析最终 JSON...`);
+               }
+
+    // Get and Parse JSON
+             let aiResponseText = null;
+             const maxRetries = 3;
+             let attempts = 0;
+
+             while (attempts < maxRetries && aiResponseText === null) {
+                  attempts++;
+         console.log(`[${reqId}]     - 尝试获取原始文本并解析 JSON (第 ${attempts} 次)...`);
+         try {
+             // Re-locate response element within the retry loop for robustness
+             const { responseElement: currentResponseElement } = await locateResponseElements(page, locators, reqId);
+
+             const rawText = await getRawTextContent(currentResponseElement, '', reqId);
+
+                      if (!rawText || rawText.trim() === '') {
+                 console.warn(`[${reqId}]     - 第 ${attempts} 次获取的原始文本为空。`);
+                          throw new Error("Raw text content is empty.");
+                      }
+              console.log(`[${reqId}]     - 获取到原始文本 (长度: ${rawText.length}): \"${rawText.substring(0,100)}...\"`);
+
+             const parsedJson = tryParseJson(rawText, reqId);
+
+                      if (parsedJson) {
+                          if (typeof parsedJson.response === 'string') {
+                              aiResponseText = parsedJson.response;
+                              console.log(`[${reqId}]     - 成功解析 JSON 并提取 'response' 字段。`);
+                          } else {
+                              // JSON 有效但无 response 字段
+                              try {
+                                  aiResponseText = JSON.stringify(parsedJson);
+                                  console.log(`[${reqId}]     - 警告: 未找到 'response' 字段，但解析到有效 JSON。将整个 JSON 字符串化作为回复。`);
+                              } catch (stringifyError) {
+                                  console.error(`[${reqId}]     - 错误：无法将解析出的 JSON 字符串化: ${stringifyError.message}`);
+                                  aiResponseText = null;
+                                  throw new Error("Failed to stringify the parsed JSON object.");
+                              }
+                          }
+                      } else {
+                          // JSON 解析失败
+                          console.warn(`[${reqId}]     - 第 ${attempts} 次未能解析 JSON。`);
+                          aiResponseText = null;
+                          if (attempts >= maxRetries) {
+                              await saveErrorSnapshot(`json_parse_fail_final_attempt_${reqId}`);
+                          }
+                          throw new Error("Failed to parse JSON from raw text.");
+                      }
+
+                 break;
+
+                  } catch (e) {
+             console.warn(`[${reqId}]     - 第 ${attempts} 次获取或解析失败: ${e.message.split('\n')[0]}`);
+             aiResponseText = null;
+                      if (attempts >= maxRetries) {
+                 console.error(`[${reqId}]     - 多次尝试获取并解析 JSON 失败。`);
+                 if (!e.message?.includes('snapshot')) await saveErrorSnapshot(`get_parse_json_failed_final_${reqId}`);
+                          aiResponseText = ""; // Fallback to empty string
+                      } else {
+                  await new Promise(resolve => setTimeout(resolve, 1500 + attempts * 500));
+                      }
+                  }
+             }
+
+            if (aiResponseText === null) {
+         console.log(`[${reqId}]     - JSON 解析失败，再次检查页面错误...`);
+         const finalCheckError = await detectAndExtractPageError(page, reqId);
+                 if (finalCheckError) {
+              console.error(`[${reqId}] ❌ 检测到 AI Studio 页面错误 (在 JSON 解析失败后): ${finalCheckError}`);
+              await saveErrorSnapshot(`page_error_post_json_fail_${reqId}`);
+              throw new Error(`[${reqId}] AI Studio Error after JSON parse failed: ${finalCheckError}`);
+         }
+          console.warn(`[${reqId}] 警告：所有尝试均未能获取并解析出有效的 JSON 回复。返回空回复。`);
+                  aiResponseText = "";
+              }
+
+    // Handle potential nested JSON
+            let cleanedResponse = aiResponseText;
+            try {
+                 // Attempt to parse the potential stringified JSON again for nested 'response' check
+                 // Only attempt if aiResponseText is likely a stringified JSON object/array
+                 if (aiResponseText && aiResponseText.startsWith('{') || aiResponseText.startsWith('[')) {
+                      const outerParsed = JSON.parse(aiResponseText); // Use JSON.parse directly here
+                      const innerParsed = tryParseJson(outerParsed.response, reqId); // Try parsing the inner 'response' field if it exists
+                      if (innerParsed && typeof innerParsed.response === 'string') {
+                          console.log(`[${reqId}]    (非流式) 检测到嵌套 JSON，使用内层 response 内容。`);
+                          cleanedResponse = innerParsed.response;
+                      } else if (typeof outerParsed.response === 'string') {
+                          // If the *outer* 'response' was already a string (not nested JSON), use it directly
+                          console.log(`[${reqId}]    (非流式) 使用外层 'response' 字段内容。`);
+                          cleanedResponse = outerParsed.response;
+                      }
+                      // If neither inner nor outer 'response' fields are relevant strings, keep the stringified JSON as cleanedResponse
+                 }
+            } catch (e) {
+                 // If parsing aiResponseText fails, it means it wasn't a stringified JSON in the first place,
+                 // or it was malformed. Keep the original aiResponseText.
+                 // console.warn(`[${reqId}] (Info) Post-processing check: aiResponseText ('${aiResponseText.substring(0,50)}...') is not a parseable JSON or lacks 'response'. Keeping original value. Error: ${e.message}`);
+                 cleanedResponse = aiResponseText; // Keep original if parsing fails
+            }
+
+    console.log(`[${reqId}] ✅ 获取到解析后的 AI 回复 (来自JSON, 长度: ${cleanedResponse?.length ?? 0}): \"${cleanedResponse?.substring(0, 100)}...\"`);
+
+               // --- 新增步骤：在非流式响应中移除标记 ---
+               const startMarker = '<<<START_RESPONSE>>>';
+
+               let finalContentForUser = cleanedResponse; // 默认使用清理后的响应
+
+               // Check for and remove the starting marker if present
+               if (finalContentForUser?.startsWith(startMarker)) {
+                    finalContentForUser = finalContentForUser.substring(startMarker.length);
+                    console.log(`[${reqId}]    (非流式 JSON) 移除前缀 ${startMarker}，最终内容长度: ${finalContentForUser.length}`);
+               } else if (aiResponseText !== null && aiResponseText !== "") { // 仅在获取到非空文本但无标记时警告
+                    console.warn(`[${reqId}]    (非流式 JSON) 警告: 未在 response 字段中找到预期的 ${startMarker} 前缀。内容: \"${aiResponseText.substring(0,50)}...\"`);
+               }
+               // --- 结束新增步骤 ---
+
+
+               // 使用移除标记后的内容构建最终响应
+               const responsePayload = {
+                  id: `${CHAT_COMPLETION_ID_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 15)}`,
+                  object: 'chat.completion',
+                  created: Math.floor(Date.now() / 1000),
+                  model: MODEL_NAME,
+                  choices: [{
+                      index: 0,
+                      message: { role: 'assistant', content: finalContentForUser }, // Use cleaned content
+                      finish_reason: 'stop',
+                  }],
+                  usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+              };
+              console.log(`[${reqId}] ✅ 返回 JSON 响应 (来自解析后的JSON)。`);
+              clearTimeout(operationTimer); // Clear the specific timer for THIS request
+              res.json(responsePayload);
+          }
+
+// --- 新增：处理 /v1/models 请求以满足 Open WebUI 验证 ---
+app.get('/v1/models', (req, res) => {
+    const modelId = 'aistudio-proxy'; // 您计划在 Open WebUI 中使用的模型名称
+    // 使用简短的日志ID或时间戳
+    const logPrefix = `[${Date.now().toString(36).slice(-5)}]`;
+    console.log(`${logPrefix} --- 收到 /v1/models 请求，返回模拟模型列表 ---`);
+    res.json({
+        object: "list",
+        data: [
+            {
+                id: modelId, // 返回您要用的那个名字
+                object: "model",
+                created: Math.floor(Date.now() / 1000),
+                owned_by: "openai-proxy", // 可以随便写
+                permission: [],
+                root: modelId,
+                parent: null
+            }
+            // 如果需要添加更多名称指向同一个代理，可以在此添加
+            // ,{
+            //    id: "gemini-pro-proxy",
+            //    object: "model",
+            //    created: Math.floor(Date.now() / 1000),
+            //    owned_by: "openai-proxy",
+            //    permission: [],
+            //    root: "gemini-pro-proxy",
+            //    parent: null
+            // }
+        ]
+    });
+});
+
+
+// --- v2.18: 新增队列处理函数 ---
+async function processQueue() {
+     if (isProcessing || requestQueue.length === 0) {
+          return;
+     }
+
+     isProcessing = true;
+     // 从队列头部取出包含状态的请求项
+     const queueItem = requestQueue.shift();
+     // 解构所需变量，包括取消标记和临时处理器
+     const { req, res, reqId, isCancelledByClient, preliminaryCloseHandler } = queueItem;
+
+     // --- 重要：立即移除临时监听器（如果存在且未被触发移除）---
+     // 因为我们要么跳过处理，要么添加新的主监听器
+     if (preliminaryCloseHandler) {
+          // 使用 removeListener 以防万一它已被触发并自我移除
+          res.removeListener('close', preliminaryCloseHandler);
+     }
+     // --- 结束移除临时监听器 ---
+
+     // --- 新增：检查请求是否在处理前已被取消 ---
+     if (isCancelledByClient) {
+          console.log(`[${reqId}] Request was cancelled by client before processing began. Skipping.`);
+          // 清理可能由其他地方（如主 close 事件处理器）设置的定时器，以防万一
+          if (operationTimer) clearTimeout(operationTimer);
+          // 标记处理结束（跳过），然后处理下一个
+          isProcessing = false;
+          processQueue(); // 尝试处理下一个请求
+          return; // 退出当前 processQueue 调用
+     }
+     // --- 结束新增检查 ---
+
+     console.log(`\n[${reqId}] ---开始处理队列中的请求 (剩余 ${requestQueue.length} 个)---`);
+
+     let operationTimer; // 主操作定时器
+     // *** 修改：将 isCancelledByClient 的状态传递给处理期间的 isCancelled 标志 ***
+     let isCancelled = isCancelledByClient; 
+     // 如果在开始处理时就已经被取消，添加一条日志
+     if (isCancelled) {
+          console.log(`[${reqId}] Warning: Request was cancelled very shortly before processing logic started.`);
+          // 虽然上面的检查理论上会处理，但这里多一层保险
+     }
+     // *** 结束修改 ***
+     let closeEventHandler = null; // 主 close 事件处理器引用
+
+     try {
+          // 1. 检查 Playwright 状态 (现在可以安全地继续，因为请求未被提前取消)
+          // *** 新增：如果此时 isCancelled 已经是 true，则直接跳到 finally ***
+          if (isCancelled) {
+               console.log(`[${reqId}] Skipping Playwright interaction as request is already marked cancelled.`);
+               throw new Error(`[${reqId}] Request pre-cancelled`); // 抛出错误以跳到 catch/finally
+          }
+          // *** 结束新增检查 ***
+          
+          if (!isPlaywrightReady && !isInitializing) {
+               console.warn(`[${reqId}] Playwright 未就绪，尝试重新初始化...`);
+               await initializePlaywright();
+          }
+          if (!isPlaywrightReady || !page || page.isClosed() || !browser?.isConnected()) {
+               console.error(`[${reqId}] API 请求失败：Playwright 未就绪、页面关闭或连接断开。`);
+               let detail = 'Unknown issue.';
+               if (!browser?.isConnected()) detail = "Browser connection lost.";
+               else if (!page || page.isClosed()) detail = "Target AI Studio page is not available or closed.";
+               else if (!isPlaywrightReady) detail = "Playwright initialization failed or incomplete.";
+               console.error(`[${reqId}] Playwright 连接不可用详情: ${detail}`);
+               // 直接为当前请求返回错误，不需要抛出，因为要继续处理队列
+               if (!res.headersSent) {
+                    res.status(503).json({
+                         error: { message: `[${reqId}] Playwright connection is not active. ${detail} Please ensure Chrome is running correctly, the AI Studio tab is open, and potentially restart the server.`, type: 'server_error' }
+                    });
+               }
+               throw new Error("Playwright not ready for this request."); // Throw to skip further processing in try block
+          }
+
+          const { messages, stream, ...otherParams } = req.body;
+          const isStreaming = stream === true;
+
+          // --- 修改：基于消息数量启发式判断并执行清空操作 + 验证 ---
+          const isLikelyNewChat = Array.isArray(messages) && (messages.length === 1 || (messages.length === 2 && messages.some(m => m.role === 'system')));
+
+          if (isLikelyNewChat && CLEAR_CHAT_BUTTON_SELECTOR && CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR) {
+              console.log(`[${reqId}] 检测到可能是新对话 (消息数: ${messages.length})，尝试清空聊天记录...`);
+              try {
+                  const clearButton = page.locator(CLEAR_CHAT_BUTTON_SELECTOR);
+                  console.log(`[${reqId}]   - 查找并点击"Clear chat" (New chat) 按钮...`);
+                  await clearButton.waitFor({ state: 'visible', timeout: 7000 });
+                  await clearButton.click({ timeout: 5000 });
+                  console.log(`[${reqId}]   - "Clear chat"按钮已点击。新版UI无确认步骤，开始验证清空效果...`);
+
+                  const checkStartTime = Date.now();
+                  let cleared = false;
+                  while (Date.now() - checkStartTime < CLEAR_CHAT_VERIFY_TIMEOUT_MS) {
+                      const modelTurns = page.locator(RESPONSE_CONTAINER_SELECTOR);
+                      const count = await modelTurns.count();
+                      if (count === 0) {
+                          console.log(`[${reqId}]   ✅ 验证成功: 页面上未找到之前的 AI 回复元素 (耗时 ${Date.now() - checkStartTime}ms)。`);
+                          cleared = true;
+                          break;
+                      }
+                      await page.waitForTimeout(CLEAR_CHAT_VERIFY_INTERVAL_MS);
+                  }
+
+                  if (!cleared) {
+                      console.warn(`[${reqId}]   ⚠️ 验证超时: 在 ${CLEAR_CHAT_VERIFY_TIMEOUT_MS}ms 内仍能检测到之前的 AI 回复元素。上下文可能未完全清空。`);
+                      await saveErrorSnapshot(`clear_chat_verify_fail_${reqId}`);
+                  }
+              } catch (clearChatError) {
+                  console.warn(`[${reqId}] ⚠️ 清空聊天记录或验证时出错: ${clearChatError.message.split('\n')[0]}. 将继续执行请求，但上下文可能未被清除。`);
+                  if (clearChatError.message.includes('selector')) {
+                       console.warn(`   (请仔细检查选择器是否仍然有效: CLEAR_CHAT_BUTTON_SELECTOR='${CLEAR_CHAT_BUTTON_SELECTOR}')`);
+                  }
+                  await saveErrorSnapshot(`clear_chat_fail_or_verify_${reqId}`);
+              }
+          } else if (isLikelyNewChat && (!CLEAR_CHAT_BUTTON_SELECTOR || !CLEAR_CHAT_CONFIRM_BUTTON_SELECTOR)) {
+              console.warn(`[${reqId}] 检测到可能是新对话，但未完整配置清空聊天相关的选择器常量，无法自动重置上下文。`);
+          }
+          // --- 结束：启发式新对话处理 ---
+
+          console.log(`[${reqId}] 请求模式: ${isStreaming ? '流式 (SSE)' : '非流式 (JSON)'}`);
+
+          // 2. 设置此请求的总操作超时
+          operationTimer = setTimeout(async () => {
+               await saveErrorSnapshot(`operation_timeout_${reqId}`);
+               console.error(`[${reqId}] Operation timed out after ${RESPONSE_COMPLETION_TIMEOUT / 1000} seconds.`);
+               if (!res.headersSent) {
+                    res.status(504).json({ error: { message: `[${reqId}] Operation timed out`, type: 'timeout_error' } });
+               } else if (isStreaming && !res.writableEnded) {
+                    sendStreamError(res, "Operation timed out on server.", reqId);
+               }
+               // Note: Timeout error now managed within processQueue, allowing next item to proceed
+          }, RESPONSE_COMPLETION_TIMEOUT);
+
+          // 3. 验证请求 (使用更新后��函数)
+          // Pass reqId to validation for better logging context
+          const validationMessages = messages.map(m => ({ ...m, reqId })); // Add reqId temporarily
+          const { userPrompt, systemPrompt: extractedSystemPrompt } = validateChatRequest(validationMessages);
+          // Combine system prompts if provided in multiple ways
+          const systemPrompt = extractedSystemPrompt || otherParams?.system_prompt;
+
+          // --- Logging (Now userPrompt is guaranteed to be a string) ---
+          const userPromptPreview = userPrompt.substring(0, 80);
+          console.log(`[${reqId}]   处理后的 User Prompt (用于提交, start): \"${userPromptPreview}...\" (Total length: ${userPrompt.length})`);
+
+          if (systemPrompt) {
+               // systemPrompt from validateChatRequest is also guaranteed string or null
+               const systemPromptPreview = systemPrompt.substring(0, 80);
+               console.log(`[${reqId}]   处理后的 System Prompt (用于提交, start): \"${systemPromptPreview}...\"`);
+          } else {
+               console.log(`[${reqId}]   无 System Prompt。`);
+          }
+          if (Object.keys(otherParams).length > 0) {
+                console.log(`[${reqId}]   记录到的额外参数: ${JSON.stringify(otherParams)}`);
+          }
+          // --- End Logging ---
+
+          // 4. 准备 Prompt (使用处理后的 userPrompt 和 systemPrompt)
+          let prompt;
+          if (isStreaming) {
+               prompt = prepareAIStudioPromptStream(userPrompt, systemPrompt); // Assumes prepare functions handle null systemPrompt
+               console.log(`[${reqId}] 构建的流式 Prompt (Raw): \"${prompt.substring(0, 200)}...\"`);
+          } else {
+               prompt = prepareAIStudioPrompt(userPrompt, systemPrompt); // Assumes prepare functions handle null systemPrompt
+               console.log(`[${reqId}] 构建的非流式 Prompt (JSON): \"${prompt.substring(0, 200)}...\"`);
+          }
+
+          // 5. 与页面交互并提交
+          const locators = await interactAndSubmitPrompt(page, prompt, reqId);
+
+          // --- 添加 'close' 事件监听器 ---
+          closeEventHandler = async () => {
+               console.log(`[${reqId}] 'close' event handler triggered.`); // <-- 新增日志
+               if (isCancelled) {
+                    console.log(`[${reqId}] 'close' event handler: Already cancelled, doing nothing.`); // <-- 新增日志
+                    return; // 防止重复执行
+               }
+               isCancelled = true;
+               console.log(`[${reqId}] Client disconnected ('close' event). Attempting to stop generation by clicking the run/stop button.`);
+               clearTimeout(operationTimer); // 清除主超时定时器
+
+               // 尝试点击运行/停止按钮 (因为它是同一个按钮)
+               try {
+                    // 确保 locators, submitButton, inputField 存在
+                    if (!locators || !locators.submitButton || !locators.inputField) {
+                         console.warn(`[${reqId}]   closeEventHandler: Cannot attempt to click stop button: locators (button or input) not available.`); // <-- 修改日志
+                         return;
+                    }
+                    // 检查按钮是否仍然可用 (增加超时)
+                    console.log(`[${reqId}]   closeEventHandler: Checking button state (timeout: 2000ms)...`); // <-- 修改日志
+                    const isEnabled = await locators.submitButton.isEnabled({ timeout: 2000 }); // <-- 增加超时
+                    console.log(`[${reqId}]   closeEventHandler: Button isEnabled result: ${isEnabled}`); // <-- 新增日志
+
+                    if (isEnabled) {
+                         // *** 新增：检查输入框是否为空 (增加超时) ***
+                         console.log(`[${reqId}]   closeEventHandler: Button enabled, checking input value (timeout: 2000ms)...`); // <-- 修改日志
+                         const inputValue = await locators.inputField.inputValue({ timeout: 2000 }); // <-- 增加超时
+                         console.log(`[${reqId}]   closeEventHandler: Input value: "${inputValue}"`); // <-- 新增日志
+                         if (inputValue === '') {
+                              console.log(`[${reqId}]   closeEventHandler: Run/Stop button is enabled AND input is empty. Clicking it to stop generation...`); // <-- 修改日志
+                              // 使用 click({ force: true }) 可能更可靠
+                              await locators.submitButton.click({ timeout: 5000, force: true });
+                              console.log(`[${reqId}]   closeEventHandler: Run/Stop button click attempted.`); // <-- 修改日志
+                         } else {
+                              console.log(`[${reqId}]   closeEventHandler: Run/Stop button is enabled BUT input is NOT empty. Assuming user typed new input, not clicking stop.`); // <-- 修改日志
+                         }
+                         // *** 结束新增检查 ***
+                    } else {
+                         console.log(`[${reqId}]   closeEventHandler: Run/Stop button is already disabled (generation likely finished or close event was late). No click needed.`); // <-- 修改日志
+                    }
+               } catch (clickError) {
+                    // 捕获检查或点击过程中的错误
+                    console.warn(`[${reqId}]   closeEventHandler: Error during stop button check/click: ${clickError.message.split('\n')[0]}`); // <-- 修改日志
+                    // 添加更详细日志并尝试保存快照
+                    console.error(`[${reqId}]   closeEventHandler: Detailed error during check/click:`, clickError); 
+                    await saveErrorSnapshot(`close_handler_click_error_${reqId}`); 
+               }
+          };
+          res.on('close', closeEventHandler);
+          // --- 结束添加监听器 ---
+
+          // 6. 定位响应元素
+          const { responseElement } = await locateResponseElements(page, locators, reqId);
+
+          // 7. 处理响应 (流式或非流式)
+          console.log(`[${reqId}] 处理 AI 回复...`);
+          if (isStreaming) {
+               // --- 设置流式响应头 ---
+               res.setHeader('Content-Type', 'text/event-stream');
+               res.setHeader('Cache-Control', 'no-cache');
+               res.setHeader('Connection', 'keep-alive');
+               res.flushHeaders();
+
+               // 调用流式处理函数
+               // 传递检查函数 () => isCancelled
+               await handleStreamingResponse(res, responseElement, page, locators, operationTimer, reqId, () => isCancelled);
+
+          } else {
+               // 调用非流式处理函数
+               // 传递检查函数 () => isCancelled
+               await handleNonStreamingResponse(res, page, locators, operationTimer, reqId, () => isCancelled);
+          }
+
+          // --- 修改：仅在未被取消时记录成功 --- 
+          if (!isCancelled) {
+               console.log(`[${reqId}] ✅ 请求处理成功完成。`);
+               clearTimeout(operationTimer); // 只有真正成功完成才清除计时器
+          } else {
+               console.log(`[${reqId}] ℹ️ 请求处理因客户端断开连接而被中止。`);
+               // operationTimer 应该已经在 closeEventHandler 中被清除了
+          }
+          // --- 结束修改 ---
+
+     } catch (error) {
+          // 确保在任何错误情况下都清除此请求的定时器 (如果 close 事件未触发)
+          if (!isCancelled) {
+               clearTimeout(operationTimer);
+          }
+          console.error(`[${reqId}] ❌ 处理队列中的请求时出错: ${error.message}\n${error.stack}`);
+
+          // --- 恢复：添加条件判断是否需要保存快照 ---
+          const shouldSaveSnapshot = !(
+              error.message?.includes('Invalid request') || // 跳过请求验证错误
+              error.message?.includes('Playwright not ready') // 跳过 Playwright 初始化/连接错误
+              // 未来可以根据需要添加其他不需要快照的错误类型
+          );
+
+          if (shouldSaveSnapshot && !error.message?.includes('snapshot') && !error.stack?.includes('saveErrorSnapshot')) {
+              // 避免在保存快照本身失败或已知Playwright问题时再次尝试保存
+              await saveErrorSnapshot(`general_api_error_${reqId}`);
+          } else if (!shouldSaveSnapshot) {
+              console.log(`[${reqId}] (Info) Skipping error snapshot for this type of error: ${error.message.split('\n')[0]}`);
+          }
+          // --- 结束恢复 ---
+
+          // 发送错误响应，如果尚未发送
+          if (!res.headersSent) {
+                let statusCode = 500;
+                let errorType = 'server_error';
+                if (error.message?.includes('timed out') || error.message?.includes('timeout')) {
+                    statusCode = 504; // Gateway Timeout
+                    errorType = 'timeout_error';
+                } else if (error.message?.includes('AI Studio Error')) {
+                    statusCode = 502; // Bad Gateway (error from upstream)
+                    errorType = 'upstream_error';
+                } else if (error.message?.includes('Invalid request')) {
+                    statusCode = 400; // Bad Request
+                    errorType = 'invalid_request_error';
+                } else if (error.message?.includes('Playwright not ready')) { // Specific handling for PW not ready here
+                    statusCode = 503;
+                    errorType = 'server_error';
+                }
+               res.status(statusCode).json({ error: { message: `[${reqId}] ${error.message}`, type: errorType } });
+          } else if (req.body.stream === true && !res.writableEnded) { // Check if it WAS a streaming request
+                // 如果是流式响应且头部已发送，则发送流式错误
+                sendStreamError(res, error.message, reqId);
+          }
+          else if (!res.writableEnded) {
+                // 对于非流式但已发送部分内容的罕见情况，或流式错误发送后的清理
+                res.end();
+          }
+     } finally {
+          // --- 添加清理逻辑 ---
+          if (closeEventHandler) {
+               res.removeListener('close', closeEventHandler);
+               // console.log(`[${reqId}] Removed 'close' event listener.`); // Optional debug log
+          }
+          // --- 结束清理逻辑 ---
+          isProcessing = false; // 标记处理已结束
+          console.log(`[${reqId}] ---结束处理队列中的请求---`);
+          // 触发处理下一个请求（如果队列中有）
+          processQueue();
+     }
+}
+
+// --- API 端点 (v2.18: 使用队列) ---
+app.post('/v1/chat/completions', async (req, res) => {
+    const reqId = Math.random().toString(36).substring(2, 9); // 生成简短的请求 ID
+    console.log(`\n[${reqId}] === 收到 /v1/chat/completions 请求 ===`);
+
+    // 创建请求队列项，并添加取消标记和临时监听器引用
+    const queueItem = {
+         req,
+         res,
+         reqId,
+         isCancelledByClient: false,
+         preliminaryCloseHandler: null
+    };
+
+    // --- 添加临时的 'close' 事件监听器 ---
+    queueItem.preliminaryCloseHandler = () => {
+         if (!queueItem.isCancelledByClient) { // 避免重复标记
+              console.log(`[${reqId}] Client disconnected before processing started.`);
+              queueItem.isCancelledByClient = true;
+              // 从 res 对象移除自身，防止后续冲突
+              res.removeListener('close', queueItem.preliminaryCloseHandler);
+         }
+    };
+    res.once('close', queueItem.preliminaryCloseHandler); // 使用 once 确保最多触发一次
+    // --- 结束添加临时监听器 ---
+
+    // 将请求加入队列
+    requestQueue.push(queueItem); // <-- 推入包含标记的对象
+    console.log(`[${reqId}] 请求已加入队列 (当前队列长度: ${requestQueue.length})`);
+
+    // 尝试处理队列 (如果当前未在处理)
+    if (!isProcessing) {
+        console.log(`[Queue] 触发队列处理 (收到新请求 ${reqId} 时处于空闲状态)`);
+        processQueue();
+    } else {
+         console.log(`[Queue] 当前正在处理其他请求，请求 ${reqId} 已排队等待。`);
+    }
+});
+
+
+// --- Helper: 获取当前文本 (v2.14 - 获取原始文本) -> vNEXT: Try innerText
+async function getRawTextContent(responseElement, previousText, reqId) {
+    try {
+         await responseElement.waitFor({ state: 'attached', timeout: 1500 });
+         const preElement = responseElement.locator('pre').last();
+         let rawText = null;
+         try {
+              await preElement.waitFor({ state: 'attached', timeout: 500 });
+              // 尝试使用 innerText 获取渲染后的文本，可能更好地保留换行
+              rawText = await preElement.innerText({ timeout: 1000 });
+         } catch {
+              // 如果 pre 元素获取失败，回退到 responseElement 的 innerText
+              console.warn(`[${reqId}] (Warn) Failed to get innerText from <pre>, falling back to parent.`);
+              rawText = await responseElement.innerText({ timeout: 2000 });
+         }
+         // 移除 trim()，直接返回获取到的文本
+         return rawText !== null ? rawText : previousText;
+    } catch (e) {
+         console.warn(`[${reqId}] (Warn) getRawTextContent (innerText) failed: ${e.message.split('\n')[0]}. Returning previous.`);
+         return previousText;
+    }
+}
+
+// --- Helper: 发送流式块 ---
+function sendStreamChunk(res, delta, reqId) {
+    if (delta && !res.writableEnded) {
+        const chunk = {
+            id: `${CHAT_COMPLETION_ID_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 15)}`,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: MODEL_NAME,
+            choices: [{ index: 0, delta: { content: delta }, finish_reason: null }]
+        };
+         try {
+             res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+         } catch (writeError) {
+              console.error(`[${reqId}] Error writing stream chunk:`, writeError.message);
+              if (!res.writableEnded) res.end(); // End stream on write error
+         }
+    }
+}
+
+// --- Helper: 发送流式错误块 ---
+function sendStreamError(res, errorMessage, reqId) {
+     if (!res.writableEnded) {
+         const errorPayload = { error: { message: `[${reqId}] Server error during streaming: ${errorMessage}`, type: 'server_error' } };
+         try {
+              // Avoid writing multiple DONE messages if error occurs after normal DONE
+              if (!res.writableEnded) res.write(`data: ${JSON.stringify(errorPayload)}\n\n`);
+              if (!res.writableEnded) res.write('data: [DONE]\n\n');
+         } catch (e) {
+             console.error(`[${reqId}] Error writing stream error chunk:`, e.message);
+         } finally {
+             if (!res.writableEnded) res.end(); // Ensure stream ends
+         }
+     }
+}
+
+// --- Helper: 保存错误快照 ---
+async function saveErrorSnapshot(errorName = 'error') {
+     // Extract reqId if present in the name
+     const nameParts = errorName.split('_');
+     const reqId = nameParts[nameParts.length - 1].length === 7 ? nameParts.pop() : null; // Simple check for likely reqId
+     const baseErrorName = nameParts.join('_');
+     const logPrefix = reqId ? `[${reqId}]` : '[No ReqId]';
+
+     if (!browser?.isConnected() || !page || page.isClosed()) {
+         console.log(`${logPrefix} 无法保存错误快照 (${baseErrorName})，浏览器或页面不可用。`);
+         return;
+     }
+     console.log(`${logPrefix} 尝试保存错误快照 (${baseErrorName})...`);
+     const timestamp = Date.now();
+     const errorDir = path.join(__dirname, 'errors');
+     try {
+          if (!fs.existsSync(errorDir)) fs.mkdirSync(errorDir, { recursive: true });
+          // Include reqId in filename if available
+          const filenameSuffix = reqId ? `${reqId}_${timestamp}` : `${timestamp}`;
+          const screenshotPath = path.join(errorDir, `${baseErrorName}_screenshot_${filenameSuffix}.png`);
+          const htmlPath = path.join(errorDir, `${baseErrorName}_page_${filenameSuffix}.html`);
+
+          try {
+               await page.screenshot({ path: screenshotPath, fullPage: true, timeout: 15000 });
+               console.log(`${logPrefix}    错误快照已保存到: ${screenshotPath}`);
+          } catch (screenshotError) {
+               console.error(`${logPrefix}    保存屏幕截图失败 (${baseErrorName}): ${screenshotError.message}`);
+          }
+          try {
+               const content = await page.content({timeout: 15000});
+               fs.writeFileSync(htmlPath, content);
+               console.log(`${logPrefix}    错误页面HTML已保存到: ${htmlPath}`);
+          } catch (htmlError) {
+                console.error(`${logPrefix}    保存页面HTML失败 (${baseErrorName}): ${htmlError.message}`);
+          }
+     } catch (dirError) {
+          console.error(`${logPrefix}    创建错误目录或保存快照时出错: ${dirError.message}`);
+     }
+}
+
+// v2.14: Helper to safely parse JSON, attempting to find the outermost object/array
+function tryParseJson(text, reqId) {
+    if (!text || typeof text !== 'string') return null;
+    text = text.trim();
+
+    let startIndex = -1;
+    let endIndex = -1;
+
+    const firstBrace = text.indexOf('{');
+    const firstBracket = text.indexOf('[');
+
+    if (firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket)) {
+        startIndex = firstBrace;
+        endIndex = text.lastIndexOf('}');
+    } else if (firstBracket !== -1) {
+        startIndex = firstBracket;
+        endIndex = text.lastIndexOf(']');
+    }
+
+    if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+        // console.warn(`[${reqId}] (Warn) Could not find valid start/end braces/brackets for JSON parsing.`);
+        return null;
+    }
+
+    const jsonText = text.substring(startIndex, endIndex + 1);
+
+    try {
+        return JSON.parse(jsonText);
+    } catch (e) {
+         // console.warn(`[${reqId}] (Warn) JSON parse failed for extracted text: ${e.message}`);
+        return null;
+    }
+}
+
+// --- Helper: 检测并提取页面错误提示 ---
+async function detectAndExtractPageError(page, reqId) {
+    const errorToastLocator = page.locator(ERROR_TOAST_SELECTOR).last();
+    try {
+        const isVisible = await errorToastLocator.isVisible({ timeout: 1000 });
+        if (isVisible) {
+            console.log(`[${reqId}]    检测到错误 Toast 元素。`);
+            const messageLocator = errorToastLocator.locator('span.content-text');
+            const errorMessage = await messageLocator.textContent({ timeout: 500 });
+            return errorMessage || "Detected error toast, but couldn't extract specific message.";
+        } else {
+             return null;
+        }
+    } catch (e) {
+        // console.warn(`[${reqId}] (Warn) Checking for error toast failed or timed out: ${e.message.split('\n')[0]}`);
+        return null;
+    }
+}
+
+// --- Helper: 快速检查结束条件 ---
+async function checkEndConditionQuickly(page, spinnerLocator, inputLocator, buttonLocator, timeoutMs = 250, reqId) {
+    try {
+        const results = await Promise.allSettled([
+            expect(spinnerLocator).toBeHidden({ timeout: timeoutMs }),
+            expect(inputLocator).toHaveValue('', { timeout: timeoutMs }),
+            expect(buttonLocator).toBeDisabled({ timeout: timeoutMs })
+        ]);
+        const allMet = results.every(result => result.status === 'fulfilled');
+        // console.log(`[${reqId}] (Quick Check) All met: ${allMet}`);
+        return allMet;
+    } catch (error) {
+        // console.warn(`[${reqId}] (Quick Check) Error during checkEndConditionQuickly: ${error.message}`);
+        return false;
+    }
+}
+
+// --- 启动服务器 ---
+let serverInstance = null;
+(async () => {
+    await initializePlaywright();
+
+    serverInstance = app.listen(SERVER_PORT, () => {
+        console.log("\n=============================================================");
+        // v2.18: Updated version marker
+        console.log("          🚀 AI Studio Proxy Server (v2.18 - Queue) 🚀");
+        console.log("=============================================================");
+        console.log(`🔗 监听地址: http://localhost:${SERVER_PORT}`);
+        console.log(`   - Web UI (测试): http://localhost:${SERVER_PORT}/`);
+        console.log(`   - API 端点:   http://localhost:${SERVER_PORT}/v1/chat/completions`);
+        console.log(`   - 模型接口:   http://localhost:${SERVER_PORT}/v1/models`);
+        console.log(`   - 健康检查:   http://localhost:${SERVER_PORT}/health`);
+        console.log("-------------------------------------------------------------");
+        if (isPlaywrightReady) {
+            console.log('✅ Playwright 连接成功，服务已准备就绪！');
+        } else {
+            console.warn('⚠️ Playwright 未就绪。请检查下方日志并确保 Chrome/AI Studio 正常运行。');
+            console.warn('   API 请求将失败，直到 Playwright 连接成功。');
+        }
+        console.log("-------------------------------------------------------------");
+        console.log(`⏳ 等待 Chrome 实例 (调试端口: ${CHROME_DEBUGGING_PORT})...`);
+        console.log("   请确保已运行 auto_connect_aistudio.js 脚本，");
+        console.log("   并且 Google AI Studio 页面已在浏览器中打开。 ");
+        console.log("=============================================================\n");
+    });
+
+    serverInstance.on('error', (error) => {
+        if (error.code === 'EADDRINUSE') {
+            console.error("\n=============================================================");
+            console.error(`❌ 致命错误：端口 ${SERVER_PORT} 已被占用！`);
+            console.error("   请关闭占用该端口的其他程序，或在 server.cjs 中修改 SERVER_PORT。 ");
+            console.error("=============================================================\n");
+        } else {
+            console.error('❌ 服务器启动失败:', error);
+        }
+        process.exit(1);
+    });
+
+})();
+
+// --- 优雅关闭处理 ---
+let isShuttingDown = false;
+async function shutdown(signal) {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    console.log(`\n收到 ${signal} 信号，正在关闭服务器...`);
+    console.log(`当前队列中有 ${requestQueue.length} 个请求等待处理。将不再接受新请求。`);
+    // Option: Wait for the current request to finish?
+    // For now, we'll just close the server, potentially interrupting the current request.
+
+    if (serverInstance) {
+        serverInstance.close(async (err) => {
+            if (err) console.error("关闭 HTTP 服务器时出错:", err);
+            else console.log("HTTP 服务器已关闭。");
+
+            console.log("Playwright connectOverCDP 将自动断开。");
+            // No need to explicitly disconnect browser in connectOverCDP mode
+            console.log('服务器优雅关闭完成。');
+            process.exit(err ? 1 : 0);
+        });
+
+        // Force exit after timeout
+        setTimeout(() => {
+            console.error("优雅关闭超时，强制退出进程。");
+            process.exit(1);
+        }, 10000); // 10 seconds timeout
+    } else {
+        console.log("服务器实例未找到，直接退出。");
+        process.exit(0);
+    }
+}
+
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM')); 

AIStudioProxyAPI/deprecated_javascript_version/test.js

@@ -0,0 +1,126 @@
+// index.js (修改后 - 用于访问本地 server.js 代理)
+
+// 确保已安装 OpenAI SDK: npm install openai
+import OpenAI from "openai";
+import readline from 'readline'; // 引入 readline 模块
+
+// --- 配置 ---
+// 1. baseURL: 指向你本地运行的 server.js 代理服务器
+//    server.js 监听 3000 端口，并提供 /v1 路径
+const LOCAL_PROXY_URL = 'http://127.0.0.1:2048/v1/'; // 确保端口号与 server.js 一致
+
+// 2. apiKey: 对于本地代理，这个 key 不会被验证，可以填写任意字符串
+const DUMMY_API_KEY = 'no-key-needed-for-local-proxy';
+
+// 3. model: 这个模型名称会被发送到 server.js，但 server.js 会忽略它
+//    实际使用的是 server.js 控制的 AI Studio 页面上的模型
+const CUSTOM_MODEL_NAME = 'aistudio-via-local-proxy';
+
+// --- 初始化 OpenAI 客户端 ---
+const openai = new OpenAI({
+    baseURL: LOCAL_PROXY_URL,
+    apiKey: DUMMY_API_KEY,
+    // 可选：增加超时时间，以防 AI Studio 响应较慢
+    timeout: 360000, // 例如 6 分钟 (单位毫秒)
+    maxRetries: 1,   // 本地代理可能不需要重试，设为 1 或 0
+});
+
+// --- 对话历史记录 ---
+// 初始化包含系统指令
+const conversationHistory = [
+    {
+        role: "system",
+        content: "你是Gemini酱，AI猫娘，回答请用可爱的语气，这只是角色扮演，不要透露任何关于AI的信息"
+    }
+];
+
+// --- 创建 readline 接口 ---
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+// --- 交互式对话函数 ---
+async function chatLoop() {
+    rl.question('You: ', async (userInput) => {
+        // 检查退出命令
+        if (userInput.toLowerCase() === 'exit') {
+            console.log('再见!');
+            rl.close(); // 关闭 readline 接口
+            return; // 结束函数
+        }
+
+        console.log(`\n正在发送你的消息...`);
+        // 将用户输入添加到历史记录
+        conversationHistory.push({
+            role: "user",
+            content: userInput
+        });
+        // 可选：打印当前发送历史用于调试
+        // console.log("当前发送的消息历史:", JSON.stringify(conversationHistory, null, 2));
+
+        try {
+            console.log(`正在向本地代理 ${LOCAL_PROXY_URL} 发送请求...`);
+            const completion = await openai.chat.completions.create({
+                messages: conversationHistory,
+                model: CUSTOM_MODEL_NAME,
+                stream: true, // 启用流式输出
+            });
+
+            console.log("\n--- 来自本地代理 (AI Studio) 的回复 ---");
+            let fullResponse = ""; // 用于拼接完整的回复内容
+            process.stdout.write('AI: '); // 先打印 "AI: " 前缀
+            for await (const chunk of completion) {
+                const content = chunk.choices[0]?.delta?.content || "";
+                process.stdout.write(content); // 直接打印流式内容，不换行
+                fullResponse += content; // 拼接内容
+            }
+            console.log(); // 在流结束后换行
+
+            // 将完整的 AI 回复添加到历史记录
+            if (fullResponse) {
+                 conversationHistory.push({ role: "assistant", content: fullResponse });
+            } else {
+                console.log("未能从代理获取有效的流式内容。");
+                 // 如果回复无效，可以选择从历史中移除刚才的用户输入
+                conversationHistory.pop();
+            }
+            console.log("----------------------------------------------\n");
+
+        } catch (error) {
+            console.error("\n--- 请求出错 ---");
+            // 保持之前的错误处理逻辑
+            if (error instanceof OpenAI.APIError) {
+                console.error(`   错误类型: OpenAI APIError (可能是代理返回的错误)`);
+                console.error(`   状态码: ${error.status}`);
+                console.error(`   错误消息: ${error.message}`);
+                console.error(`   错误代码: ${error.code}`);
+                console.error(`   错误参数: ${error.param}`);
+            } else if (error.code === 'ECONNREFUSED') {
+                console.error(`   错误类型: 连接被拒绝 (ECONNREFUSED)`);
+                console.error(`   无法连接到服务器 ${LOCAL_PROXY_URL}。请检查 server.js 是否运行。`);
+            } else if (error.name === 'TimeoutError' || (error.cause && error.cause.code === 'UND_ERR_CONNECT_TIMEOUT')) {
+                 console.error(`   错误类型: 连接超时`);
+                 console.error(`   连接到 ${LOCAL_PROXY_URL} 超时。请检查 server.js 或 AI Studio 响应。`);
+            } else {
+                console.error('   发生了未知错误:', error.message);
+            }
+            console.error("----------------------------------------------\n");
+             // 出错时，从历史中移除刚才的用户输入，避免影响下次对话
+            conversationHistory.pop();
+        }
+
+        // 不论成功或失败，都继续下一次循环
+        chatLoop();
+    });
+}
+
+// --- 启动交互式对话 ---
+console.log('你好! 我是Gemini酱。有什么事可以帮你哒，输入 "exit" 退出。');
+console.log('   (请确保 server.js 和 auto_connect_aistudio.js 正在运行)');
+chatLoop(); // 开始第一次提问
+
+// --- 不再需要文件末尾的 main 调用和 setTimeout 示例 ---
+// // 运行第一次对话
+// main("你好！简单介绍一下你自己以及你的能力。");
+// ... (移除 setTimeout 示例)

AIStudioProxyAPI/docker/.env.docker

@@ -0,0 +1,150 @@
+# Docker 环境配置文件示例
+# 复制此文件为 .env 并根据需要修改配置
+
+# =============================================================================
+# Docker 主机端口配置
+# =============================================================================
+
+# 主机上映射的端口 (外部访问端口)
+HOST_FASTAPI_PORT=2048
+HOST_STREAM_PORT=3120
+
+# =============================================================================
+# 容器内服务端口配置
+# =============================================================================
+
+# FastAPI 服务端口 (容器内)
+PORT=8000
+DEFAULT_FASTAPI_PORT=2048
+DEFAULT_CAMOUFOX_PORT=9222
+
+# 流式代理服务配置
+STREAM_PORT=3120
+
+# =============================================================================
+# 代理配置
+# =============================================================================
+
+# HTTP/HTTPS 代理设置
+# HTTP_PROXY=http://host.docker.internal:7890
+# HTTPS_PROXY=http://host.docker.internal:7890
+
+# 统一代理配置 (优先级高于 HTTP_PROXY/HTTPS_PROXY)
+# UNIFIED_PROXY_CONFIG=http://host.docker.internal:7890
+
+# 代理绕过列表 (用分号分隔)
+# NO_PROXY=localhost;127.0.0.1;*.local
+
+# =============================================================================
+# 日志配置
+# =============================================================================
+
+# 服务器日志级别 (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+SERVER_LOG_LEVEL=INFO
+
+# 是否重定向 print 输出到日志
+SERVER_REDIRECT_PRINT=false
+
+# 启用调试日志
+DEBUG_LOGS_ENABLED=false
+
+# 启用跟踪日志
+TRACE_LOGS_ENABLED=false
+
+# =============================================================================
+# 认证配置
+# =============================================================================
+
+# 自动保存认证信息
+AUTO_SAVE_AUTH=false
+
+# 认证保存超时时间 (秒)
+AUTH_SAVE_TIMEOUT=30
+
+# 自动确认登录
+AUTO_CONFIRM_LOGIN=true
+
+# =============================================================================
+# 浏览器配置
+# =============================================================================
+
+# 启动模式 (normal, headless, virtual_display, direct_debug_no_browser)
+LAUNCH_MODE=headless
+
+# =============================================================================
+# API 默认参数配置
+# =============================================================================
+
+# 默认温度值 (0.0-2.0)
+DEFAULT_TEMPERATURE=1.0
+
+# 默认最大输出令牌数
+DEFAULT_MAX_OUTPUT_TOKENS=65536
+
+# 默认 Top-P 值 (0.0-1.0)
+DEFAULT_TOP_P=0.95
+
+# 默认停止序列 (JSON 数组格式)
+DEFAULT_STOP_SEQUENCES=["用户:"]
+
+# =============================================================================
+# 超时配置 (毫秒)
+# =============================================================================
+
+# 响应完成总超时时间
+RESPONSE_COMPLETION_TIMEOUT=300000
+
+# 轮询间隔
+POLLING_INTERVAL=300
+POLLING_INTERVAL_STREAM=180
+
+# 静默超时
+SILENCE_TIMEOUT_MS=60000
+
+# =============================================================================
+# 脚本注入配置
+# =============================================================================
+
+# 是否启用油猴脚本注入功能
+ENABLE_SCRIPT_INJECTION=false
+
+# 油猴脚本文件路径（相对于容器内 /app 目录）
+USERSCRIPT_PATH=browser_utils/more_modles.js
+
+# 注意：MODEL_CONFIG_PATH 已废弃
+# 模型数据现在直接从 USERSCRIPT_PATH 指定的油猴脚本中解析
+
+# =============================================================================
+# Docker 特定配置
+# =============================================================================
+
+# 容器内存限制
+# 默认不限制。如需限制容器资源，请在你的 .env 文件中取消注释并设置以下值。
+# 例如: DOCKER_MEMORY_LIMIT=1g或DOCKER_MEMORY_LIMIT=1024m
+# 注意：DOCKER_MEMORY_LIMIT和DOCKER_MEMSWAP_LIMIT相同时，不会使用SWAP
+# DOCKER_MEMORY_LIMIT=
+# DOCKER_MEMSWAP_LIMIT=
+
+# 容器重启策略相关
+# 这些配置项在 docker-compose.yml 中使用
+
+# 健康检查间隔 (秒)
+HEALTHCHECK_INTERVAL=30
+
+# 健康检查超时 (秒)
+HEALTHCHECK_TIMEOUT=10
+
+# 健康检查重试次数
+HEALTHCHECK_RETRIES=3
+
+# =============================================================================
+# 网络配置说明
+# =============================================================================
+
+# 在 Docker 环境中访问主机服务，请使用：
+# - Linux: host.docker.internal
+# - macOS: host.docker.internal  
+# - Windows: host.docker.internal
+# 
+# 例如，如果主机上有代理服务运行在 7890 端口：
+# HTTP_PROXY=http://host.docker.internal:7890

AIStudioProxyAPI/docker/Dockerfile

@@ -0,0 +1,116 @@
+# Dockerfile
+
+#ARG PROXY_ADDR="http://host.docker.internal:7890" Linxux 下使用 host.docker.internal 可能会有问题，建议使用实际的代理地址
+FROM python:3.10-slim-bookworm AS builder
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG PROXY_ADDR
+
+RUN if [ -n "$PROXY_ADDR" ]; then \
+    printf 'Acquire::http::Proxy "%s";\nAcquire::https::Proxy "%s";\n' "$PROXY_ADDR" "$PROXY_ADDR" > /etc/apt/apt.conf.d/99proxy; \
+    fi && \
+    apt-get update && \
+    apt-get install -y --no-install-recommends curl \
+    && apt-get clean && rm -rf /var/lib/apt/lists/* && \
+    if [ -n "$PROXY_ADDR" ]; then rm -f /etc/apt/apt.conf.d/99proxy; fi
+
+ENV HTTP_PROXY=${PROXY_ADDR}
+ENV HTTPS_PROXY=${PROXY_ADDR}
+
+ENV POETRY_HOME="/opt/poetry"
+ENV POETRY_VERSION=1.8.3
+RUN curl -sSL https://install.python-poetry.org | python3 - --version ${POETRY_VERSION}
+ENV PATH="${POETRY_HOME}/bin:${PATH}"
+
+WORKDIR /app_builder
+COPY pyproject.toml poetry.lock ./
+RUN poetry config virtualenvs.create false --local && \
+    poetry install --no-root --no-dev --no-interaction --no-ansi
+
+FROM python:3.10-slim-bookworm
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG PROXY_ADDR
+
+ENV HTTP_PROXY=${PROXY_ADDR}
+ENV HTTPS_PROXY=${PROXY_ADDR}
+
+# 步骤 1: 安装所有系统依赖。
+# Playwright 的依赖也在这里一并安装。
+RUN \
+    if [ -n "$PROXY_ADDR" ]; then \
+    printf 'Acquire::http::Proxy "%s";\nAcquire::https::Proxy "%s";\n' "$PROXY_ADDR" "$PROXY_ADDR" > /etc/apt/apt.conf.d/99proxy; \
+    fi && \
+    apt-get update && \
+    apt-get install -y --no-install-recommends \
+    libatk1.0-0 libatk-bridge2.0-0 libcups2 libdbus-1-3 libdrm2 libgbm1 libgtk-3-0 libnspr4 libnss3 libx11-6 libx11-xcb1 libxcb1 libxcomposite1 libxdamage1 libxext6 libxfixes3 libxrandr2 libxrender1 libxtst6 ca-certificates fonts-liberation libasound2 libpangocairo-1.0-0 libpango-1.0-0 libu2f-udev \
+    supervisor curl \
+    && \
+    # 清理工作
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/* && \
+    if [ -n "$PROXY_ADDR" ]; then rm -f /etc/apt/apt.conf.d/99proxy; fi
+
+RUN groupadd -r appgroup && useradd -r -g appgroup -s /bin/bash -d /app appuser
+
+WORKDIR /app
+
+# 步骤 2: 复制 Python 包和可执行文件。
+# 这是关键的顺序调整：在使用 playwright 之前先把它复制进来。
+COPY --from=builder /usr/local/lib/python3.10/site-packages/ /usr/local/lib/python3.10/site-packages/
+COPY --from=builder /usr/local/bin/ /usr/local/bin/
+COPY --from=builder /opt/poetry/bin/poetry /usr/local/bin/poetry
+
+# 复制应用代码
+COPY . .
+
+# 步骤 3: 现在 Python 模块已存在，可以安全地运行这些命令。
+# 注意：我们不再需要 `playwright install-deps`，因为依赖已在上面的 apt-get 中安装。
+RUN camoufox fetch && \
+    python -m playwright install firefox
+
+# 创建目录和设置权限
+RUN mkdir -p /app/logs && \
+    mkdir -p /app/auth_profiles/active && \
+    mkdir -p /app/auth_profiles/saved && \
+    mkdir -p /app/certs && \
+    mkdir -p /app/browser_utils/custom_scripts && \
+    mkdir -p /home/appuser/.cache/ms-playwright && \
+    mkdir -p /home/appuser/.mozilla && \
+    chown -R appuser:appgroup /app && \
+    chown -R appuser:appgroup /home/appuser
+
+COPY supervisord.conf /etc/supervisor/conf.d/app.conf
+
+# 修复 camoufox 缓存逻辑
+RUN mkdir -p /var/cache/camoufox && \
+    if [ -d /root/.cache/camoufox ]; then cp -a /root/.cache/camoufox/* /var/cache/camoufox/; fi && \
+    mkdir -p /app/.cache && \
+    ln -s /var/cache/camoufox /app/.cache/camoufox
+
+RUN python update_browserforge_data.py
+
+# 清理代理环境变量
+ENV HTTP_PROXY=""
+ENV HTTPS_PROXY=""
+
+EXPOSE 2048
+EXPOSE 3120
+
+USER appuser
+ENV HOME=/app
+ENV PLAYWRIGHT_BROWSERS_PATH=/home/appuser/.cache/ms-playwright
+
+ENV PYTHONUNBUFFERED=1
+
+ENV PORT=8000
+ENV DEFAULT_FASTAPI_PORT=2048
+ENV DEFAULT_CAMOUFOX_PORT=9222
+ENV STREAM_PORT=3120
+ENV SERVER_LOG_LEVEL=INFO
+ENV DEBUG_LOGS_ENABLED=false
+ENV AUTO_CONFIRM_LOGIN=true
+ENV SERVER_PORT=2048
+ENV INTERNAL_CAMOUFOX_PROXY=""
+
+CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/app.conf"]

AIStudioProxyAPI/docker/README-Docker.md

@@ -0,0 +1,456 @@
+# Docker 部署指南 (AI Studio Proxy API)
+
+> 📁 **注意**: 所有 Docker 相关文件现在都位于 `docker/` 目录中，保持项目根目录的整洁。
+
+本文档提供了使用 Docker 构建和运行 AI Studio Proxy API 项目的完整指南，包括 Poetry 依赖管理、`.env` 配置管理和脚本注入功能。
+
+## 🐳 概述
+
+Docker 部署提供了以下优势：
+- ✅ **环境隔离**: 容器化部署，避免环境冲突
+- ✅ **Poetry 依赖管理**: 使用现代化的 Python 依赖管理工具
+- ✅ **统一配置**: 基于 `.env` 文件的配置管理
+- ✅ **版本更新无忧**: `bash update.sh` 即可完成更新
+- ✅ **跨平台支持**: 支持 x86_64 和 ARM64 架构
+- ✅ **配置持久化**: 认证文件和日志持久化存储
+- ✅ **多阶段构建**: 优化镜像大小和构建速度
+
+## 先决条件
+
+*   **Docker**: 确保您的系统已正确安装并正在运行 Docker。您可以从 [Docker 官方网站](https://www.docker.com/get-started) 下载并安装 Docker Desktop (适用于 Windows 和 macOS) 或 Docker Engine (适用于 Linux)。
+*   **项目代码**: 项目代码已下载到本地。
+*   **认证文件**: 首次运行需要在主机上完成认证文件获取，Docker环境目前仅支持日常运行。
+
+## 🔧 Docker 环境规格
+
+*   **基础镜像**: Python 3.10-slim-bookworm (稳定且轻量)
+*   **Python版本**: 3.10 (在容器内运行，与主机Python版本无关)
+*   **依赖管理**: Poetry (现代化 Python 依赖管理)
+*   **构建方式**: 多阶段构建 (builder + runtime)
+*   **架构支持**: x86_64 和 ARM64 (Apple Silicon)
+*   **模块化设计**: 完全支持项目的模块化架构
+*   **虚拟环境**: Poetry 自动管理虚拟环境
+
+## 1. 理解项目中的 Docker 相关文件
+
+在项目根目录下，您会找到以下与 Docker 配置相关的文件：
+
+*   **[`Dockerfile`](./Dockerfile:1):** 这是构建 Docker 镜像的蓝图。它定义了基础镜像、依赖项安装、代码复制、端口暴露以及容器启动时执行的命令。
+*   **[`.dockerignore`](./.dockerignore:1):** 这个文件列出了在构建 Docker 镜像时应忽略的文件和目录。这有助于减小镜像大小并加快构建速度，例如排除 `.git` 目录、本地开发环境文件等。
+*   **[`supervisord.conf`](./supervisord.conf:1):** (如果项目使用 Supervisor) Supervisor 是一个进程控制系统，它允许用户在类 UNIX 操作系统上监控和控制多个进程。此配置文件定义了 Supervisor 应如何管理应用程序的进程 (例如，主服务和流服务)。
+
+## 2. 构建 Docker 镜像
+
+要构建 Docker 镜像，请在项目根目录下打开终端或命令行界面，然后执行以下命令：
+
+```bash
+# 方法 1: 使用 docker compose (推荐)
+cd docker
+docker compose build
+
+# 方法 2: 直接使用 docker build (在项目根目录执行)
+docker build -f docker/Dockerfile -t ai-studio-proxy:latest .
+```
+
+**命令解释:**
+
+*   `docker build`: 这是 Docker CLI 中用于构建镜像的命令。
+*   `-t ai-studio-proxy:latest`: `-t` 参数用于为镜像指定一个名称和可选的标签 (tag)，格式为 `name:tag`。
+    *   `ai-studio-proxy`: 是您为镜像选择的名称。
+    *   `latest`: 是标签，通常表示这是该镜像的最新版本。您可以根据版本控制策略选择其他标签，例如 `ai-studio-proxy:1.0`。
+*   `.`: (末尾的点号) 指定了 Docker 构建上下文的路径。构建上下文是指包含 [`Dockerfile`](./Dockerfile:1) 以及构建镜像所需的所有其他文件和目录的本地文件系统路径。点号表示当前目录。Docker 守护进程会访问此路径下的文件来执行构建。
+
+构建过程可能需要一些时间，具体取决于您的网络速度和项目依赖项的多少。成功构建后，您可以使用 `docker images` 命令查看本地已有的镜像列表，其中应包含 `ai-studio-proxy:latest`。
+
+## 3. 运行 Docker 容器
+
+镜像构建完成后，您可以选择以下两种方式来运行容器：
+
+### 方式 A: 使用 Docker Compose (推荐)
+
+Docker Compose 提供了更简洁的配置管理方式，特别适合使用 `.env` 文件：
+
+```bash
+# 1. 准备配置文件 (进入 docker 目录)
+cd docker
+cp .env.docker .env
+# 编辑 .env 文件以适应您的需求
+
+# 2. 使用 Docker Compose 启动 (在 docker 目录下)
+docker compose up -d
+
+# 3. 查看日志
+docker compose logs -f
+
+# 4. 停止服务
+docker compose down
+```
+
+### 方式 B: 使用 Docker 命令
+
+您也可以使用传统的 Docker 命令来创建并运行容器：
+
+### 方法 1: 使用 .env 文件 (推荐)
+
+```bash
+docker run -d \
+    -p <宿主机_服务端口>:2048 \
+    -p <宿主机_流端口>:3120 \
+    -v "$(pwd)/../auth_profiles":/app/auth_profiles \
+    -v "$(pwd)/.env":/app/.env \
+    # 可选: 如果您想使用自己的 SSL/TLS 证书，请取消下面一行的注释���
+    # 请确保宿主机上的 'certs/' 目录存在，并且其中包含应用程序所需的证书文件。
+    # -v "$(pwd)/../certs":/app/certs \
+    --name ai-studio-proxy-container \
+    ai-studio-proxy:latest
+```
+
+### 方法 2: 使用环境变量 (传统方式)
+
+```bash
+docker run -d \
+    -p <宿主机_服务端口>:2048 \
+    -p <宿主机_流端口>:3120 \
+    -v "$(pwd)/../auth_profiles":/app/auth_profiles \
+    # 可选: 如果您想使用自己的 SSL/TLS 证书，请取消下面一行的注释。
+    # 请确保宿主机上的 'certs/' 目录存在，并且其中包含应用程序所需的证书文件。
+    # -v "$(pwd)/../certs":/app/certs \
+    -e PORT=8000 \
+    -e DEFAULT_FASTAPI_PORT=2048 \
+    -e DEFAULT_CAMOUFOX_PORT=9222 \
+    -e STREAM_PORT=3120 \
+    -e SERVER_LOG_LEVEL=INFO \
+    -e DEBUG_LOGS_ENABLED=false \
+    -e AUTO_CONFIRM_LOGIN=true \
+    # 可选: 如果您需要设置代理，请取消下面的注释
+    # -e HTTP_PROXY="http://your_proxy_address:port" \
+    # -e HTTPS_PROXY="http://your_proxy_address:port" \
+    # -e UNIFIED_PROXY_CONFIG="http://your_proxy_address:port" \
+    --name ai-studio-proxy-container \
+    ai-studio-proxy:latest
+```
+
+**命令解释:**
+
+*   `docker run`: 这是 Docker CLI 中用于从镜像创建并启动容器的命令。
+*   `-d`: 以“分离模式”(detached mode) 运行容器。这意味着容器将在后台运行，您的终端提示符将立即可用，而不会被容器的日志输出占用。
+*   `-p <宿主机_服务端口>:2048`: 端口映射 (Port mapping)。
+    *   此参数将宿主机的某个端口映射到容器内部的 `2048` 端口。`2048` 是应用程序主服务在容器内监听的端口。
+    *   您需要将 `<宿主机_服务端口>` 替换为您希望在宿主机上用于访问此服务的实际端口号 (例如，如果您想通过宿主机的 `8080` 端口访问服务，则使用 `-p 8080:2048`)。
+*   `-p <宿主机_流端口>:3120`: 类似地，此参数将宿主机的某个端口映射到容器内部的 `3120` 端口，这是应用程序流服务在容器内监听的端口。
+    *   您需要将 `<宿主机_流端口>` 替换为您希望在宿主机上用于访问流服务的实际端口号 (例如 `-p 8081:3120`)。
+*   `-v "$(pwd)/../auth_profiles":/app/auth_profiles`: 卷挂载 (Volume mounting)。
+    *   此参数将宿主机当前工作目录 (`$(pwd)`) 下的 `auth_profiles/` 目录挂载到容器内的 `/app/auth_profiles/` 目录。
+    *   这样做的好处是：
+        *   **持久化数据:** 即使容器被删除，`auth_profiles/` 中的数据仍保留在宿主机上。
+        *   **方便配置:** 您可以直接在宿主机上修改 `auth_profiles/` 中的文件，更改会实时反映到容器中 (取决于应用程序如何读取这些文件)。
+    *   **重要:** 在运行命令前，请确保宿主机上的 `auth_profiles/` 目录已存在。如果应用程序期望在此目录中找到特定的配置文件，请提前准备好。
+*   `# -v "$(pwd)/../certs":/app/certs` (可选，已注释): 挂载自定义证书。
+    *   如果您希望应用程序使用您自己的 SSL/TLS 证书而不是自动生成的证书，可以取消此行的注释。
+    *   它会将宿主机当前工作目录下的 `certs/` 目录挂载到容器内的 `/app/certs/` 目录。
+    *   **重要:** 如果启用此选项，请确保宿主机上的 `certs/` 目录存在，并且其中包含应用程序所需的证书文件 (通常是 `server.crt` 和 `server.key` 或类似名称的文件)。应用程序也需要被配置为从 `/app/certs/` 读取这些证书。
+*   `-e SERVER_PORT=2048`: 设置环境变量。
+    *   `-e` 参数用于在容器内设置环境变量。
+    *   这里，我们将 `SERVER_PORT` 环境变量设置为 `2048`。应用程序在容器内会读取此变量来确定其主服务应监听哪个端口。这应与 [`Dockerfile`](./Dockerfile:1) 中 `EXPOSE` 指令以及 [`supervisord.conf`](./supervisord.conf:1) (如果使用) 中的配置相匹配。
+*   `-e STREAM_PORT=3120`: 类似地，设置 `STREAM_PORT` 环境变量为 `3120`，供应用程序的流服务使用。
+*   `# -e INTERNAL_CAMOUFOX_PROXY="http://your_proxy_address:port"` (可选，已注释): 设置内部 Camoufox 代理。
+    *   如果您的应用程序需要通过一个特定的内部代理服务器来访问 Camoufox 或其他外部服务，可以取消此行的注释，并将 `"http://your_proxy_address:port"` 替换为实际的代理服务器地址和端口 (例如 `http://10.0.0.5:7890` 或 `socks5://proxy-user:proxy-pass@10.0.0.10:1080`)。
+*   `--name ai-studio-proxy-container`: 为正在运行的容器指定一个名称。
+    *   这使得管理容器更加方便。例如，您可以使用 `docker stop ai-studio-proxy-container` 来停止这个容器，或使用 `docker logs ai-studio-proxy-container` 来查看其日志。
+    *   如果您不指定名称，Docker 会自动为容器生成一个随机名称。
+*   `ai-studio-proxy:latest`: 指定要运行的镜像的名称和标签。这必须与您在 `docker build` 命令中使用的名称和标签相匹配。
+
+**首次运行前的重要准备:**
+
+### 配置文件准备
+
+1. **创建 `.env` 配置文件 (推荐):**
+   ```bash
+   # 复制配置模板 (在项目 docker 目录下执行)
+   cp .env.docker .env
+
+   # 编辑配置文件
+   nano .env  # 或使用其他编辑器
+   ```
+
+   **`.env` 文件的优势:**
+   - ✅ **版本更新无忧**: 一个 `git pull` 就完成更新，无需重新配置
+   - ✅ **配置集中管理**: 所有配置项统一在 `.env` 文件中
+   - ✅ **Docker 兼容**: 容器会自动读取挂载的 `.env` 文件
+   - ✅ **安全性**: `.env` 文件已被 `.gitignore` 忽略，不会泄露配置
+
+2. **创建 `auth_profiles/` 目录:** 在项目根目录下 (与 [`Dockerfile`](./Dockerfile:1) 同级)，手动创建一个名为 `auth_profiles` 的目录。如果您的应用程序需要初始的认证配置文件，请将它们放入此目录中。
+
+3. **(可选) 创建 `certs/` 目录:** 如果您计划使用自己的证书并取消了相关卷挂载行的注释，请在项目根目录下创建一个名为 `certs` 的目录，并将您的证书文件 (例如 `server.crt`, `server.key`) 放入其中。
+
+## 4. 环境变量配置详解
+
+### 使用 .env 文件配置 (推荐)
+
+项目现在支持通过 `.env` 文件进行配置管理。在 Docker 环境中，您只需要将 `.env` 文件挂载到容器中即可：
+
+```bash
+# 挂载 .env 文件到容器
+-v "$(pwd)/.env":/app/.env
+```
+
+### 常用配置项
+
+以下是 Docker 环境中常用的配置项：
+
+```env
+# 服务端口配置
+PORT=8000
+DEFAULT_FASTAPI_PORT=2048
+DEFAULT_CAMOUFOX_PORT=9222
+STREAM_PORT=3120
+
+# 代理配置
+HTTP_PROXY=http://127.0.0.1:7890
+HTTPS_PROXY=http://127.0.0.1:7890
+UNIFIED_PROXY_CONFIG=http://127.0.0.1:7890
+
+# 日志配置
+SERVER_LOG_LEVEL=INFO
+DEBUG_LOGS_ENABLED=false
+TRACE_LOGS_ENABLED=false
+
+# 认证配置
+AUTO_CONFIRM_LOGIN=true
+AUTO_SAVE_AUTH=false
+AUTH_SAVE_TIMEOUT=30
+
+# 脚本注入配置 v3.0 (重大升级)
+ENABLE_SCRIPT_INJECTION=true
+USERSCRIPT_PATH=browser_utils/more_modles.js
+# 注意：MODEL_CONFIG_PATH 已废弃，现在直接从油猴脚本解析模型数据
+# v3.0 使用 Playwright 原生网络拦截，100% 可靠
+
+# API 默认参数
+DEFAULT_TEMPERATURE=1.0
+DEFAULT_MAX_OUTPUT_TOKENS=65536
+DEFAULT_TOP_P=0.95
+```
+
+### 配置优先级
+
+在 Docker 环境中，配置的优先级顺序为：
+
+1. **Docker 运行时环境变量** (`-e` 参数) - 最高优先级
+2. **挂载的 .env 文件** - 中等优先级
+3. **Dockerfile 中的 ENV** - 最低优先级
+
+### 示例：完整的 Docker 运行命令
+
+```bash
+# 使用 .env 文件的完整示例
+docker run -d \
+    -p 8080:2048 \
+    -p 8081:3120 \
+    -v "$(pwd)/../auth_profiles":/app/auth_profiles \
+    -v "$(pwd)/.env":/app/.env \
+    --name ai-studio-proxy-container \
+    ai-studio-proxy:latest
+```
+
+## 5. 管理正在运行的容器
+
+一旦容器启动，您可以使用以下 Docker 命令来管理它：
+
+*   **查看正在运行的容器:**
+    ```bash
+    docker ps
+    ```
+    (如果您想查看所有容器，包括已停止的，请使用 `docker ps -a`)
+
+*   **查看容器日志:**
+    ```bash
+    docker logs ai-studio-proxy-container
+    ```
+    (如果您想持续跟踪日志输出，可以使用 `-f` 参数: `docker logs -f ai-studio-proxy-container`)
+
+*   **停止容器:**
+    ```bash
+    docker stop ai-studio-proxy-container
+    ```
+
+*   **启动已停止的容器:**
+    ```bash
+    docker start ai-studio-proxy-container
+    ```
+
+*   **重启容器:**
+    ```bash
+    docker restart ai-studio-proxy-container
+    ```
+
+*   **进入容器内部 (获取一个交互式 shell):**
+    ```bash
+    docker exec -it ai-studio-proxy-container /bin/bash
+    ```
+    (或者 `/bin/sh`，取决于容器基础镜像中可用的 shell。这对于调试非常有用。)
+
+*   **删除容器:**
+    首先需要停止容器，然后才能删除它。
+    ```bash
+    docker stop ai-studio-proxy-container
+    docker rm ai-studio-proxy-container
+    ```
+    (如果您想强制删除正在运行的容器，可以使用 `docker rm -f ai-studio-proxy-container`，但不建议这样做，除非您知道自己在做什么。)
+
+## 5. 更新应用程序
+
+当您更新了应用程序代码并希望部署新版本时，通常需要执行以下步骤：
+
+1.  **停止并删除旧的容器** (如果它正在使用相同的端口或名称)：
+    ```bash
+    docker stop ai-studio-proxy-container
+    docker rm ai-studio-proxy-container
+    ```
+2.  **重新构建 Docker 镜像** (确保您在包含最新代码和 [`Dockerfile`](./Dockerfile:1) 的目录中)：
+    ```bash
+    docker build -t ai-studio-proxy:latest .
+    ```
+3.  **使用新的镜像运行新的容���** (使用与之前相同的 `docker run` 命令，或根据需要进行调整)：
+    ```bash
+    docker run -d \
+        -p <宿主机_服务端口>:2048 \
+        # ... (其他参数与之前相同) ...
+        --name ai-studio-proxy-container \
+        ai-studio-proxy:latest
+    ```
+
+## 6. 清理
+
+*   **删除指定的 Docker 镜像:**
+    ```bash
+    docker rmi ai-studio-proxy:latest
+    ```
+    (注意：如果存在基于此镜像的容器，您需要先删除这些容器。)
+
+*   **删除所有未使用的 (悬空) 镜像、容器、网络和卷:**
+    ```bash
+    docker system prune
+    ```
+    (如果想删除所有未使用的镜像，不仅仅是悬空的，可以使用 `docker system prune -a`)
+    **警告:** `prune` 命令会删除数据，请谨慎使用。
+
+希望本教程能帮助您成功地通过 Docker 部署和运行 AI Studio Proxy API 项目！
+
+## 脚本注入配置 (v3.0 新功能) 🆕
+
+### 概述
+
+Docker 环境完全支持最新的脚本注入功能 v3.0，提供革命性的改进：
+
+- **🚀 Playwright 原生拦截**: 使用 Playwright 路由拦截，100% 可靠性
+- **🔄 双重保障机制**: 网络拦截 + 脚本注入，确保万无一失
+- **📝 直接脚本解析**: 从油猴脚本中自动解析模型列表，无需配置文件
+- **🔗 前后端同步**: 前端和后端使用相同的模型数据源，100%一致
+- **⚙️ 零配置维护**: 无需手动维护模型配置文件，脚本更新自动生效
+- **🔄 自动适配**: 油猴脚本更新时无需手动更新配置
+
+### 配置选项
+
+在 `.env` 文件中配置以下选项：
+
+```env
+# 是否启用脚本注入功能
+ENABLE_SCRIPT_INJECTION=true
+
+# 油猴脚本文件路径（容器内路径）
+# 模型数据直接从此脚本文件中解析，无需额外配置文件
+USERSCRIPT_PATH=browser_utils/more_modles.js
+```
+
+### 自定义脚本和模型配置
+
+如果您想使用自定义的脚本或模型配置：
+
+1. **自定义脚本配置**：
+   ```bash
+   # 在主机上创建自定义脚本文件
+   cp browser_utils/more_modles.js browser_utils/my_script.js
+   # 编辑 my_script.js 中的 MODELS_TO_INJECT 数组
+
+   # 在 docker-compose.yml 中取消注释并修改挂载行：
+   # - ../browser_utils/my_script.js:/app/browser_utils/more_modles.js:ro
+
+   # 或者在 .env 中修改路径：
+   # USERSCRIPT_PATH=browser_utils/my_script.js
+   ```
+
+2. **自定义脚本**：
+   ```bash
+   # 将自定义脚本放在 browser_utils/ 目录
+   cp your_custom_script.js browser_utils/custom_script.js
+
+   # 在 .env 中修改路径：
+   # USERSCRIPT_PATH=browser_utils/custom_script.js
+   ```
+
+### Docker Compose 挂载配置
+
+在 `docker-compose.yml` 中，您可以取消注释以下行来挂载自定义文件：
+
+```yaml
+volumes:
+  # 挂载自定义模型配置
+  - ../browser_utils/model_configs.json:/app/browser_utils/model_configs.json:ro
+  # 挂载自定义脚本目录
+  - ../browser_utils/custom_scripts:/app/browser_utils/custom_scripts:ro
+```
+
+### 注意事项
+
+- 脚本或配置文件更新后需要重启容器
+- 如果脚本注入失败，不会影响主要功能
+- 可以通过容器日志查看脚本注入状态
+
+## 注意事项
+
+1. **认证文件**: Docker 部署需要预先在主机上获取有效的认证文件，并将其放置在 `auth_profiles/active/` 目录中。
+2. **模块化架构**: 项目采用模块化设计，所有配置和代码都已经过优化，无需手动修改。
+3. **端口配置**: 确保宿主机上的端口未被占用，默认使用 2048 (主服务) 和 3120 (流式代理)。
+4. **日志查看**: 可以通过 `docker logs` 命令查看容器运行日志，便于调试和监控。
+5. **脚本注入**: 新增的脚本注入功能默认启用，可通过 `ENABLE_SCRIPT_INJECTION=false` 禁用。
+
+## 配置管理总结 ⭐
+
+### 新功能：统一的 .env 配置
+
+现在 Docker 部署完全支持 `.env` 文件配置管理：
+
+✅ **统一配置**: 使用 `.env` 文件管理所有配置
+✅ **版本更新无忧**: `git pull` + `docker compose up -d` 即可完成更新
+✅ **配置隔离**: 开发、测试、生产环境可使用不同的 `.env` 文件
+✅ **安全性**: `.env` 文件不会被提交到版本控制
+
+### 推荐的 Docker 工作流程
+
+```bash
+# 1. 初始设置
+git clone <repository>
+cd <project>/docker
+cp .env.docker .env
+# 编辑 .env 文件
+
+# 2. 启动服务
+docker compose up -d
+
+# 3. 版本更新
+bash update.sh
+
+# 4. 查看状态
+docker compose ps
+docker compose logs -f
+```
+
+### 配置文件说明
+
+- **`.env`**: 您的实际配置文件 (从 `.env.docker` 复制并修改)
+- **`.env.docker`**: Docker 环境的配置模板
+- **`.env.example`**: 通用配置模板 (适用于所有环境)
+- **`docker-compose.yml`**: Docker Compose 配置文件
+
+这样的配置管理方式确保了 Docker 部署与本地开发的一致性���同时简化了配置和更新流程。

AIStudioProxyAPI/docker/README.md

@@ -0,0 +1,77 @@
+# Docker 部署文件
+
+这个目录包含了 AI Studio Proxy API 项目的所有 Docker 相关文件。
+
+## 📁 文件说明
+
+- **`Dockerfile`** - Docker 镜像构建文件
+- **`docker-compose.yml`** - Docker Compose 配置文件
+- **`.env.docker`** - Docker 环境配置模板
+- **`README-Docker.md`** - 详细的 Docker 部署指南
+
+## 🚀 快速开始
+
+### 1. 准备配置文件
+
+```bash
+# 进入 docker 目录
+cp .env.docker .env
+nano .env  # 编辑配置文件
+```
+
+### 2. 启动服务
+
+```bash
+# 进入 docker 目录
+cd docker
+
+# 构建并启动服务
+docker compose up -d
+
+# 查看日志
+docker compose logs -f
+```
+
+### 3. 版本更新
+
+```bash
+# 在 docker 目录下
+bash update.sh
+```
+
+## 📖 详细文档
+
+完整的 Docker 部署指南请参见：[README-Docker.md](README-Docker.md)
+
+## 🔧 常用命令
+
+```bash
+# 查看服务状态
+docker compose ps
+
+# 查看日志
+docker compose logs -f
+
+# 停止服务
+docker compose down
+
+# 重启服务
+docker compose restart
+
+# 进入容器
+docker compose exec ai-studio-proxy /bin/bash
+```
+
+## 🌟 主要优势
+
+- ✅ **统一配置**: 使用 `.env` 文件管理所有配置
+- ✅ **版本更新无忧**: `bash update.sh` 即可完成更新
+- ✅ **环境隔离**: 容器化部署，避免环境冲突
+- ✅ **配置持久化**: 认证文件和日志持久化存储
+
+## ⚠️ 注意事项
+
+1. **认证文件**: 首次运行需要在主机上获取认证文件
+2. **端口配置**: 确保主机端口未被占用
+3. **配置文件**: `.env` 文件需要放在 `docker/` 目录下，确保正确获取环境变量
+4. **目录结构**: Docker 文件已移至 `docker/` 目录，保持项目根目录整洁

AIStudioProxyAPI/docker/SCRIPT_INJECTION_DOCKER.md

@@ -0,0 +1,209 @@
+# Docker 环境脚本注入配置指南
+
+## 概述
+
+本指南专门针对 Docker 环境中的油猴脚本注入功能配置。
+
+## 快速开始
+
+### 1. 基础配置
+
+```bash
+# 进入 docker 目录
+cd docker
+
+# 复制配置模板
+cp .env.docker .env
+
+# 编辑配置文件
+nano .env
+```
+
+在 `.env` 文件中确保以下配置：
+
+```env
+# 启用脚本注入
+ENABLE_SCRIPT_INJECTION=true
+
+# 使用默认脚本（模型数据直接从脚本解析）
+USERSCRIPT_PATH=browser_utils/more_modles.js
+```
+
+### 2. 启动容器
+
+```bash
+# 构建并启动
+docker compose up -d
+
+# 查看日志确认脚本注入状态
+docker compose logs -f | grep "脚本注入"
+```
+
+## 自定义配置
+
+### 方法 1: 直接替换脚本文件
+
+```bash
+# 1. 创建自定义油猴脚本
+cp ../browser_utils/more_modles.js ../browser_utils/my_custom_script.js
+
+# 2. 编辑脚本文件中的 MODELS_TO_INJECT 数组
+nano ../browser_utils/my_custom_script.js
+
+# 3. 重启容器
+docker compose restart
+```
+
+### 方法 2: 挂载自定义脚本
+
+```bash
+# 1. 创建自定义脚本文件
+cp ../browser_utils/more_modles.js ../browser_utils/my_script.js
+
+# 2. 编辑 docker-compose.yml，取消注释并修改：
+# volumes:
+#   - ../browser_utils/my_script.js:/app/browser_utils/more_modles.js:ro
+
+# 3. 重启服务
+docker compose down
+docker compose up -d
+```
+
+### 方法 3: 环境变量配置
+
+```bash
+# 1. 在 .env 文件中修改路径
+echo "USERSCRIPT_PATH=browser_utils/my_custom_script.js" >> .env
+
+# 2. 创建对应的脚本文件
+cp ../browser_utils/more_modles.js ../browser_utils/my_custom_script.js
+
+# 3. 重启容器
+docker compose restart
+```
+
+## 验证脚本注入
+
+### 检查日志
+
+```bash
+# 查看脚本注入相关日志
+docker compose logs | grep -E "(脚本注入|script.*inject|模型增强)"
+
+# 实时监控日志
+docker compose logs -f | grep -E "(脚本注入|script.*inject|模型增强)"
+```
+
+### 预期日志输出
+
+成功的脚本注入应该显示类似以下日志：
+
+```
+设置网络拦截和脚本注入...
+成功设置模型列表网络拦截
+成功解析 6 个模型从油猴脚本
+添加了 6 个注入的模型到API模型列表
+✅ 脚本注入成功，模型显示效果与油猴脚本100%一致
+   解析的模型: 👑 Kingfall, ✨ Gemini 2.5 Pro, 🦁 Goldmane...
+```
+
+### 进入容器检查
+
+```bash
+# 进入容器
+docker compose exec ai-studio-proxy /bin/bash
+
+# 检查脚本文件
+cat /app/browser_utils/more_modles.js
+
+# 检查脚本文件列表
+ls -la /app/browser_utils/*.js
+
+# 退出容器
+exit
+```
+
+## 故障排除
+
+### 脚本注入失败
+
+1. **检查配置文件路径**：
+   ```bash
+   docker compose exec ai-studio-proxy ls -la /app/browser_utils/
+   ```
+
+2. **检查文件权限**：
+   ```bash
+   docker compose exec ai-studio-proxy cat /app/browser_utils/more_modles.js
+   ```
+
+3. **查看详细错误日志**：
+   ```bash
+   docker compose logs | grep -A 5 -B 5 "脚本注入"
+   ```
+
+### 脚本文件无效
+
+1. **验证 JavaScript 格式**：
+   ```bash
+   # 在主机上验证 JavaScript 语法
+   node -c browser_utils/more_modles.js
+   ```
+
+2. **检查必需字段**：
+   确保每个模型都有 `name` 和 `displayName` 字段。
+
+### 禁用脚本注入
+
+如果遇到问题，可以临时禁用：
+
+```bash
+# 在 .env 文件中设置
+echo "ENABLE_SCRIPT_INJECTION=false" >> .env
+
+# 重启容器
+docker compose restart
+```
+
+## 高级配置
+
+### 使用自定义脚本
+
+```bash
+# 1. 将自定义脚本放在 browser_utils/ 目录
+cp your_custom_script.js ../browser_utils/custom_injector.js
+
+# 2. 在 .env 中修改脚本路径
+echo "USERSCRIPT_PATH=browser_utils/custom_injector.js" >> .env
+
+# 3. 重启容器
+docker compose restart
+```
+
+### 多环境配置
+
+```bash
+# 开发环境
+cp .env.docker .env.dev
+# 编辑 .env.dev
+
+# 生产环境
+cp .env.docker .env.prod
+# 编辑 .env.prod
+
+# 使用特定环境启动
+cp .env.prod .env
+docker compose up -d
+```
+
+## 注意事项
+
+1. **文件挂载**: 确保主机上的文件路径正确
+2. **权限问题**: Docker 容器内的文件权限可能需要调整
+3. **重启生效**: 配置更改后需要重启容器
+4. **日志监控**: 通过日志确认脚本注入状态
+5. **备份配置**: 建议备份工作的配置文件
+
+## 示例配置文件
+
+参考 `model_configs_docker_example.json` 文件了解完整的配置格式和选项。

AIStudioProxyAPI/docker/docker-compose.yml

@@ -0,0 +1,56 @@
+services:
+  ai-studio-proxy:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile
+    container_name: ai-studio-proxy-container
+    mem_limit: ${DOCKER_MEMORY_LIMIT:-0}
+    memswap_limit: ${DOCKER_MEMSWAP_LIMIT:-0}
+    ports:
+      - "${HOST_FASTAPI_PORT:-2048}:${DEFAULT_FASTAPI_PORT:-2048}"
+      - "${HOST_STREAM_PORT:-3120}:${STREAM_PORT:-3120}"
+    volumes:
+      # 挂载认证文件目录 (必需)
+      - ../auth_profiles:/app/auth_profiles
+      # 挂载 .env 配置文件 (推荐)
+      # 请将 docker/.env.docker 复制为 docker/.env 并根据需要修改
+      - ../docker/.env:/app/.env:ro
+      # 挂载日志目录 (可选，用于持久化日志)
+      # 如果出现权限报错，需要修改日志目录权限 sudo chmod -R 777 ../logs
+      # - ../logs:/app/logs
+      # 挂载自定义证书 (可选)
+      # - ../certs:/app/certs:ro
+      # 挂载脚本注入相关文件 (可选，用于自定义脚本和模型配置)
+      # 如果您有自定义的油猴脚本或模型配置，可以取消注释以下行
+      # - ../browser_utils/custom_scripts:/app/browser_utils/custom_scripts:ro
+      # - ../browser_utils/model_configs.json:/app/browser_utils/model_configs.json:ro
+    environment:
+      # 这些环境变量会覆盖 .env 文件中的设置
+      # 如果您想使用 .env 文件，可以注释掉这些行
+      - PYTHONUNBUFFERED=1
+      # - PORT=${PORT:-8000}
+      # - DEFAULT_FASTAPI_PORT=${DEFAULT_FASTAPI_PORT:-2048}
+      # - DEFAULT_CAMOUFOX_PORT=${DEFAULT_CAMOUFOX_PORT:-9222}
+      # - STREAM_PORT=${STREAM_PORT:-3120}
+      # - SERVER_LOG_LEVEL=${SERVER_LOG_LEVEL:-INFO}
+      # - DEBUG_LOGS_ENABLED=${DEBUG_LOGS_ENABLED:-false}
+      # - AUTO_CONFIRM_LOGIN=${AUTO_CONFIRM_LOGIN:-true}
+      # 代理配置 (可选)
+      # - HTTP_PROXY=${HTTP_PROXY}
+      # - HTTPS_PROXY=${HTTPS_PROXY}
+      # - UNIFIED_PROXY_CONFIG=${UNIFIED_PROXY_CONFIG}
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:${DEFAULT_FASTAPI_PORT:-2048}/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    # 可选：如果需要特定的网络配置
+    # networks:
+    #   - ai-studio-network
+
+# 可选：自定义网络
+# networks:
+#   ai-studio-network:
+#     driver: bridge

AIStudioProxyAPI/docker/update.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# 定义颜色变量以便复用
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+set -e
+
+echo -e "${GREEN}==> 正在更新并重启服务...${NC}"
+
+# 获取脚本所在的目录，并切换到项目根目录
+SCRIPT_DIR=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null && pwd)
+cd "$SCRIPT_DIR/.."
+
+echo -e "${YELLOW}--> 步骤 1/4: 拉取最新的代码...${NC}"
+git pull
+
+cd "$SCRIPT_DIR"
+
+echo -e "${YELLOW}--> 步骤 2/4: 停止并移除旧的容器...${NC}"
+docker compose down
+
+echo -e "${YELLOW}--> 步骤 3/4: 使用 Docker Compose 构建并启动新容器...${NC}"
+docker compose up -d --build
+
+echo -e "${YELLOW}--> 步骤 4/4: 显示当前运行的容器状态...${NC}"
+docker compose ps
+
+echo -e "${GREEN}==> 更新完成！${NC}"

AIStudioProxyAPI/docs/advanced-configuration.md

@@ -0,0 +1,356 @@
+# 高级配置指南
+
+本文档介绍项目的高级配置选项和功能。
+
+## 代理配置管理
+
+### 代理配置优先级
+
+项目采用统一的代理配置管理系统，按以下优先级顺序确定代理设置：
+
+1. **`--internal-camoufox-proxy` 命令行参数** (最高优先级)
+   - 明确指定代理：`--internal-camoufox-proxy 'http://127.0.0.1:7890'`
+   - 明确禁用代理：`--internal-camoufox-proxy ''`
+2. **`UNIFIED_PROXY_CONFIG` 环境变量** (推荐，.env 文件配置)
+3. **`HTTP_PROXY` 环境变量**
+4. **`HTTPS_PROXY` 环境变量**
+5. **系统代理设置** (Linux 下的 gsettings，最低优先级)
+
+**推荐配置方式**:
+```env
+# .env 文件中统一配置代理
+UNIFIED_PROXY_CONFIG=http://127.0.0.1:7890
+# 或禁用代理
+UNIFIED_PROXY_CONFIG=
+```
+
+### 统一代理配置
+
+此代理配置会同时应用于 Camoufox 浏览器和流式代理服务的上游连接，确保整个系统的代理行为一致。
+
+## 响应获取模式配置
+
+### 模式1: 优先使用集成的流式代理 (默认推荐)
+
+**推荐使用 .env 配置方式**:
+```env
+# .env 文件配置
+DEFAULT_FASTAPI_PORT=2048
+STREAM_PORT=3120
+UNIFIED_PROXY_CONFIG=
+```
+
+```bash
+# 简化启动命令 (推荐)
+python launch_camoufox.py --headless
+
+# 传统命令行方式 (仍然支持)
+python launch_camoufox.py --headless --server-port 2048 --stream-port 3120 --helper '' --internal-camoufox-proxy ''
+```
+
+# 启用统一代理配置（同时应用于浏览器和流式代理）
+python launch_camoufox.py --headless --server-port 2048 --stream-port 3120 --helper '' --internal-camoufox-proxy 'http://127.0.0.1:7890'
+```
+
+在此模式下，主服务器会优先尝试通过端口 `3120` (或指定的 `--stream-port`) 上的集成流式代理获取响应。如果失败，则回退到 Playwright 页面交互。
+
+### 模式2: 优先使用外部 Helper 服务 (禁用集成流式代理)
+
+```bash
+# 基本外部Helper模式，明确禁用代理
+python launch_camoufox.py --headless --server-port 2048 --stream-port 0 --helper 'http://your-helper-service.com/api/getStreamResponse' --internal-camoufox-proxy ''
+
+# 外部Helper模式 + 统一代理配置
+python launch_camoufox.py --headless --server-port 2048 --stream-port 0 --helper 'http://your-helper-service.com/api/getStreamResponse' --internal-camoufox-proxy 'http://127.0.0.1:7890'
+```
+
+在此模式下，主服务器会优先尝试通过 `--helper` 指定的端点获取响应 (需要有效的 `auth_profiles/active/*.json` 以提取 `SAPISID`)。如果失败，则回退到 Playwright 页面交互。
+
+### 模式3: 仅使用 Playwright 页面交互 (禁用所有流式代理和 Helper)
+
+```bash
+# 纯Playwright模式，明确禁用代理
+python launch_camoufox.py --headless --server-port 2048 --stream-port 0 --helper '' --internal-camoufox-proxy ''
+
+# Playwright模式 + 统一代理配置
+python launch_camoufox.py --headless --server-port 2048 --stream-port 0 --helper '' --internal-camoufox-proxy 'http://127.0.0.1:7890'
+```
+
+在此模式下，主服务器将仅通过 Playwright 与 AI Studio 页面交互 (模拟点击"编辑"或"复制"按钮) 来获取响应。这是传统的后备方法。
+
+## 虚拟显示模式 (Linux)
+
+### 关于 `--virtual-display`
+
+- **为什么使用**: 与标准的无头模式相比，虚拟显示模式通过创建一个完整的虚拟 X 服务器环境 (Xvfb) 来运行浏览器。这可以模拟一个更真实的桌面环境，从而可能进一步降低被网站检测为自动化脚本或机器人的风险
+- **什么时候使用**: 当您在 Linux 环境下运行，并且希望以无头模式操作
+- **如何使用**:
+  1. 确保您的 Linux 系统已安装 `xvfb`
+  2. 在运行时添加 `--virtual-display` 标志：
+     ```bash
+     python launch_camoufox.py --virtual-display --server-port 2048 --stream-port 3120 --internal-camoufox-proxy ''
+     ```
+
+## 流式代理服务配置
+
+### 自签名证书管理
+
+集成的流式代理服务会在 `certs` 文件夹内生成自签名的根证书。
+
+#### 证书删除与重新生成
+
+- 可以删除 `certs` 目录下的根证书 (`ca.crt`, `ca.key`)，代码会在下次启动时重新生成
+- **重要**: 删除根证书时，**强烈建议同时删除 `certs` 目录下的所有其他文件**，避免信任链错误
+
+#### 手动生成证书
+
+如果需要重新生成证书，可以使用以下命令：
+
+```bash
+openssl genrsa -out certs/ca.key 2048
+openssl req -new -x509 -days 3650 -key certs/ca.key -out certs/ca.crt -subj "/C=CN/ST=Shanghai/L=Shanghai/O=AiStudioProxyHelper/OU=CA/CN=AiStudioProxyHelper CA/emailAddress=ca@example.com"
+openssl rsa -in certs/ca.key -out certs/ca.key
+```
+
+### 工作原理
+
+流式代理服务的特性：
+
+- 创建一个 HTTP 代理服务器（默认端口：3120）
+- 拦截针对 Google 域名的 HTTPS 请求
+- 使用自签名 CA 证书动态自动生成服务器证书
+- 将 AIStudio 响应解析为 OpenAI 兼容格式
+
+## 模型排除配置
+
+### excluded_models.txt
+
+项目根目录下的 `excluded_models.txt` 文件可用于从 `/v1/models` 端点返回的列表中排除特定的模型 ID。
+
+每行一个模型ID，例如：
+```
+gemini-1.0-pro
+gemini-1.0-pro-vision
+deprecated-model-id
+```
+
+## 脚本注入高级配置 🆕
+
+### 概述
+
+脚本注入功能允许您动态挂载油猴脚本来增强 AI Studio 的模型列表。该功能使用 Playwright 原生网络拦截技术，确保 100% 可靠性。
+
+### 工作原理
+
+1. **双重拦截机制**：
+   - **Playwright 路由拦截**：在网络层面直接拦截和修改模型列表响应
+   - **JavaScript 脚本注入**：作为备用方案，确保万无一失
+
+2. **自动模型解析**：
+   - 从油猴脚本中自动解析 `MODELS_TO_INJECT` 数组
+   - 前端和后端使用相同的模型数据源
+   - 无需手动维护模型配置文件
+
+### 高级配置选项
+
+#### 自定义脚本路径
+
+```env
+# 使用自定义脚本文件
+USERSCRIPT_PATH=custom_scripts/my_enhanced_script.js
+```
+
+#### 自定义脚本配置
+
+```env
+# 使用自定义脚本文件（模型数据直接从脚本解析）
+USERSCRIPT_PATH=configs/production_script.js
+```
+
+#### 调试模式
+
+```env
+# 启用详细的脚本注入日志
+DEBUG_LOGS_ENABLED=true
+ENABLE_SCRIPT_INJECTION=true
+```
+
+### 自定义脚本开发
+
+#### 脚本格式要求
+
+您的自定义脚本必须包含 `MODELS_TO_INJECT` 数组：
+
+```javascript
+const MODELS_TO_INJECT = [
+    {
+        name: 'models/your-custom-model',
+        displayName: '🚀 Your Custom Model',
+        description: 'Custom model description'
+    },
+    // 更多模型...
+];
+```
+
+#### 脚本模型数组格式
+
+```javascript
+const MODELS_TO_INJECT = [
+    {
+        name: 'models/custom-model-1',
+        displayName: `🎯 Custom Model 1 (Script ${SCRIPT_VERSION})`,
+        description: `First custom model injected by script ${SCRIPT_VERSION}`
+    },
+    {
+        name: 'models/custom-model-2',
+        displayName: `⚡ Custom Model 2 (Script ${SCRIPT_VERSION})`,
+        description: `Second custom model injected by script ${SCRIPT_VERSION}`
+    }
+];
+```
+```
+
+### 网络拦截技术细节
+
+#### Playwright 路由拦截
+
+```javascript
+// 系统会自动设置类似以下的路由拦截
+await context.route("**/*", async (route) => {
+    const request = route.request();
+    if (request.url().includes('alkalimakersuite') &&
+        request.url().includes('ListModels')) {
+        // 拦截并修改模型列表响应
+        const response = await route.fetch();
+        const modifiedBody = await modifyModelListResponse(response);
+        await route.fulfill({ response, body: modifiedBody });
+    } else {
+        await route.continue_();
+    }
+});
+```
+
+#### 响应修改流程
+
+1. **请求识别**：检测包含 `alkalimakersuite` 和 `ListModels` 的请求
+2. **响应获取**：获取原始模型列表响应
+3. **数据解析**：解析 JSON 响应并处理反劫持前缀
+4. **模型注入**：将自定义模型注入到响应中
+5. **响应返回**：返回修改后的响应给浏览器
+
+### 故障排除
+
+#### 脚本注入失败
+
+1. **检查脚本文件**：
+   ```bash
+   # 验证脚本文件存在且可读
+   ls -la browser_utils/more_modles.js
+   cat browser_utils/more_modles.js | head -20
+   ```
+
+2. **检查日志输出**：
+   ```bash
+   # 查看脚本注入相关日志
+   python launch_camoufox.py --debug | grep -i "script\|inject"
+   ```
+
+3. **验证配置**：
+   ```bash
+   # 检查环境变量配置
+   grep SCRIPT .env
+   ```
+
+#### 模型未显示
+
+1. **前端检查**：在浏览器开发者工具中查看是否有 JavaScript 错误
+2. **后端检查**：查看 API 响应是否包含注入的模型
+3. **网络检查**：确认网络拦截是否正常工作
+
+### 性能优化
+
+#### 脚本缓存
+
+系统会自动缓存解析的模型列表，避免重复解析：
+
+```python
+# 系统内部缓存机制
+if not hasattr(self, '_cached_models'):
+    self._cached_models = parse_userscript_models(script_content)
+return self._cached_models
+```
+
+#### 网络拦截优化
+
+- 只拦截必要的请求，其他请求直接通过
+- 使用高效的 JSON 解析和序列化
+- 最小化响应修改的开销
+
+### 安全考虑
+
+#### 脚本安全
+
+- 脚本在受控的浏览器环境中执行
+- 不会影响主机系统安全
+- 建议只使用可信的脚本源
+
+#### 网络安全
+
+- 网络拦截仅限于特定的模型列表请求
+- 不会拦截或修改其他敏感请求
+- 所有修改都在本地进行，不会发送到外部服务器
+
+## GUI 启动器高级功能
+
+### 本地LLM模拟服务
+
+GUI 集成了启动和管理一个本地LLM模拟服务的功能：
+
+- **功能**: 监听 `11434` ���口，模拟部分 Ollama API 端点和 OpenAI 兼容的 `/v1/chat/completions` 端点
+- **启动**: 在 GUI 的"启动选项"区域，点击"启动本地LLM模拟服务"按钮
+- **依赖检测**: 启动前会自动检测 `localhost:2048` 端口是否可用
+- **用途**: 主要用于测试客户端与 Ollama 或 OpenAI 兼容 API 的对接
+
+### 端口进程管理
+
+GUI 提供端口进程管理功能：
+
+- 查询指定端口上当前正在运行的进程
+- 选择并尝试停止在指定端口上找到的进程
+- 手动输入 PID 终止进程
+
+## 环境变量配置
+
+### 代理配置
+
+```bash
+# 使用环境变量配置代理（不推荐，建议明确指定）
+export HTTP_PROXY=http://127.0.0.1:7890
+export HTTPS_PROXY=http://127.0.0.1:7890
+python launch_camoufox.py --headless --server-port 2048 --stream-port 3120 --helper ''
+```
+
+### 日志控制
+
+详见 [日志控制指南](logging-control.md)。
+
+## 重要提示
+
+### 代理配置建议
+
+**强烈建议在所有 `launch_camoufox.py` 命令中明确指定 `--internal-camoufox-proxy` 参数，即使其值为空字符串 (`''`)，以避免意外使用系统环境变量中的代理设置。**
+
+### 参数控制限制
+
+API 请求中的模型参数（如 `temperature`, `max_output_tokens`, `top_p`, `stop`）**仅在通过 Playwright 页面交互获取响应时生效**。当使用集成的流式代理或外部 Helper 服务时，这些参数的传递和应用方式取决于这些服务自身的实现。
+
+### 首次访问性能
+
+当通过流式代理首次访问一个新的 HTTPS 主机时，服务需要为该主机动态生成并签署一个新的子证书。这个过程可能会比较耗时，导致对该新主机的首次连接请求响应较慢。一旦证书生成并缓存后，后续访问同一主机将会显著加快。
+
+## 下一步
+
+高级配置完成后，请参考：
+- [脚本注入指南](script_injection_guide.md) - 详细的脚本注入功能使用说明
+- [日志控制指南](logging-control.md)
+- [故障排除指南](troubleshooting.md)

AIStudioProxyAPI/docs/api-usage.md

@@ -0,0 +1,415 @@
+# API 使用指南
+
+本指南详细介绍如何使用 AI Studio Proxy API 的各种功能和端点。
+
+## 服务器配置
+
+代理服务器默认监听在 `http://127.0.0.1:2048`。端口可以通过以下方式配置：
+
+- **环境变量**: 在 `.env` 文件中设置 `PORT=2048` 或 `DEFAULT_FASTAPI_PORT=2048`
+- **命令行参数**: 使用 `--server-port` 参数
+- **GUI 启动器**: 在图形界面中直接配置端口
+
+推荐使用 `.env` 文件进行配置管理，详见 [环境变量配置指南](environment-configuration.md)。
+
+## API 密钥配置
+
+### key.txt 文件配置
+
+项目使用 `auth_profiles/key.txt` 文件来管理 API 密钥：
+
+**文件位置**: 项目根目录下的 `key.txt` 文件
+
+**文件格式**: 每行一个 API 密钥，支持空行和注释
+
+```
+your-api-key-1
+your-api-key-2
+# 这是注释行，会被忽略
+
+another-api-key
+```
+
+**自动创建**: 如果 `key.txt` 文件不存在，系统会自动创建一个空文件
+
+### 密钥管理方法
+
+#### 手动编辑文件
+
+直接编辑 `key.txt` 文件添加或删除密钥：
+
+```bash
+# 添加密钥
+echo "your-new-api-key" >> key.txt
+
+# 查看当前密钥（注意安全）
+cat key.txt
+```
+
+#### 通过 Web UI 管理
+
+在 Web UI 的"设置"标签页中可以：
+
+- 验证密钥有效性
+- 查看服务器上配置的密钥列表（需要先验证）
+- 测试特定密钥
+
+### 密钥验证机制
+
+**验证逻辑**:
+
+- 如果 `key.txt` 为空或不存在，则不需要 API 密钥验证
+- 如果配置了密钥，则所有 API 请求都需要提供有效的密钥
+- 密钥验证支持两种认证头格式
+
+**安全特性**:
+
+- 密钥在日志中会被打码显示（如：`abcd****efgh`）
+- Web UI 中的密钥列表也会打码显示
+- 支持最小长度验证（至少 8 个字符）
+
+## API 认证流程
+
+### Bearer Token 认证
+
+项目支持标准的 OpenAI 兼容认证方式：
+
+**主要认证方式** (推荐):
+
+```bash
+Authorization: Bearer your-api-key
+```
+
+**备用认证方式** (向后兼容):
+
+```bash
+X-API-Key: your-api-key
+```
+
+### 认证行为
+
+**无密钥配置时**:
+
+- 所有 API 请求都不需要认证
+- `/api/info` 端点会显示 `"api_key_required": false`
+
+**有密钥配置时**:
+
+- 所有 `/v1/*` 路径的 API 请求都需要有效的密钥
+- 除外路径：`/v1/models`, `/health`, `/docs` 等公开端点
+- 认证失败返回 `401 Unauthorized` 错误
+
+### 客户端配置示例
+
+#### curl 示例
+
+```bash
+# 使用 Bearer token
+curl -X POST http://127.0.0.1:2048/v1/chat/completions \
+  -H "Authorization: Bearer your-api-key" \
+  -H "Content-Type: application/json" \
+  -d '{"messages": [{"role": "user", "content": "Hello"}]}'
+
+# 使用 X-API-Key 头
+curl -X POST http://127.0.0.1:2048/v1/chat/completions \
+  -H "X-API-Key: your-api-key" \
+  -H "Content-Type: application/json" \
+  -d '{"messages": [{"role": "user", "content": "Hello"}]}'
+```
+
+#### Python requests 示例
+
+```python
+import requests
+
+headers = {
+    "Authorization": "Bearer your-api-key",
+    "Content-Type": "application/json"
+}
+
+data = {
+    "messages": [{"role": "user", "content": "Hello"}]
+}
+
+response = requests.post(
+    "http://127.0.0.1:2048/v1/chat/completions",
+    headers=headers,
+    json=data
+)
+```
+
+## API 端点
+
+### 聊天接口
+
+**端点**: `POST /v1/chat/completions`
+
+- 请求体与 OpenAI API 兼容，需要 `messages` 数组。
+- `model` 字段现在用于指定目标模型，代理会尝试在 AI Studio 页面切换到该模型。如果为空或为代理的默认模型名，则使用 AI Studio 当前激活的模型。
+- `stream` 字段控制流式 (`true`) 或非流式 (`false`) 输出。
+- 现在支持 `temperature`, `max_output_tokens`, `top_p`, `stop` 等参数，代理会尝试在 AI Studio 页面上应用它们。
+- **需要认证**: 如果配置了 API 密钥，此端点需要有效的认证头。
+
+#### 示例 (curl, 非流式, 带参数)
+
+```bash
+curl -X POST http://127.0.0.1:2048/v1/chat/completions \
+-H "Content-Type: application/json" \
+-d '{
+  "model": "gemini-1.5-pro-latest",
+  "messages": [
+    {"role": "system", "content": "Be concise."},
+    {"role": "user", "content": "What is the capital of France?"}
+  ],
+  "stream": false,
+  "temperature": 0.7,
+  "max_output_tokens": 150,
+  "top_p": 0.9,
+  "stop": ["\n\nUser:"]
+}'
+```
+
+#### 示例 (curl, 流式, 带参数)
+
+```bash
+curl -X POST http://127.0.0.1:2048/v1/chat/completions \
+-H "Content-Type: application/json" \
+-d '{
+  "model": "gemini-pro",
+  "messages": [
+    {"role": "user", "content": "Write a short story about a cat."}
+  ],
+  "stream": true,
+  "temperature": 0.9,
+  "top_p": 0.95,
+  "stop": []
+}' --no-buffer
+```
+
+#### 示例 (Python requests)
+
+```python
+import requests
+import json
+
+API_URL = "http://127.0.0.1:2048/v1/chat/completions"
+headers = {"Content-Type": "application/json"}
+data = {
+    "model": "gemini-1.5-flash-latest",
+    "messages": [
+        {"role": "user", "content": "Translate 'hello' to Spanish."}
+    ],
+    "stream": False, # or True for streaming
+    "temperature": 0.5,
+    "max_output_tokens": 100,
+    "top_p": 0.9,
+    "stop": ["\n\nHuman:"]
+}
+
+response = requests.post(API_URL, headers=headers, json=data, stream=data["stream"])
+
+if data["stream"]:
+    for line in response.iter_lines():
+        if line:
+            decoded_line = line.decode('utf-8')
+            if decoded_line.startswith('data: '):
+                content = decoded_line[len('data: '):]
+                if content.strip() == '[DONE]':
+                    print("\nStream finished.")
+                    break
+                try:
+                    chunk = json.loads(content)
+                    delta = chunk.get('choices', [{}])[0].get('delta', {})
+                    print(delta.get('content', ''), end='', flush=True)
+                except json.JSONDecodeError:
+                    print(f"\nError decoding JSON: {content}")
+            elif decoded_line.startswith('data: {'): # Handle potential error JSON
+                try:
+                    error_data = json.loads(decoded_line[len('data: '):])
+                    if 'error' in error_data:
+                        print(f"\nError from server: {error_data['error']}")
+                        break
+                except json.JSONDecodeError:
+                     print(f"\nError decoding error JSON: {decoded_line}")
+else:
+    if response.status_code == 200:
+        print(json.dumps(response.json(), indent=2))
+    else:
+        print(f"Error: {response.status_code}\n{response.text}")
+```
+
+### 模型列表
+
+**端点**: `GET /v1/models`
+
+- 返回 AI Studio 页面上检测到的可用模型列表，以及一个代理本身的默认模型条目。
+- 现在会尝试从 AI Studio 动态获取模型列表。如果获取失败，会返回一个后备模型。
+- 支持 [`excluded_models.txt`](../excluded_models.txt) 文件，用于从列表中排除特定的模型 ID。
+- **🆕 脚本注入模型**: 如果启用了脚本注入功能，列表中还会包含通过油猴脚本注入的自定义模型，这些模型会标记为 `"injected": true`。
+
+**脚本注入模型特点**:
+
+- 模型 ID 格式：注入的模型会自动移除 `models/` 前缀，如 `models/kingfall-ab-test` 变为 `kingfall-ab-test`
+- 标识字段：包含 `"injected": true` 字段用于识别
+- 所有者标识：`"owned_by": "ai_studio_injected"`
+- 完全兼容：可以像普通模型一样通过 API 调用
+
+**示例响应**:
+
+```json
+{
+  "object": "list",
+  "data": [
+    {
+      "id": "kingfall-ab-test",
+      "object": "model",
+      "created": 1703123456,
+      "owned_by": "ai_studio_injected",
+      "display_name": "👑 Kingfall",
+      "description": "Kingfall model - Advanced reasoning capabilities",
+      "injected": true
+    }
+  ]
+}
+```
+
+### API 信息
+
+**端点**: `GET /api/info`
+
+- 返回 API 配置信息，如基础 URL 和模型名称。
+
+### 健康检查
+
+**端点**: `GET /health`
+
+- 返回服务器运行状态（Playwright, 浏览器连接, 页面状态, Worker 状态, 队列长度）。
+
+### 队列状态
+
+**端点**: `GET /v1/queue`
+
+- 返回当前请求队列的详细信息。
+
+### 取消请求
+
+**端点**: `POST /v1/cancel/{req_id}`
+
+- 尝试取消仍在队列中等待处理的请求。
+
+### API 密钥管理端点
+
+#### 获取密钥列表
+
+**端点**: `GET /api/keys`
+
+- 返回服务器上配置的所有 API 密钥列表
+- **注意**: 服务器返回完整密钥，打码显示由 Web UI 前端处理
+- **无需认证**: 此端点不需要 API 密钥认证
+
+#### 测试密钥
+
+**端点**: `POST /api/keys/test`
+
+- 验证指定的 API 密钥是否有效
+- 请求体：`{"key": "your-api-key"}`
+- 返回：`{"success": true, "valid": true/false, "message": "..."}`
+- **无需认证**: 此端点不需要 API 密钥认证
+
+#### 添加密钥
+
+**端点**: `POST /api/keys`
+
+- 向服务器添加新的 API 密钥
+- 请求体：`{"key": "your-new-api-key"}`
+- 密钥要求：至少 8 个字符，不能重复
+- **无需认证**: 此端点不需要 API 密钥认证
+
+#### 删除密钥
+
+**端点**: `DELETE /api/keys`
+
+- 从服务器删除指定的 API 密钥
+- 请求体：`{"key": "key-to-delete"}`
+- **无需认证**: 此端点不需要 API 密钥认证
+
+## 配置客户端 (以 Open WebUI 为例)
+
+1. 打开 Open WebUI。
+2. 进入 "设置" -> "连接"。
+3. 在 "模型" 部分，点击 "添加模型"。
+4. **模型名称**: 输入你想要的名字，例如 `aistudio-gemini-py`。
+5. **API 基础 URL**: 输入代理服务器的地址，例如 `http://127.0.0.1:2048/v1` (如果服务器在另一台机器，用其 IP 替换 `127.0.0.1`，并确保端口可访问)。
+6. **API 密钥**: 留空或输入任意字符 (服务器不验证)。
+7. 保存设置。
+8. 现在，你应该可以在 Open WebUI 中选择你在第一步中配置的模型名称并开始聊天了。如果之前配置过，可能需要刷新或重新选择模型以应用新的 API 基地址。
+
+## 重要提示
+
+### 三层响应获取机制与参数控制
+
+- **响应获取优先级**: 项目采用三层响应获取机制，确保高可用性和最佳性能：
+
+  1. **集成流式代理服务 (Stream Proxy)**:
+     - 默认启用，监听端口 `3120` (可通过 `.env` 文件的 `STREAM_PORT` 配置)
+     - 提供最佳性能和稳定性，直接处理 AI Studio 请求
+     - 支持基础参数传递，无需浏览器交互
+  2. **外部 Helper 服务**:
+     - 可选配置，通过 `--helper <endpoint_url>` 参数或 `.env` 配置启用
+     - 需要有效的认证文件 (`auth_profiles/active/*.json`) 提取 `SAPISID` Cookie
+     - 作为流式代理的备用方案
+  3. **Playwright 页面交互**:
+     - 最终后备方案，通过浏览器自动化获取响应
+     - 支持完整的参数控制和模型切换
+     - 通过模拟用户操作（编辑/复制按钮）获取响应
+
+- **参数控制详解**:
+
+  - **流式代理模式**: 支持基础参数 (`model`, `temperature`, `max_tokens` 等)，性能最优
+  - **Helper 服务模式**: 参数支持取决于外部 Helper 服务的具体实现
+  - **Playwright 模式**: 完整支持所有参数，包括 `temperature`, `max_output_tokens`, `top_p`, `stop`, `reasoning_effort`, `tools` 等
+
+- **模型管理**:
+
+  - API 请求中的 `model` 字段用于在 AI Studio 页面切换模型
+  - 支持动态模型列表获取和模型 ID 验证
+  - [`excluded_models.txt`](../excluded_models.txt) 文件可排除特定模型 ID
+
+- **🆕 脚本注入功能 v3.0**:
+  - 使用 Playwright 原生网络拦截，100% 可靠性
+  - 直接从油猴脚本解析模型数据，无需配置文件维护
+  - 前后端模型数据完全同步，注入模型标记为 `"injected": true`
+  - 详见 [脚本注入指南](script_injection_guide.md)
+
+### 客户端管理历史
+
+**客户端管理历史，代理不支持 UI 内编辑**: 客户端负责维护完整的聊天记录并将其发送给代理。代理服务器本身不支持在 AI Studio 界面中对历史消息进行编辑或分叉操作；它总是处理客户端发送的完整消息列表，然后将其发送到 AI Studio 页面。
+
+## 兼容性说明
+
+### Python 版本兼容性
+
+- **推荐版本**: Python 3.10+ 或 3.11+ (生产环境推荐)
+- **最低要求**: Python 3.9 (所有功能完全支持)
+- **Docker 环境**: Python 3.10 (容器内默认版本)
+- **完全支持**: Python 3.9, 3.10, 3.11, 3.12, 3.13
+- **依赖管理**: 使用 Poetry 管理，确保版本一致性
+
+### API 兼容性
+
+- **OpenAI API**: 完全兼容 OpenAI v1 API 标准，支持所有主流客户端
+- **FastAPI**: 基于 0.115.12 版本，包含最新性能优化和功能增强
+- **HTTP 协议**: 支持 HTTP/1.1 和 HTTP/2，完整的异步处理
+- **认证方式**: 支持 Bearer Token 和 X-API-Key 头部认证，OpenAI 标准兼容
+- **流式响应**: 完整支持 Server-Sent Events (SSE) 流式输出
+- **FastAPI**: 基于 0.111.0 版本，支持现代异步特性
+- **HTTP 协议**: 支持 HTTP/1.1 和 HTTP/2
+- **认证方式**: 支持 Bearer Token 和 X-API-Key 头部认证
+
+## 下一步
+
+API 使用配置完成后，请参考：
+
+- [Web UI 使用指南](webui-guide.md)
+- [故障排除指南](troubleshooting.md)
+- [日志控制指南](logging-control.md)

AIStudioProxyAPI/docs/architecture-guide.md

@@ -0,0 +1,259 @@
+# 项目架构指南
+
+本文档详细介绍 AI Studio Proxy API 项目的模块化架构设计、组件职责和交互关系。
+
+## 🏗️ 整体架构概览
+
+项目采用现代化的模块化架构设计，遵循单一职责原则，确保代码的可维护性和可扩展性。
+
+### 核心设计原则
+
+- **模块化分离**: 按功能领域划分模块，避免循环依赖
+- **单一职责**: 每个模块专注于特定的功能领域
+- **配置统一**: 使用 `.env` 文件和 `config/` 模块统一管理配置
+- **依赖注入**: 通过 `dependencies.py` 管理组件依赖关系
+- **异步优先**: 全面采用异步编程模式，提升性能
+
+## 📁 模块结构详解
+
+```
+AIstudioProxyAPI/
+├── api_utils/              # FastAPI 应用核心模块
+│   ├── app.py             # FastAPI 应用入口和生命周期管理
+│   ├── routes.py          # API 路由定义和端点实现
+│   ├── request_processor.py # 请求处理核心逻辑
+│   ├── queue_worker.py    # 异步队列工作器
+│   ├── auth_utils.py      # API 密钥认证管理
+│   └── dependencies.py   # FastAPI 依赖注入
+├── browser_utils/          # 浏览器自动化模块
+│   ├── page_controller.py # 页面控制器和生命周期管理
+│   ├── model_management.py # AI Studio 模型管理
+│   ├── script_manager.py  # 脚本注入管理 (v3.0)
+│   ├── operations.py      # 浏览器操作封装
+│   └── initialization.py # 浏览器初始化逻辑
+├── config/                 # 配置管理模块
+│   ├── settings.py        # 主要设置和环境变量
+│   ├── constants.py       # 系统常量定义
+│   ├── timeouts.py        # 超时配置管理
+│   └── selectors.py       # CSS 选择器定义
+├── models/                 # 数据模型定义
+│   ├── chat.py           # 聊天相关数据模型
+│   ├── exceptions.py     # 自定义异常类
+│   └── logging.py        # 日志相关模型
+├── stream/                 # 流式代理服务模块
+│   ├── main.py           # 流式代理服务入口
+│   ├── proxy_server.py   # 代理服务器实现
+│   ├── interceptors.py   # 请求拦截器
+│   └── utils.py          # 流式处理工具
+├── logging_utils/          # 日志管理模块
+│   └── setup.py          # 日志系统配置
+└── node_stream/            # Node流式处理模块
+```
+
+## 🔧 核心模块详解
+
+### 1. api_utils/ - FastAPI 应用核心
+
+**职责**: FastAPI 应用的核心逻辑，包括路由、认证、请求处理等。
+
+#### app.py - 应用入口
+
+- FastAPI 应用创建和配置
+- 生命周期管理 (startup/shutdown)
+- 中间件配置 (API 密钥认证)
+- 全局状态初始化
+
+#### routes.py - API 路由
+
+- `/v1/chat/completions` - 聊天完成端点
+- `/v1/models` - 模型列表端点
+- `/api/keys/*` - API 密钥管理端点
+- `/health` - 健康检查端点
+- WebSocket 日志端点
+
+#### request_processor.py - 请求处理核心
+
+- 三层响应获取机制实现
+- 流式和非流式响应处理
+- 客户端断开检测
+- 错误处理和重试逻辑
+
+#### queue_worker.py - 队列工作器
+
+- 异步请求队列处理
+- 并发控制和资源管理
+- 请求优先级处理
+
+### 2. browser_utils/ - 浏览器自动化
+
+**职责**: 浏览器自动化、页面控制、脚本注入等功能。
+
+#### page_controller.py - 页面控制器
+
+- Camoufox 浏览器生命周期管理
+- 页面导航和状态监控
+- 认证文件管理
+
+#### script_manager.py - 脚本注入管理 (v3.0)
+
+- Playwright 原生网络拦截
+- 油猴脚本解析和注入
+- 模型数据同步
+
+#### model_management.py - 模型管理
+
+- AI Studio 模型列表获取
+- 模型切换和验证
+- 排除模型处理
+
+### 3. config/ - 配置管理
+
+**职责**: 统一的配置管理，包括环境变量、常量、超时等。
+
+#### settings.py - 主要设置
+
+- `.env` 文件加载
+- 环境变量解析
+- 配置验证和默认值
+
+#### constants.py - 系统常量
+
+- API 端点常量
+- 错误代码定义
+- 系统标识符
+
+### 4. stream/ - 流式代理服务
+
+**职责**: 独立的流式代理服务，提供高性能的请求转发。
+
+#### proxy_server.py - 代理服务器
+
+- HTTP/HTTPS 代理实现
+- 请求拦截和修改
+- 上游代理支持
+
+#### interceptors.py - 请求拦截器
+
+- AI Studio 请求拦截
+- 响应数据解析
+- 流式数据处理
+
+## 🔄 三层响应获取机制
+
+项目实现了三层响应获取机制，确保高可用性和最佳性能：
+
+### 第一层: 集成流式代理 (Stream Proxy)
+
+- **位置**: `stream/` 模块
+- **端口**: 3120 (可配置)
+- **优势**: 最佳性能，直接处理请求
+- **适用**: 日常使用，生产环境
+
+### 第二层: 外部 Helper 服务
+
+- **配置**: 通过 `--helper` 参数或环境变量
+- **依赖**: 需要有效的认证文件
+- **适用**: 备用方案，特殊环境
+
+### 第三层: Playwright 页面交互
+
+- **位置**: `browser_utils/` 模块
+- **方式**: 浏览器自动化操作
+- **优势**: 完整参数支持，最终后备
+- **适用**: 调试模式，参数精确控制
+
+## 🔐 认证系统架构
+
+### API 密钥管理
+
+- **存储**: `auth_profiles/key.txt` 文件
+- **格式**: 每行一个密钥
+- **验证**: Bearer Token 和 X-API-Key 双重支持
+- **管理**: Web UI 分级权限查看
+
+### 浏览器认证
+
+- **文件**: `auth_profiles/active/*.json`
+- **内容**: 浏览器会话和 Cookie
+- **更新**: 通过调试模式重新获取
+
+## 📊 配置管理架构
+
+### 配置优先级
+
+1. **命令行参数** (最高优先级)
+2. **环境变量** (`.env` 文件)
+3. **默认值** (代码中定义)
+
+### 配置分类
+
+- **服务配置**: 端口、代理、日志等
+- **功能配置**: 脚本注入、认证、超时等
+- **API 配置**: 默认参数、模型设置等
+
+## 🚀 脚本注入架构 v3.0
+
+### 工作机制
+
+1. **脚本解析**: 从油猴脚本解析 `MODELS_TO_INJECT` 数组
+2. **网络拦截**: Playwright 拦截 `/api/models` 请求
+3. **数据合并**: 将注入模型与原始模型合并
+4. **响应修改**: 返回包含注入模型的完整列表
+5. **前端注入**: 同时注入脚本确保显示一致
+
+### 技术优势
+
+- **100% 可靠**: Playwright 原生拦截，无时序问题
+- **零维护**: 脚本更新自动生效
+- **完全同步**: 前后端使用相同数据源
+
+## 🔧 开发和部署
+
+### 开发环境
+
+- **依赖管理**: Poetry
+- **类型检查**: Pyright
+- **代码格式**: Black + isort
+- **测试框架**: pytest
+
+### 部署方式
+
+- **本地部署**: Poetry 虚拟环境
+- **Docker 部署**: 多阶段构建，支持多架构
+- **配置管理**: 统一的 `.env` 文件
+
+## 📈 性能优化
+
+### 异步处理
+
+- 全面采用 `async/await`
+- 异步队列处理请求
+- 并发控制和资源管理
+
+### 缓存机制
+
+- 模型列表缓存
+- 认证状态缓存
+- 配置热重载
+
+### 资源管理
+
+- 浏览器实例复用
+- 连接池管理
+- 内存优化
+
+## 🔍 监控和调试
+
+### 日志系统
+
+- 分级日志记录
+- WebSocket 实时日志
+- 错误追踪和报告
+
+### 健康检查
+
+- 组件状态监控
+- 队列长度监控
+- 性能指标收集
+
+这种模块化架构确保了项目的可维护性、可扩展性和高性能，为用户提供稳定可靠的 AI Studio 代理服务。

AIStudioProxyAPI/docs/authentication-setup.md

@@ -0,0 +1,81 @@
+# 首次运行与认证设置指南
+
+为了避免每次启动都手动登录 AI Studio，你需要先通过 [`launch_camoufox.py --debug`](../launch_camoufox.py) 模式或 [`gui_launcher.py`](../gui_launcher.py) 的有头模式运行一次来生成认证文件。
+
+## 认证文件的重要性
+
+**认证文件是无头模式的关键**: 无头模式依赖于 `auth_profiles/active/` 目录下的有效 `.json` 文件来维持登录状态和访问权限。**文件可能会过期**，需要定期通过 [`launch_camoufox.py --debug`](../launch_camoufox.py) 模式手动运行、登录并保存新的认证文件来替换更新。
+
+## 方法一：通过命令行运行 Debug 模式
+
+**推荐使用 .env 配置方式**:
+```env
+# .env 文件配置
+DEFAULT_FASTAPI_PORT=2048
+STREAM_PORT=0
+LAUNCH_MODE=normal
+DEBUG_LOGS_ENABLED=true
+```
+
+```bash
+# 简化启动命令 (推荐)
+python launch_camoufox.py --debug
+
+# 传统命令行方式 (仍然支持)
+python launch_camoufox.py --debug --server-port 2048 --stream-port 0 --helper '' --internal-camoufox-proxy ''
+```
+
+**重要参数说明:**
+*   `--debug`: 启动有头模式，用于首次认证和调试
+*   `--server-port <端口号>`: 指定 FastAPI 服务器监听的端口 (默认: 2048)
+*   `--stream-port <端口号>`: 启动集成的流式代理服务端口 (默认: 3120)。设置为 `0` 可禁用此服务，首次启动建议禁用
+*   `--helper <端点URL>`: 指定外部 Helper 服务的地址。设置为空字符串 `''` 表示不使用外部 Helper
+*   `--internal-camoufox-proxy <代理地址>`: 为 Camoufox 浏览器指定代理。设置为空字符串 `''` 表示不使用代理
+*   **注意**: 如果需要启用流式代理服务，建议同时配置 `--internal-camoufox-proxy` 参数以确保正常运行
+
+### 操作步骤
+
+1. 脚本会启动 Camoufox（通过内部调用自身），并在终端输出启动信息。
+2. 你会看到一个 **带界面的 Firefox 浏览器窗口** 弹出。
+3. **关键交互:** **在弹出的浏览器窗口中完成 Google 登录**，直到看到 AI Studio 聊天界面。 (脚本会自动处理浏览器连接，无需用户手动操作)。
+4. **登录确认操作**: 当系统检测到登录页面并在终端显示类似以下提示时：
+   ```
+   检测到可能需要登录。如果浏览器显示登录页面，请在浏览器窗口中完成 Google 登录，然后在此处按 Enter 键继续...
+   ```
+   **用户必须在终端中按 Enter 键确认操作才能继续**。这个确认步骤是必需的，系统会等待用户的确认输入才会进行下一步的登录状态检查。
+5. 回到终端根据提示回车即可，如果设置使用非自动保存模式（即将弃用），请根据提示保存认证时输入 `y` 并回车 (文件名可默认)。文件会保存在 `auth_profiles/saved/`。
+6. **将 `auth_profiles/saved/` 下新生成的 `.json` 文件移动到 `auth_profiles/active/` 目录。** 确保 `active` 目录下只有一个 `.json` 文件。
+7. 可以按 `Ctrl+C` 停止 `--debug` 模式的运行。
+
+## 方法二：通过 GUI 启动有头模式
+
+1. 运行 `python gui_launcher.py`。
+2. 在 GUI 中输入 `FastAPI 服务端口` (默认为 2048)。
+3. 点击 `启动有头模式` 按钮。
+4. 在弹出的新控制台和浏览器窗口中，按照命令行方式的提示进行 Google 登录和认证文件保存操作。
+5. 同样需要手动将认证文件从 `auth_profiles/saved/` 移动到 `auth_profiles/active/`便于无头模式正常使用。
+
+## 激活认证文件
+
+1. 进入 `auth_profiles/saved/` 目录，找到刚才保存的 `.json` 认证文件。
+2. 将这个 `.json` 文件 **移动或复制** 到 `auth_profiles/active/` 目录下。
+3. **重要:** 确保 `auth_profiles/active/` 目录下 **有且仅有一个 `.json` 文件**。无头模式启动时会自动加载此目录下的第一个 `.json` 文件。
+
+## 认证文件过期处理
+
+**认证文件会过期!** Google 的登录状态不是永久有效的。当无头模式启动失败并报告认证错误或重定向到登录页时，意味着 `active` 目录下的认证文件已失效。你需要：
+
+1. 删除 `active` 目录下的旧文件。
+2. 重新执行上面的 **【通过命令行运行 Debug 模式】** 或 **【通过 GUI 启动有头模式】** 步骤，生成新的认证文件。
+3. 将新生成的 `.json` 文件再次移动到 `active` 目录下。
+
+## 重要提示
+
+*   **首次访问新主机的性能问题**: 当通过流式代理首次访问一个新的 HTTPS 主机时，服务需要为该主机动态生成并签署一个新的子证书。这个过程可能会比较耗时，导致对该新主机的首次连接请求响应较慢，甚至在某些情况下可能被主程序（如 [`server.py`](../server.py) 中的 Playwright 交互逻辑）误判为浏览器加载超时。一旦证书生成并缓存后，后续访问同一主机将会显著加快。
+
+## 下一步
+
+认证设置完成后，请参考：
+- [日常运行指南](daily-usage.md)
+- [API 使用指南](api-usage.md)
+- [Web UI 使用指南](webui-guide.md)

AIStudioProxyAPI/docs/daily-usage.md

@@ -0,0 +1,199 @@
+# 日常运行指南
+
+本指南介绍如何在完成首次认证设置后进行日常运行。项目提供了多种启动方式，推荐使用基于 `.env` 配置文件的简化启动方式。
+
+## 概述
+
+完成首次认证设置后，您可以选择以下方式进行日常运行：
+
+- **图形界面启动**: 使用 [`gui_launcher.py`](../gui_launcher.py) 提供的现代化GUI界面
+- **命令行启动**: 直接使用 [`launch_camoufox.py`](../launch_camoufox.py) 命令行工具
+- **Docker部署**: 使用容器化部署方式
+
+## ⭐ 简化启动方式（推荐）
+
+**基于 `.env` 配置文件的统一配置管理，启动变得极其简单！**
+
+### 配置优势
+
+- ✅ **一次配置，终身受益**: 配置好 `.env` 文件后，启动命令极其简洁
+- ✅ **版本更新无忧**: `git pull` 后无需重新配置，直接启动
+- ✅ **参数集中管理**: 所有配置项统一在 `.env` 文件中
+- ✅ **环境隔离**: 不同环境可使用不同的配置文件
+
+### 基本启动（推荐）
+
+```bash
+# 图形界面启动（推荐新手）
+python gui_launcher.py
+
+# 命令行启动（推荐日常使用）
+python launch_camoufox.py --headless
+
+# 调试模式（首次设置或故障排除）
+python launch_camoufox.py --debug
+```
+
+**就这么简单！** 所有配置都在 `.env` 文件中预设好了，无需复杂的命令行参数。
+
+## 启动器说明
+
+### 关于 `--virtual-display` (Linux 虚拟显示无头模式)
+
+*   **为什么使用?** 与标准的无头模式相比，虚拟显示模式通过创建一个完整的虚拟 X 服务器环境 (Xvfb) 来运行浏览器。这可以模拟一个更真实的桌面环境，从而可能进一步降低被网站检测为自动化脚本或机器人的风险，特别适用于对反指纹和反检测有更高要求的场景，同时确保无桌面的环境下能正常运行服务
+*   **什么时候使用?** 当您在 Linux 环境下运行，并且希望以无头模式操作。
+*   **如何使用?**
+    1. 确保您的 Linux 系统已安装 `xvfb` (参见 [安装指南](installation-guide.md) 中的安装说明)。
+    2. 在运行 [`launch_camoufox.py`](../launch_camoufox.py) 时添加 `--virtual-display` 标志。例如:
+        ```bash
+        python launch_camoufox.py --virtual-display --server-port 2048 --stream-port 3120 --internal-camoufox-proxy ''
+        ```
+
+## 代理配置优先级
+
+项目采用统一的代理配置管理系统，按以下优先级顺序确定代理设置：
+
+1. **`--internal-camoufox-proxy` 命令行参数** (最高优先级)
+   - 明确指定代理：`--internal-camoufox-proxy 'http://127.0.0.1:7890'`
+   - 明确禁用代理：`--internal-camoufox-proxy ''`
+2. **`UNIFIED_PROXY_CONFIG` 环境变量** (推荐，.env 文件配置)
+3. **`HTTP_PROXY` 环境变量**
+4. **`HTTPS_PROXY` 环境变量**
+5. **系统代理设置** (Linux 下的 gsettings，最低优先级)
+
+**推荐配置方式**:
+```env
+# .env 文件中统一配置代理
+UNIFIED_PROXY_CONFIG=http://127.0.0.1:7890
+# 或禁用代理
+UNIFIED_PROXY_CONFIG=
+```
+
+**重要说明**：此代理配置会同时应用于 Camoufox 浏览器和流式代理服务的上游连接，确保整个系统的代理行为一致。
+
+## 三层响应获取机制配置
+
+项目采用三层响应获取机制，确保高可用性和最佳性能。详细说明请参见 [流式处理模式详解](streaming-modes.md)。
+
+### 模式1: 优先使用集成的流式代理 (默认推荐)
+
+**使用 `.env` 配置（推荐）:**
+
+```env
+# 在 .env 文件中配置
+STREAM_PORT=3120
+UNIFIED_PROXY_CONFIG=http://127.0.0.1:7890  # 如需代理
+```
+
+```bash
+# 然后简单启动
+python launch_camoufox.py --headless
+```
+
+**命令行覆盖（高级用户）:**
+
+```bash
+# 使用自定义流式代理端口
+python launch_camoufox.py --headless --stream-port 3125
+
+# 启用代理配置
+python launch_camoufox.py --headless --internal-camoufox-proxy 'http://127.0.0.1:7890'
+
+# 明确禁用代理（覆盖 .env 中的设置）
+python launch_camoufox.py --headless --internal-camoufox-proxy ''
+```
+
+在此模式下，主服务器会优先尝试通过端口 `3120` (或 `.env` 中配置的 `STREAM_PORT`) 上的集成流式代理获取响应。如果失败，则回退到 Playwright 页面交互。
+
+### 模式2: 优先使用外部 Helper 服务 (禁用集成流式代理)
+
+**使用 `.env` 配置（推荐）:**
+
+```bash
+# 在 .env 文件中配置
+STREAM_PORT=0  # 禁用集成流式代理
+GUI_DEFAULT_HELPER_ENDPOINT=http://your-helper-service.com/api/getStreamResponse
+
+# 然后简单启动
+python launch_camoufox.py --headless
+```
+
+**命令行覆盖（高级用户）:**
+
+```bash
+# 外部Helper模式
+python launch_camoufox.py --headless --stream-port 0 --helper 'http://your-helper-service.com/api/getStreamResponse'
+```
+
+在此模式下，主服务器会优先尝试通过 Helper 端点获取响应 (需要有效的 `auth_profiles/active/*.json` 以提取 `SAPISID`)。如果失败，则回退到 Playwright 页面交互。
+
+### 模式3: 仅使用 Playwright 页面交互 (禁用所有流式代理和 Helper)
+
+**使用 `.env` 配置（推荐）:**
+
+```bash
+# 在 .env 文件中配置
+STREAM_PORT=0  # 禁用集成流式代理
+GUI_DEFAULT_HELPER_ENDPOINT=  # 禁用 Helper 服务
+
+# 然后简单启动
+python launch_camoufox.py --headless
+```
+
+**命令行覆盖（高级用户）:**
+
+```bash
+# 纯Playwright模式
+python launch_camoufox.py --headless --stream-port 0 --helper ''
+```
+
+在此模式下，主服务器将仅通过 Playwright 与 AI Studio 页面交互 (模拟点击"编辑"或"复制"按钮) 来获取响应。这是传统的后备方法。
+
+## 使用图形界面启动器
+
+项目提供了一个基于 Tkinter 的图形用户界面 (GUI) 启动器：[`gui_launcher.py`](../gui_launcher.py)。
+
+### 启动 GUI
+
+```bash
+python gui_launcher.py
+```
+
+### GUI 功能
+
+*   **服务端口配置**: 指定 FastAPI 服务器监听的端口号 (默认为 2048)。
+*   **端口进程管理**: 查询和停止指定端口上的进程。
+*   **启动选项**:
+    1. **启动有头模式 (Debug, 交互式)**: 对应 `python launch_camoufox.py --debug`
+    2. **启动无头模式 (后台独立运行)**: 对应 `python launch_camoufox.py --headless`
+*   **本地LLM模拟服务**: 启动和管理本地LLM模拟服务 (基于 [`llm.py`](../llm.py))
+*   **状态与日志**: 显示服务状态和实时日志
+
+### 使用建议
+
+*   首次运行或需要更新认证文件：使用"启动有头模式"
+*   日常后台运行：使用"启动无头模式"
+*   需要详细日志或调试：直接使用命令行 [`launch_camoufox.py`](../launch_camoufox.py)
+
+## 重要注意事项
+
+### 配置优先级
+
+1. **`.env` 文件配置** - 推荐的配置方式，一次设置长期使用
+2. **命令行参数** - 可以覆盖 `.env` 文件中的设置，适用于临时调整
+3. **环境变量** - 最低优先级，主要用于系统级配置
+
+### 使用建议
+
+- **日常使用**: 配置好 `.env` 文件后，使用简单的 `python launch_camoufox.py --headless` 即可
+- **临时调整**: 需要临时修改配置时，使用命令行参数覆盖，无需修改 `.env` 文件
+- **首次设置**: 使用 `python launch_camoufox.py --debug` 进行认证设置
+
+**只有当你确认使用调试模式一切运行正常（特别是浏览器内的登录和认证保存），并且 `auth_profiles/active/` 目录下有有效的认证文件后，才推荐使用无头模式作为日常后台运行的标准方式。**
+
+## 下一步
+
+日常运行设置完成后，请参考：
+- [API 使用指南](api-usage.md)
+- [Web UI 使用指南](webui-guide.md)
+- [故障排除指南](troubleshooting.md)

AIStudioProxyAPI/docs/dependency-versions.md

@@ -0,0 +1,284 @@
+# 依赖版本说明
+
+本文档详细说明了项目的 Python 版本要求、Poetry 依赖管理和版本控制策略。
+
+## 📦 依赖管理工具
+
+项目使用 **Poetry** 进行现代化的依赖管理，相比传统的 `requirements.txt` 提供：
+
+- ✅ **依赖解析**: 自动解决版本冲突
+- ✅ **锁定文件**: `poetry.lock` 确保环境一致性
+- ✅ **虚拟环境**: 自动创建和管理虚拟环境
+- ✅ **依赖分组**: 区分生产依赖和开发依赖
+- ✅ **语义化版本**: 更精确的版本控制
+- ✅ **构建系统**: 内置打包和发布功能
+
+## 🐍 Python 版本要求
+
+### Poetry 配置
+
+```toml
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+```
+
+### 推荐配置
+- **生产环境**: Python 3.10+ 或 3.11+ (最佳性能和稳定性)
+- **开发环境**: Python 3.11+ 或 3.12+ (获得最佳开发体验)
+- **最低要求**: Python 3.9 (基础功能支持)
+
+### 版本兼容性矩阵
+
+| Python版本 | 支持状态 | 推荐程度 | 主要特性 | 说明 |
+|-----------|---------|---------|---------|------|
+| 3.8 | ❌ 不支持 | 不推荐 | - | 缺少必要的类型注解特性 |
+| 3.9 | ✅ 完全支持 | 可用 | 基础功能 | 最低支持版本，所有功能正常 |
+| 3.10 | ✅ 完全支持 | 推荐 | 结构化模式匹配 | Docker 默认版本，稳定可靠 |
+| 3.11 | ✅ 完全支持 | 强烈推荐 | 性能优化 | 显著性能提升，类型提示增强 |
+| 3.12 | ✅ 完全支持 | 推荐 | 更快启动 | 更快启动时间，最新稳定特性 |
+| 3.13 | ✅ 完全支持 | 可用 | 最新特性 | 最新版本，开发环境推荐 |
+
+## 📋 Poetry 依赖配置
+
+### pyproject.toml 结构
+
+```toml
+[tool.poetry]
+name = "aistudioproxyapi"
+version = "0.1.0"
+package-mode = false
+
+[tool.poetry.dependencies]
+# 生产依赖
+python = ">=3.9,<4.0"
+fastapi = "==0.115.12"
+# ... 其他依赖
+
+[tool.poetry.group.dev.dependencies]
+# 开发依赖 (可选安装)
+pytest = "^7.0.0"
+black = "^23.0.0"
+# ... 其他开发工具
+```
+
+### 版本约束语法
+
+Poetry 使用语义化版本约束：
+
+- `==1.2.3` - 精确版本
+- `^1.2.3` - 兼容版本 (>=1.2.3, <2.0.0)
+- `~1.2.3` - 补丁版本 (>=1.2.3, <1.3.0)
+- `>=1.2.3,<2.0.0` - 版本范围
+- `*` - 最新版本
+
+## 🔧 核心依赖版本
+
+### Web 框架相关
+```toml
+fastapi = "==0.115.12"
+pydantic = ">=2.7.1,<3.0.0"
+uvicorn = "==0.29.0"
+```
+
+**版本说明**:
+- **FastAPI 0.115.12**: 最新稳定版本，包含性能优化和新功能
+  - 新增 Query/Header/Cookie 参数模型支持
+  - 改进的类型提示和验证
+  - 更好的 OpenAPI 文档生成
+- **Pydantic 2.7.1+**: 现代数据验证库，使用版本范围确保兼容性
+- **Uvicorn 0.29.0**: 高性能 ASGI 服务器
+
+### 浏览器自动化
+```toml
+playwright = "*"
+camoufox = {version = "0.4.11", extras = ["geoip"]}
+```
+
+**版本说明**:
+- **Playwright**: 使用最新版本 (`*`)，确保浏览器兼容性
+- **Camoufox 0.4.11**: 反指纹检测浏览器，包含地理位置数据扩展
+
+### 网络和安全
+```toml
+aiohttp = "~=3.9.5"
+requests = "==2.31.0"
+cryptography = "==42.0.5"
+pyjwt = "==2.8.0"
+websockets = "==12.0"
+aiosocks = "~=0.2.6"
+python-socks = "~=2.7.1"
+```
+
+**版本说明**:
+- **aiohttp ~3.9.5**: 异步HTTP客户端，允许补丁版本更新
+- **cryptography 42.0.5**: 加密库，固定版本确保安全性
+- **websockets 12.0**: WebSocket 支持
+- **requests 2.31.0**: HTTP 客户端库
+
+### 系统工具
+```toml
+python-dotenv = "==1.0.1"
+httptools = "==0.6.1"
+uvloop = {version = "*", markers = "sys_platform != 'win32'"}
+Flask = "==3.0.3"
+```
+
+**版本说明**:
+- **uvloop**: 仅在非 Windows 系统安装，显著提升性能
+- **httptools**: HTTP 解析优化
+- **python-dotenv**: 环境变量管理
+- **Flask**: 用于特定功能的轻量级 Web 框架
+
+## 🔄 Poetry 依赖管理命令
+
+### 基础命令
+
+```bash
+# 安装所有依赖
+poetry install
+
+# 安装包括开发依赖
+poetry install --with dev
+
+# 添加新依赖
+poetry add package_name
+
+# 添加开发依赖
+poetry add --group dev package_name
+
+# 移除依赖
+poetry remove package_name
+
+# 更新依赖
+poetry update
+
+# 更新特定依赖
+poetry update package_name
+
+# 查看依赖树
+poetry show --tree
+
+# 导出 requirements.txt (兼容性)
+poetry export -f requirements.txt --output requirements.txt
+```
+
+### 锁定文件管理
+
+```bash
+# 更新锁定文件
+poetry lock
+
+# 不更新锁定文件的情况下安装
+poetry install --no-update
+
+# 检查锁定文件是否最新
+poetry check
+```
+
+## 📊 依赖更新策略
+
+### 自动更新 (使用 ~ 版本范围)
+- `aiohttp~=3.9.5` - 允许补丁版本更新 (3.9.5 → 3.9.x)
+- `aiosocks~=0.2.6` - 允许补丁版本更新 (0.2.6 → 0.2.x)
+- `python-socks~=2.7.1` - 允许补丁版本更新 (2.7.1 → 2.7.x)
+
+### 固定版本 (使用 == 精确版本)
+- 核心框架组件 (FastAPI, Uvicorn, python-dotenv)
+- 安全相关库 (cryptography, pyjwt, requests)
+- 稳定性要求高的组件 (websockets, httptools)
+
+### 兼容版本 (使用版本范围)
+- `pydantic>=2.7.1,<3.0.0` - 主版本内兼容更新
+
+### 最新版本 (使用 * 或无限制)
+- `playwright = "*"` - 浏览器自动化，需要最新功能
+- `uvloop = "*"` - 性能优化库，持续更新
+
+## 版本升级建议
+
+### 已完成的依赖升级
+1. **FastAPI**: 0.111.0 → 0.115.12 ✅
+   - 新增 Query/Header/Cookie 参数模型功能
+   - 改进的类型提示和验证机制
+   - 更好的 OpenAPI 文档生成和异步性能
+   - 向后兼容，无破坏性变更
+   - 增强的中间件支持和错误处理
+
+2. **Pydantic**: 固定版本 → 版本范围 ✅
+   - 从 `pydantic==2.7.1` 更新为 `pydantic>=2.7.1,<3.0.0`
+   - 确保与 FastAPI 0.115.12 的完美兼容性
+   - 允许自动获取补丁版本更新和安全修复
+   - 支持最新的数据验证特性
+
+3. **开发工具链现代化**: ✅
+   - Poetry 依赖管理替代传统 requirements.txt
+   - Pyright 类型检查支持，提升开发体验
+   - 模块化配置管理，支持 .env 文件
+
+### 可选的次要依赖更新
+- `charset-normalizer`: 3.4.1 → 3.4.2
+- `click`: 8.1.8 → 8.2.1
+- `frozenlist`: 1.6.0 → 1.6.2
+
+### 升级注意事项
+- 在测试环境中先验证兼容性
+- 关注 FastAPI 版本更新的 breaking changes
+- 定期检查安全漏洞更新
+
+## 环境特定配置
+
+### Docker 环境
+- **基础镜像**: `python:3.10-slim-bookworm`
+- **系统依赖**: 自动安装浏览器运行时依赖
+- **Python版本**: 固定为 3.10 (容器内)
+
+### 开发环境
+- **推荐**: Python 3.11+ 
+- **虚拟环境**: 强烈推荐使用 venv 或 conda
+- **IDE支持**: 配置了 pyrightconfig.json (Python 3.13)
+
+### 生产环境
+- **推荐**: Python 3.10 或 3.11
+- **稳定性**: 使用固定版本依赖
+- **监控**: 定期检查依赖安全更新
+
+## 故障排除
+
+### 常见版本冲突
+1. **Python 3.8 兼容性问题**
+   - 升级到 Python 3.9+
+   - 检查类型提示语法兼容性
+
+2. **依赖版本冲突**
+   - 使用虚拟环境隔离
+   - 清理 pip 缓存: `pip cache purge`
+
+3. **系统依赖缺失**
+   - Linux: 安装 `xvfb` 用于虚拟显示
+   - 运行 `playwright install-deps`
+
+### 版本检查命令
+```bash
+# 检查 Python 版本
+python --version
+
+# 检查已安装包版本
+pip list
+
+# 检查过时的包
+pip list --outdated
+
+# 检查特定包信息
+pip show fastapi
+```
+
+## 更新日志
+
+### 2025-01-25
+- **重要更新**: FastAPI 从 0.111.0 升级到 0.115.12
+- **重要更新**: Pydantic 版本策略从固定版本改为版本范围 (>=2.7.1,<3.0.0)
+- 更新 Python 版本要求说明 (推荐 3.9+，强烈建议 3.10+)
+- 添加详细的依赖版本兼容性矩阵
+- 完善 Docker 环境版本说明 (Python 3.10)
+- 增加版本升级建议和故障排除指南
+- 更新所有相关文档以反映新的依赖版本要求

AIStudioProxyAPI/docs/development-guide.md

@@ -0,0 +1,352 @@
+# 开发者指南
+
+本文档面向希望参与项目开发、贡献代码或深度定制功能的开发者。
+
+## 🛠️ 开发环境设置
+
+### 前置要求
+
+- **Python**: >=3.9, <4.0 (推荐 3.10+ 以获得最佳性能)
+- **Poetry**: 现代化 Python 依赖管理工具
+- **Node.js**: >=16.0 (用于 Pyright 类型检查，可选)
+- **Git**: 版本控制
+
+### 快速开始
+
+```bash
+# 1. 克隆项目
+git clone https://github.com/CJackHwang/AIstudioProxyAPI.git
+cd AIstudioProxyAPI
+
+# 2. 安装 Poetry (如果尚未安装)
+curl -sSL https://install.python-poetry.org | python3 -
+
+# 3. 安装项目依赖 (包括开发依赖)
+poetry install --with dev
+
+# 4. 激活虚拟环境
+poetry env activate
+
+# 5. 安装 Pyright (可选，用于类型检查)
+npm install -g pyright
+```
+
+## 📁 项目结构
+
+```
+AIstudioProxyAPI/
+├── api_utils/              # FastAPI 应用核心模块
+│   ├── app.py             # FastAPI 应用入口
+│   ├── routes.py          # API 路由定义
+│   ├── request_processor.py # 请求处理逻辑
+│   ├── queue_worker.py    # 队列工作器
+│   └── auth_utils.py      # 认证工具
+├── browser_utils/          # 浏览器自动化模块
+│   ├── page_controller.py # 页面控制器
+│   ├── model_management.py # 模型管理
+│   ├── script_manager.py  # 脚本注入管理
+│   └── operations.py      # 浏览器操作
+├── config/                 # 配置管理模块
+│   ├── settings.py        # 主要设置
+│   ├── constants.py       # 常量定义
+│   ├── timeouts.py        # 超时配置
+│   └── selectors.py       # CSS 选择器
+├── models/                 # 数据模型
+│   ├── chat.py           # 聊天相关模型
+│   ├── exceptions.py     # 异常定义
+│   └── logging.py        # 日志模型
+├── stream/                 # 流式代理服务
+│   ├── main.py           # 代理服务入口
+│   ├── proxy_server.py   # 代理服务器
+│   └── interceptors.py   # 请求拦截器
+├── logging_utils/          # 日志工具
+├── docs/                   # 文档目录
+├── docker/                 # Docker 相关文件
+├── pyproject.toml         # Poetry 配置文件
+├── pyrightconfig.json     # Pyright 类型检查配置
+├── .env.example           # 环境变量模板
+└── README.md              # 项目说明
+```
+
+## 🔧 依赖管理 (Poetry)
+
+### Poetry 基础命令
+
+```bash
+# 查看项目信息
+poetry show
+
+# 查看依赖树
+poetry show --tree
+
+# 添加新依赖
+poetry add package_name
+
+# 添加开发依赖
+poetry add --group dev package_name
+
+# 移除依赖
+poetry remove package_name
+
+# 更新依赖
+poetry update
+
+# 更新特定依赖
+poetry update package_name
+
+# 导出 requirements.txt (兼容性)
+poetry export -f requirements.txt --output requirements.txt
+```
+
+### 依赖分组
+
+项目使用 Poetry 的依赖分组功能：
+
+```toml
+[tool.poetry.dependencies]
+# 生产依赖
+python = ">=3.9,<4.0"
+fastapi = "==0.115.12"
+# ... 其他生产依赖
+
+[tool.poetry.group.dev.dependencies]
+# 开发依赖 (可选安装)
+pytest = "^7.0.0"
+black = "^23.0.0"
+isort = "^5.12.0"
+```
+
+### 虚拟环境管理
+
+```bash
+# 查看虚拟环境信息
+poetry env info
+
+# 查看虚拟环境路径
+poetry env info --path
+
+# 激活虚拟环境
+poetry env activate
+
+# 在虚拟环境中运行命令
+poetry run python script.py
+
+# 删除虚拟环境
+poetry env remove python
+```
+
+## 🔍 类型检查 (Pyright)
+
+### Pyright 配置
+
+项目使用 `pyrightconfig.json` 进行类型检查配置：
+
+```json
+{
+    "pythonVersion": "3.13",
+    "pythonPlatform": "Darwin",
+    "typeCheckingMode": "off",
+    "extraPaths": [
+        "./api_utils",
+        "./browser_utils",
+        "./config",
+        "./models",
+        "./logging_utils",
+        "./stream"
+    ]
+}
+```
+
+### 使用 Pyright
+
+```bash
+# 安装 Pyright
+npm install -g pyright
+
+# 检查整个项目
+pyright
+
+# 检查特定文件
+pyright api_utils/app.py
+
+# 监视模式 (文件变化时自动检查)
+pyright --watch
+```
+
+### 类型注解最佳实践
+
+```python
+from typing import Optional, List, Dict, Any
+from pydantic import BaseModel
+
+# 函数类型注解
+def process_request(data: Dict[str, Any]) -> Optional[str]:
+    """处理请求数据"""
+    return data.get("message")
+
+# 类型别名
+ModelConfig = Dict[str, Any]
+ResponseData = Dict[str, str]
+
+# Pydantic 模型
+class ChatRequest(BaseModel):
+    message: str
+    model: Optional[str] = None
+    temperature: float = 0.7
+```
+
+## 🧪 测试
+
+### 运行测试
+
+```bash
+# 运行所有测试
+poetry run pytest
+
+# 运行��定测试文件
+poetry run pytest tests/test_api.py
+
+# 运行测试并生成覆盖率报告
+poetry run pytest --cov=api_utils --cov-report=html
+```
+
+### 测试结构
+
+```
+tests/
+├── conftest.py           # 测试配置
+├── test_api.py          # API 测试
+├── test_browser.py      # 浏览器功能测试
+└── test_config.py       # 配置测试
+```
+
+## 🔄 开发工作流程
+
+### 1. 代码格式化
+
+```bash
+# 使用 Black 格式化代码
+poetry run black .
+
+# 使用 isort 整理导入
+poetry run isort .
+
+# 检查代码风格
+poetry run flake8 .
+```
+
+### 2. 类型检查
+
+```bash
+# 运行类型检查
+pyright
+
+# 或使用 mypy (如果安装)
+poetry run mypy .
+```
+
+### 3. 测试
+
+```bash
+# 运行测试
+poetry run pytest
+
+# 运行测试并检查覆盖率
+poetry run pytest --cov
+```
+
+### 4. 提交代码
+
+```bash
+# 添加文件
+git add .
+
+# 提交 (建议使用规范的提交信息)
+git commit -m "feat: 添加新功能"
+
+# 推送
+git push origin feature-branch
+```
+
+## 📝 代码规范
+
+### 命名规范
+
+- **文件名**: 使用下划线分隔 (`snake_case`)
+- **类名**: 使用驼峰命名 (`PascalCase`)
+- **函数名**: 使用下划线分隔 (`snake_case`)
+- **常量**: 使用大写字母和下划线 (`UPPER_CASE`)
+
+### 文档字符串
+
+```python
+def process_chat_request(request: ChatRequest) -> ChatResponse:
+    """
+    处理聊天请求
+    
+    Args:
+        request: 聊天请求对象
+        
+    Returns:
+        ChatResponse: 聊天响应对象
+        
+    Raises:
+        ValidationError: 当请求数据无效时
+        ProcessingError: 当处理失败时
+    """
+    pass
+```
+
+## 🚀 部署和发布
+
+### 构建项目
+
+```bash
+# 构建分发包
+poetry build
+
+# 检查构建结果
+ls dist/
+```
+
+### Docker 开发
+
+```bash
+# 构建开发镜像
+docker build -f docker/Dockerfile.dev -t aistudio-dev .
+
+# 运行开发容器
+docker run -it --rm -v $(pwd):/app aistudio-dev bash
+```
+
+## 🤝 贡献指南
+
+### 提交 Pull Request
+
+1. Fork 项目
+2. 创建功能分支: `git checkout -b feature/amazing-feature`
+3. 提交更改: `git commit -m 'feat: 添加惊人的功能'`
+4. 推送分支: `git push origin feature/amazing-feature`
+5. 创建 Pull Request
+
+### 代码审查清单
+
+- [ ] 代码遵循项目规范
+- [ ] 添加了必要的测试
+- [ ] 测试通过
+- [ ] 类型检查通过
+- [ ] 文档已更新
+- [ ] 变更日志已更新
+
+## 📞 获取帮助
+
+- **GitHub Issues**: 报告 Bug 或请求功能
+- **GitHub Discussions**: 技术讨论和问答
+- **开发者文档**: 查看详细的 API 文档
+
+## 🔗 相关资源
+
+- [Poetry 官方文档](https://python-poetry.org/docs/)
+- [Pyright 官方文档](https://github.com/microsoft/pyright)
+- [FastAPI 官方文档](https://fastapi.tiangolo.com/)
+- [Playwright 官方文档](https://playwright.dev/python/)