fix(proxy): track actual provider used in forwarding for accurate logging

Introduce ForwardResult and ForwardError structs to return the actual provider that handled the request. This ensures usage statistics and error logs reflect the correct provider after failover.
fix(proxy): handle missing health records and clear health on proxy stop
2026-07-24 21:30:17 +08:00 · 2025-12-23 00:24:22 +08:00 · 2025-12-23 00:05:37 +08:00 · 2025-12-22 23:51:01 +08:00 · 2025-12-22 23:48:56 +08:00 · 2025-12-22 23:46:26 +08:00
177 changed files with 14303 additions and 4088 deletions
@@ -5,6 +5,100 @@ All notable changes to CC Switch will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

+## [3.9.0-1] - 2025-12-18
+
+### Beta Release
+
+This beta release introduces the **Local API Proxy** feature, along with Skills multi-app support, UI improvements, and numerous bug fixes.
+
+### Major Features
+
+#### Local Proxy Server
+- **Local HTTP Proxy** - High-performance proxy server built on Axum framework
+- **Multi-app Support** - Unified proxy for Claude Code, Codex, and Gemini CLI API requests
+- **Per-app Takeover** - Independent control over which apps route through the proxy
+- **Live Config Takeover** - Automatically backs up and redirects CLI configurations to local proxy
+
+#### Auto Failover
+- **Circuit Breaker** - Automatically detects provider failures and triggers protection
+- **Smart Failover** - Automatically switches to backup provider when current one is unavailable
+- **Health Tracking** - Real-time monitoring of provider availability
+- **Independent Failover Queues** - Each app maintains its own failover queue
+
+#### Monitoring
+- **Request Logging** - Detailed logging of all proxy requests
+- **Usage Statistics** - Token consumption, latency, success rate metrics
+- **Real-time Status** - Frontend displays proxy status and statistics
+
+#### Skills Multi-App Support
+- **Multi-app Support** - Skills now support both Claude and Codex (#365)
+- **Multi-app Migration** - Existing Skills auto-migrate to multi-app structure (#378)
+- **Installation Path Fix** - Use directory basename for skill installation path (#358)
+
+### Added
+- **Provider Icon Colors** - Customize provider icon colors (#385)
+- **Deeplink Usage Config** - Import usage query config via deeplink (#400)
+- **Error Request Logging** - Detailed logging for proxy requests (#401)
+- **Closable Toast** - Added close button to switch notification toast (#350)
+- **Icon Color Component** - ProviderIcon component supports color prop (#384)
+
+### Fixed
+
+#### Proxy Related
+- Takeover Codex base_url via model_provider
+- Harden crash recovery with fallback detection
+- Sync UI when active provider differs from current setting
+- Resolve circuit breaker race condition and error classification
+- Stabilize live takeover and provider editing
+- Reset health badges when proxy stops
+- Retry failover for all HTTP errors including 4xx
+- Fix HalfOpen counter underflow and config field inconsistencies
+- Resolve circuit breaker state persistence and HalfOpen deadlock
+- Auto-recover live config after abnormal exit
+- Update live backup when hot-switching provider in proxy mode
+- Wait for server shutdown before exiting app
+- Disable auto-start on app launch by resetting enabled flag on stop
+- Sync live config tokens to database before takeover
+- Resolve 404 error and auto-setup proxy targets
+
+#### MCP Related
+- Skip sync when target CLI app is not installed
+- Improve upsert and import robustness
+- Use browser-compatible platform detection for MCP presets
+
+#### UI Related
+- Restore fade transition for Skills button
+- Add close button to all success toasts
+- Prevent card jitter when health badge appears
+- Update SettingsPage tab styles (#342)
+
+#### Other
+- Fix Azure website link (#407)
+- Add fallback to provider config for usage credentials (#360)
+- Fix Windows black screen on startup (use system titlebar)
+- Add fallback for crypto.randomUUID() on older WebViews
+- Use correct npm package for Codex CLI version check
+- Security fixes for JavaScript executor and usage script (#151)
+
+### Improved
+- **Proxy Active Theme** - Apply emerald theme when proxy takeover is active
+- **Card Animation** - Improved provider card hover animation
+- **Remove Restart Prompt** - No longer prompts restart when switching providers
+
+### Technical
+- Implement per-app takeover mode
+- Proxy module contains 20+ Rust files with complete layered architecture
+- Add 5 new database tables for proxy functionality
+- Modularize handlers.rs to reduce code duplication
+- Remove is_proxy_target in favor of failover_queue
+
+### Stats
+- 55 commits since v3.8.2
+- 164 files changed
+- +22,164 / -570 lines
+
+---
+
 ## [3.8.0] - 2025-11-28

 ### Major Updates
@@ -3,7 +3,6 @@
 # All-in-One Assistant for Claude Code, Codex & Gemini CLI

 [![Version](https://img.shields.io/badge/version-3.8.2-blue.svg)](https://github.com/farion1231/cc-switch/releases)
-[![Trending](https://img.shields.io/badge/🔥_TypeScript_Trending-Daily%20%7C%20Weekly%20%7C%20Monthly-ff6b6b.svg)](https://github.com/trending/typescript)
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey.svg)](https://github.com/farion1231/cc-switch/releases)
 [![Built with Tauri](https://img.shields.io/badge/built%20with-Tauri%202-orange.svg)](https://tauri.app/)
 [![Downloads](https://img.shields.io/endpoint?url=https://api.pinstudios.net/api/badges/downloads/farion1231/cc-switch/total)](https://github.com/farion1231/cc-switch/releases/latest)
@@ -12,21 +11,13 @@

 English | [中文](README_ZH.md) | [日本語](README_JA.md) | [Changelog](CHANGELOG.md)

-**From Provider Switcher to All-in-One AI CLI Management Platform**
-
-Unified management for Claude Code, Codex & Gemini CLI provider configurations, MCP servers, Skills extensions, and system prompts.
-
 </div>

 ## ❤️Sponsor

 ![Zhipu GLM](assets/partners/banners/glm-en.jpg)

-This project is sponsored by Z.ai, supporting us with their GLM CODING PLAN.
-
-GLM CODING PLAN is a subscription service designed for AI coding, starting at just $3/month. It provides access to their flagship GLM-4.6 model across 10+ popular AI coding tools (Claude Code, Cline, Roo Code, etc.), offering developers top-tier, fast, and stable coding experiences.
-
-Get 10% OFF the GLM CODING PLAN with [this link](https://z.ai/subscribe?ic=8JVLJQFSKB)!
+This project is sponsored by Z.ai, supporting us with their GLM CODING PLAN.GLM CODING PLAN is a subscription service designed for AI coding, starting at just $3/month. It provides access to their flagship GLM-4.6 model across 10+ popular AI coding tools (Claude Code, Cline, Roo Code, etc.), offering developers top-tier, fast, and stable coding experiences.Get 10% OFF the GLM CODING PLAN with [this link](https://z.ai/subscribe?ic=8JVLJQFSKB)!

 ---

@@ -41,6 +32,12 @@ Get 10% OFF the GLM CODING PLAN with [this link](https://z.ai/subscribe?ic=8JVLJ
 <td>Thanks to ShanDianShuo for sponsoring this project! ShanDianShuo is a local-first AI voice input: Millisecond latency, data stays on device, 4x faster than typing, AI-powered correction, Privacy-first, completely free. Doubles your coding efficiency with Claude Code! <a href="https://www.shandianshuo.cn">Free download</a> for Mac/Win</td>
 </tr>

+<tr>
+<td width="180"><img src="assets/partners/logos/aigocode.png" alt="AIGoCode" width="150"></td>
+<td>Thanks to AIGoCode for sponsoring this project! AIGoCode is an all-in-one platform that integrates Claude Code, Codex, and the latest Gemini models, providing you with stable, efficient, and highly cost-effective AI coding services. The platform offers flexible subscription plans, zero risk of account suspension, direct access with no VPN required, and lightning-fast responses.AIGoCode has prepared a special benefit for CC Switch users: if you register via <a href="https://aigocode.com/invite/CC-SWITCH">this link</a>, you’ll receive an extra 10% bonus credit on your first top-up!
+</td>
+</tr>
+
 </table>

 ## Screenshots
@@ -3,7 +3,6 @@
 # Claude Code / Codex / Gemini CLI オールインワン・アシスタント

 [![Version](https://img.shields.io/badge/version-3.8.2-blue.svg)](https://github.com/farion1231/cc-switch/releases)
-[![Trending](https://img.shields.io/badge/🔥_TypeScript_Trending-Daily%20%7C%20Weekly%20%7C%20Monthly-ff6b6b.svg)](https://github.com/trending/typescript)
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey.svg)](https://github.com/farion1231/cc-switch/releases)
 [![Built with Tauri](https://img.shields.io/badge/built%20with-Tauri%202-orange.svg)](https://tauri.app/)
 [![Downloads](https://img.shields.io/endpoint?url=https://api.pinstudios.net/api/badges/downloads/farion1231/cc-switch/total)](https://github.com/farion1231/cc-switch/releases/latest)
@@ -12,21 +11,13 @@

 [English](README.md) | [中文](README_ZH.md) | 日本語 | [Changelog](CHANGELOG.md) | [v3.8.0 リリースノート](docs/release-note-v3.8.0-en.md)

-**プロバイダスイッチャーから AI CLI 一体型管理プラットフォームへ**
-
-Claude Code・Codex・Gemini CLI のプロバイダ設定、MCP サーバー、Skills 拡張、システムプロンプトを統合管理。
-
 </div>

 ## ❤️スポンサー

 ![Zhipu GLM](assets/partners/banners/glm-en.jpg)

-本プロジェクトは Z.ai の GLM CODING PLAN による支援を受けています。
-
-GLM CODING PLAN は AI コーディング向けのサブスクリプションで、月額わずか 3 ドルから。Claude Code、Cline、Roo Code など 10 以上の人気 AI コーディングツールでフラッグシップモデル GLM-4.6 を利用でき、速く安定した開発体験を提供します。
-
-[このリンク](https://z.ai/subscribe?ic=8JVLJQFSKB) から申し込むと 10% オフになります！
+本プロジェクトは Z.ai の GLM CODING PLAN による支援を受けています。GLM CODING PLAN は AI コーディング向けのサブスクリプションで、月額わずか 3 ドルから。Claude Code、Cline、Roo Code など 10 以上の人気 AI コーディングツールでフラッグシップモデル GLM-4.6 を利用でき、速く安定した開発体験を提供します。[このリンク](https://z.ai/subscribe?ic=8JVLJQFSKB) から申し込むと 10% オフになります！

 ---

@@ -41,6 +32,13 @@ GLM CODING PLAN は AI コーディング向けのサブスクリプションで
 <td>ShanDianShuo のご支援に感謝します！ShanDianShuo はローカルファーストの音声入力ツールで、ミリ秒遅延・データは端末から外に出ず・キーボード入力の 4 倍の速度・AI 自動補正・プライバシー優先で完全無料。Claude Code と組み合わせればコーディング効率が倍増します。<a href="https://www.shandianshuo.cn">Mac/Win 版を無料ダウンロード</a></td>
 </tr>

+<tr>
+<td width="180"><img src="assets/partners/logos/aigocode.png" alt="AIGoCode" width="150"></td>
+<td>本プロジェクトは AIGoCode のスポンサー提供でお届けしています。AIGoCode は、Claude Code・Codex・最新の Gemini モデルを統合したオールインワンのAIコーディングプラットフォームで、安定性・高速性・コストパフォーマンスに優れた開発サービスを提供します。柔軟なサブスクリプションプランを備え、レスポンスも非常に高速です。さらに、CC Switch ユーザー向けの特典として、<a href="https://aigocode.com/invite/CC-SWITCH">このリンク</a>から登録すると、初回チャージ時に10％分のボーナスクレジットが付与されます！
+
+</td>
+</tr>
+
 </table>

 ## スクリーンショット
@@ -3,7 +3,6 @@
 # Claude Code / Codex / Gemini CLI 全方位辅助工具

 [![Version](https://img.shields.io/badge/version-3.8.2-blue.svg)](https://github.com/farion1231/cc-switch/releases)
-[![Trending](https://img.shields.io/badge/🔥_TypeScript_Trending-Daily%20%7C%20Weekly%20%7C%20Monthly-ff6b6b.svg)](https://github.com/trending/typescript)
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey.svg)](https://github.com/farion1231/cc-switch/releases)
 [![Built with Tauri](https://img.shields.io/badge/built%20with-Tauri%202-orange.svg)](https://tauri.app/)
 [![Downloads](https://img.shields.io/endpoint?url=https://api.pinstudios.net/api/badges/downloads/farion1231/cc-switch/total)](https://github.com/farion1231/cc-switch/releases/latest)
@@ -12,21 +11,13 @@

 [English](README.md) | 中文 | [日本語](README_JA.md) | [更新日志](CHANGELOG.md) | [v3.8.0 发布说明](docs/release-note-v3.8.0-zh.md)

-**从供应商切换器到 AI CLI 一体化管理平台**
-
-统一管理 Claude Code、Codex 与 Gemini CLI 的供应商配置、MCP 服务器、Skills 扩展和系统提示词。
-
 </div>

 ## ❤️赞助商

 ![智谱 GLM](assets/partners/banners/glm-zh.jpg)

-感谢智谱AI的 GLM CODING PLAN 赞助了本项目！
-
-GLM CODING PLAN 是专为AI编码打造的订阅套餐,每月最低仅需20元，即可在十余款主流AI编码工具如 Claude Code、Cline 中畅享智谱旗舰模型 GLM-4.6，为开发者提供顶尖、高速、稳定的编码体验。
-
-CC Switch 已经预设了智谱GLM，只需要填写 key 即可一键导入编程工具。智谱AI为本软件的用户提供了特别优惠，使用[此链接](https://www.bigmodel.cn/claude-code?ic=RRVJPB5SII)购买可以享受九折优惠。
+感谢智谱AI的 GLM CODING PLAN 赞助了本项目！GLM CODING PLAN 是专为AI编码打造的订阅套餐,每月最低仅需20元，即可在十余款主流AI编码工具如 Claude Code、Cline 中畅享智谱旗舰模型 GLM-4.6，为开发者提供顶尖、高速、稳定的编码体验。CC Switch 已经预设了智谱GLM，只需要填写 key 即可一键导入编程工具。智谱AI为本软件的用户提供了特别优惠，使用[此链接](https://www.bigmodel.cn/claude-code?ic=RRVJPB5SII)购买可以享受九折优惠。

 ---

@@ -41,6 +32,11 @@ CC Switch 已经预设了智谱GLM，只需要填写 key 即可一键导入编
 <td>感谢闪电说赞助了本项目！闪电说是本地优先的 AI 语音输入法：毫秒级响应，数据不离设备；打字速度提升 4 倍，AI 智能纠错；绝对隐私安全，完全免费，配合 Claude Code 写代码效率翻倍！支持 Mac/Win 双平台，<a href="https://www.shandianshuo.cn">免费下载</a></td>
 </tr>

+<tr>
+<td width="180"><img src="assets/partners/logos/aigocode.png" alt="AIGoCode" width="150"></td>
+<td>感谢 AIGoCode 赞助了本项目！AIGoCode 是一个集成了 Claude Code、Codex 以及 Gemini 最新模型的一站式平台，为你提供稳定、高效且高性价比的AI编程服务。本站提供灵活的订阅计划，零封号风险，国内直连，无需魔法，极速响应。AIGoCode 为 CC Switch 的用户提供了特别福利，通过<a href="https://aigocode.com/invite/CC-SWITCH">此链接</a>注册的用户首次充值可以获得额外10%奖励额度！</td>
+</tr>
+
 </table>

 ## 界面预览
@@ -0,0 +1,165 @@
+# CC Switch 代理功能使用指南
+
+## 功能介绍
+
+CC Switch 的代理功能是一个本地 HTTP 代理服务器，可以统一管理 Claude Code、Codex 和 Gemini CLI 的 API 请求。主要特性包括：
+
+- **统一代理入口** - 所有 CLI 应用的请求通过本地代理转发
+- **自动故障转移** - 当前供应商故障时自动切换到备用供应商
+- **按应用控制** - 可独立控制每个应用是否启用代理
+- **配置保护** - 自动备份原始配置，停止代理时安全恢复
+
+## 快速开始
+
+### 1. 启动代理
+
+在 CC Switch 主界面，点击右上角的 **Proxy** 按钮，可以看到代理控制面板。
+
+点击 **启动代理** 按钮启动本地代理服务器。代理默认监听 `127.0.0.1:15721`。
+
+### 2. 启用应用接管
+
+代理启动后，你可以选择让哪些应用的请求通过代理：
+
+- **Claude** - 接管 Claude Code 的 API 请求
+- **Codex** - 接管 Codex CLI 的 API 请求
+- **Gemini** - 接管 Gemini CLI 的 API 请求
+
+点击对应应用的开关即可启用/禁用接管。
+
+> **注意**：启用接管后，CC Switch 会自动修改对应应用的配置文件，将 API 端点指向本地代理。原始配置会被安全备份。
+
+### 3. 正常使用 CLI
+
+启用接管后，你可以正常使用各个 CLI 工具。所有请求都会经过 CC Switch 代理转发到配置的供应商。
+
+### 4. 停止代理
+
+当你不再需要代理时，点击 **停止代理** 按钮。CC Switch 会：
+
+1. 安全关闭代理服务器
+2. 自动恢复所有应用的原始配置
+3. 清除代理状态
+
+## 自动故障转移
+
+### 工作原理
+
+代理功能内置了智能故障转移机制：
+
+1. **健康监控** - 实时监控每个供应商的响应状态
+2. **熔断器** - 连续失败 5 次后触发熔断，暂停使用该供应商
+3. **自动切换** - 熔断后自动切换到列表中的下一个供应商
+4. **自动恢复** - 30 秒后尝试恢复熔断的供应商
+
+### 配置故障转移
+
+要使用故障转移功能，你需要：
+
+1. 在对应应用下添加多个供应商（至少 2 个）
+2. 启动代理并启用接管
+3. 当主供应商故障时，代理会自动切换到备用供应商
+
+### 健康状态指示
+
+在供应商卡片上可以看到健康状态指示：
+
+- **绿色** - 供应商正常
+- **红色** - 供应商故障/熔断中
+- **灰色** - 未使用代理或未检测
+
+## 按应用接管
+
+v3.9.0 新增了按应用分粒度控制功能：
+
+- 你可以只接管 Claude，而让 Codex 使用原始配置
+- 每个应用的接管状态独立管理
+- 启用/禁用不会影响其他应用
+
+### 接管状态检测
+
+CC Switch 通过检测配置备份来判断接管状态：
+
+- 存在备份 = 已接管
+- 无备份 = 未接管
+
+这确保了即使 CC Switch 异常退出，重新启动后也能正确识别状态。
+
+## 代理配置
+
+在代理面板中，你可以配置以下参数：
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| 监听地址 | 127.0.0.1 | 代理服务器绑定地址 |
+| 监听端口 | 15721 | 代理服务器端口 |
+| 最大重试 | 3 | 请求失败时的最大重试次数 |
+| 请求超时 | 120 秒 | 单个请求的超时时间 |
+| 启用日志 | 是 | 是否记录请求日志 |
+
+## 常见问题
+
+### Q: 代理启动失败，提示端口被占用？
+
+A: 默认端口 15721 可能被其他程序占用。你可以：
+- 关闭占用该端口的程序
+- 在代理配置中修改端口号
+
+### Q: 启用接管后 CLI 无法使用？
+
+A: 请检查：
+1. 代理服务器是否正常运行（查看代理面板状态）
+2. 供应商配置是否正确（API Key 等）
+3. 网络连接是否正常
+
+### Q: 如何恢复原始配置？
+
+A: 点击 **停止代理** 按钮，CC Switch 会自动恢复所有应用的原始配置。
+
+如果 CC Switch 异常退出，重新启动后会检测到之前的备份，你可以：
+- 点击停止代理来恢复配置
+- 或继续使用代理功能
+
+### Q: 故障转移没有生效？
+
+A: 请确保：
+1. 配置了至少 2 个供应商
+2. 代理已启动且接管已启用
+3. 故障转移只在代理模式下工作
+
+### Q: 代理会影响性能吗？
+
+A: 本地代理的延迟开销非常小（通常 < 1ms）。但如果启用了请求日志，在高频请求场景下可能会有少量性能影响。
+
+## 技术细节
+
+### 配置文件位置
+
+启用接管后，CC Switch 会修改以下配置文件：
+
+| 应用 | 配置文件 | 修改内容 |
+|------|----------|----------|
+| Claude | `~/.claude/settings.json` | `apiBaseUrl` 指向代理 |
+| Codex | `~/.codex/config.toml` | `[api] baseUrl` 指向代理 |
+| Gemini | `~/.gemini/.env` | `GEMINI_BASE_URL` 指向代理 |
+
+原始配置备份在 CC Switch 数据库中，停止代理时自动恢复。
+
+### 代理模式
+
+代理服务器运行在接管模式下，会：
+
+1. 接收来自 CLI 的 HTTPS 请求
+2. 根据当前供应商配置转发到真实 API 端点
+3. 返回响应给 CLI
+4. 记录请求日志和健康状态
+
+### 数据库表
+
+代理功能使用以下数据库表：
+
+- `proxy_config` - 代理配置
+- `provider_health` - 供应商健康状态
+- `proxy_request_logs` - 请求日志
+- `circuit_breaker_config` - 熔断器配置
+- `proxy_live_backup` - Live 配置备份
@@ -1,6 +1,6 @@
 {
  "name": "cc-switch",
-  "version": "3.8.2",
+  "version": "3.9.0-2",
  "description": "All-in-One Assistant for Claude Code, Codex & Gemini CLI",
  "scripts": {
    "dev": "pnpm tauri dev",
@@ -50,6 +50,7 @@
    "@dnd-kit/utilities": "^3.2.2",
    "@hookform/resolvers": "^5.2.2",
    "@lobehub/icons-static-svg": "^1.73.0",
+    "@radix-ui/react-accordion": "^1.2.12",
    "@radix-ui/react-checkbox": "^1.3.3",
    "@radix-ui/react-dialog": "^1.1.15",
    "@radix-ui/react-dropdown-menu": "^2.1.16",
@@ -67,7 +68,9 @@
    "@tauri-apps/plugin-updater": "^2.0.0",
    "class-variance-authority": "^0.7.1",
    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
    "codemirror": "^6.0.2",
+    "framer-motion": "^12.23.25",
    "i18next": "^25.5.2",
    "jsonc-parser": "^3.2.1",
    "lucide-react": "^0.542.0",
@@ -44,6 +44,9 @@ importers:
      '@lobehub/icons-static-svg':
        specifier: ^1.73.0
        version: 1.73.0
+      '@radix-ui/react-accordion':
+        specifier: ^1.2.12
+        version: 1.2.12(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
      '@radix-ui/react-checkbox':
        specifier: ^1.3.3
        version: 1.3.3(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@@ -95,9 +98,15 @@ importers:
      clsx:
        specifier: ^2.1.1
        version: 2.1.1
+      cmdk:
+        specifier: ^1.1.1
+        version: 1.1.1(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
      codemirror:
        specifier: ^6.0.2
        version: 6.0.2
+      framer-motion:
+        specifier: ^12.23.25
+        version: 12.23.25(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
      i18next:
        specifier: ^25.5.2
        version: 25.5.2(typescript@5.9.2)
@@ -652,6 +661,19 @@ packages:
  '@radix-ui/primitive@1.1.3':
    resolution: {integrity: sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==}

+  '@radix-ui/react-accordion@1.2.12':
+    resolution: {integrity: sha512-T4nygeh9YE9dLRPhAHSeOZi7HBXo+0kYIPJXayZfvWOWA0+n3dESrZbjfDPUABkUNym6Hd+f2IR113To8D2GPA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
  '@radix-ui/react-arrow@1.1.7':
    resolution: {integrity: sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==}
    peerDependencies:
@@ -678,6 +700,19 @@ packages:
      '@types/react-dom':
        optional: true

+  '@radix-ui/react-collapsible@1.1.12':
+    resolution: {integrity: sha512-Uu+mSh4agx2ib1uIGPP4/CKNULyajb3p92LsVXmH2EHVMTfZWpll88XJ0j4W0z3f8NK1eYl1+Mf/szHPmcHzyA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
  '@radix-ui/react-collection@1.1.7':
    resolution: {integrity: sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw==}
    peerDependencies:
@@ -1527,6 +1562,12 @@ packages:
    resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
    engines: {node: '>=6'}

+  cmdk@1.1.1:
+    resolution: {integrity: sha512-Vsv7kFaXm+ptHDMZ7izaRsP70GgrW9NBNGswt9OZaVBLlE0SNpDq8eu/VGXyF9r7M0azK3Wy7OlYXsuyYLFzHg==}
+    peerDependencies:
+      react: ^18 || ^19 || ^19.0.0-rc
+      react-dom: ^18 || ^19 || ^19.0.0-rc
+
  codemirror@6.0.2:
    resolution: {integrity: sha512-VhydHotNW5w1UGK0Qj96BwSk/Zqbp9WbnyK2W/eVMv4QyF41INRGpjUhFJY7/uDNuudSc33a/PKr4iDqRduvHw==}

@@ -1752,6 +1793,20 @@ packages:
  fraction.js@5.3.4:
    resolution: {integrity: sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==}

+  framer-motion@12.23.25:
+    resolution: {integrity: sha512-gUHGl2e4VG66jOcH0JHhuJQr6ZNwrET9g31ZG0xdXzT0CznP7fHX4P8Bcvuc4MiUB90ysNnWX2ukHRIggkl6hQ==}
+    peerDependencies:
+      '@emotion/is-prop-valid': '*'
+      react: ^18.0.0 || ^19.0.0
+      react-dom: ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@emotion/is-prop-valid':
+        optional: true
+      react:
+        optional: true
+      react-dom:
+        optional: true
+
  fsevents@2.3.3:
    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
@@ -2035,6 +2090,12 @@ packages:
    resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==}
    engines: {node: '>=4'}

+  motion-dom@12.23.23:
+    resolution: {integrity: sha512-n5yolOs0TQQBRUFImrRfs/+6X4p3Q4n1dUEqt/H58Vx7OW6RF+foWEgmTVDhIWJIMXOuNNL0apKH2S16en9eiA==}
+
+  motion-utils@12.23.6:
+    resolution: {integrity: sha512-eAWoPgr4eFEOFfg2WjIsMoqJTW6Z8MTUCgn/GZ3VRpClWBdnbjryiA3ZSNLyxCTmCQx4RmYX6jX1iWHbenUPNQ==}
+
  ms@2.1.3:
    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}

@@ -3183,6 +3244,23 @@ snapshots:

  '@radix-ui/primitive@1.1.3': {}

+  '@radix-ui/react-accordion@1.2.12(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collapsible': 1.1.12(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@18.3.23)(react@18.3.1)
+      '@radix-ui/react-context': 1.1.2(@types/react@18.3.23)(react@18.3.1)
+      '@radix-ui/react-direction': 1.1.1(@types/react@18.3.23)(react@18.3.1)
+      '@radix-ui/react-id': 1.1.1(@types/react@18.3.23)(react@18.3.1)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@18.3.23)(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+    optionalDependencies:
+      '@types/react': 18.3.23
+      '@types/react-dom': 18.3.7(@types/react@18.3.23)
+
  '@radix-ui/react-arrow@1.1.7(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
    dependencies:
      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@@ -3208,6 +3286,22 @@ snapshots:
      '@types/react': 18.3.23
      '@types/react-dom': 18.3.7(@types/react@18.3.23)

+  '@radix-ui/react-collapsible@1.1.12(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@18.3.23)(react@18.3.1)
+      '@radix-ui/react-context': 1.1.2(@types/react@18.3.23)(react@18.3.1)
+      '@radix-ui/react-id': 1.1.1(@types/react@18.3.23)(react@18.3.1)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@18.3.23)(react@18.3.1)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@18.3.23)(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+    optionalDependencies:
+      '@types/react': 18.3.23
+      '@types/react-dom': 18.3.7(@types/react@18.3.23)
+
  '@radix-ui/react-collection@1.1.7(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
    dependencies:
      '@radix-ui/react-compose-refs': 1.1.2(@types/react@18.3.23)(react@18.3.1)
@@ -3988,6 +4082,18 @@ snapshots:

  clsx@2.1.1: {}

+  cmdk@1.1.1(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@18.3.23)(react@18.3.1)
+      '@radix-ui/react-dialog': 1.1.15(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-id': 1.1.1(@types/react@18.3.23)(react@18.3.1)
+      '@radix-ui/react-primitive': 2.1.4(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+    transitivePeerDependencies:
+      - '@types/react'
+      - '@types/react-dom'
+
  codemirror@6.0.2:
    dependencies:
      '@codemirror/autocomplete': 6.18.7
@@ -4202,6 +4308,15 @@ snapshots:

  fraction.js@5.3.4: {}

+  framer-motion@12.23.25(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
+    dependencies:
+      motion-dom: 12.23.23
+      motion-utils: 12.23.6
+      tslib: 2.8.1
+    optionalDependencies:
+      react: 18.3.1
+      react-dom: 18.3.1(react@18.3.1)
+
  fsevents@2.3.3:
    optional: true

@@ -4444,6 +4559,12 @@ snapshots:

  min-indent@1.0.1: {}

+  motion-dom@12.23.23:
+    dependencies:
+      motion-utils: 12.23.6
+
+  motion-utils@12.23.6: {}
+
  ms@2.1.3: {}

  msw@2.11.6(@types/node@20.19.9)(typescript@5.9.2):
@@ -586,6 +586,12 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"

+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
 [[package]]
 name = "bytes"
 version = "1.10.1"
@@ -695,7 +701,7 @@ dependencies = [

 [[package]]
 name = "cc-switch"
-version = "3.8.2"
+version = "3.9.0-2"
 dependencies = [
 "anyhow",
 "async-stream",
@@ -2214,7 +2220,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cc50b891e4acf8fe0e71ef88ec43ad82ee07b3810ad09de10f1d01f072ed4b98"
 dependencies = [
 "byteorder",
- "png",
+ "png 0.17.16",
 ]

 [[package]]
@@ -2330,6 +2336,19 @@ dependencies = [
 "icu_properties",
 ]

+[[package]]
+name = "image"
+version = "0.25.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "529feb3e6769d234375c4cf1ee2ce713682b8e76538cb13f9fc23e1400a591e7"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "moxcms",
+ "num-traits",
+ "png 0.18.0",
+]
+
 [[package]]
 name = "indexmap"
 version = "1.9.3"
@@ -2759,6 +2778,16 @@ dependencies = [
 "windows-sys 0.59.0",
 ]

+[[package]]
+name = "moxcms"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fbdd3d7436f8b5e892b8b7ea114271ff0fa00bc5acae845d53b07d498616ef6"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
 [[package]]
 name = "muda"
 version = "0.17.1"
@@ -2774,7 +2803,7 @@ dependencies = [
 "objc2-core-foundation",
 "objc2-foundation 0.3.1",
 "once_cell",
- "png",
+ "png 0.17.16",
 "serde",
 "thiserror 2.0.17",
 "windows-sys 0.60.2",
@@ -3563,6 +3592,19 @@ dependencies = [
 "miniz_oxide",
 ]

+[[package]]
+name = "png"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97baced388464909d42d89643fe4361939af9b7ce7a31ee32a168f832a70f2a0"
+dependencies = [
+ "bitflags 2.9.4",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
 [[package]]
 name = "polling"
 version = "3.11.0"
@@ -3694,6 +3736,15 @@ dependencies = [
 "syn 1.0.109",
 ]

+[[package]]
+name = "pxfm"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3cbdf373972bf78df4d3b518d07003938e2c7d1fb5891e55f9cb6df57009d84"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "quick-xml"
 version = "0.37.5"
@@ -4987,6 +5038,7 @@ dependencies = [
 "heck 0.5.0",
 "http",
 "http-range",
+ "image",
 "jni",
 "libc",
 "log",
@@ -5055,7 +5107,7 @@ dependencies = [
 "ico",
 "json-patch",
 "plist",
- "png",
+ "png 0.17.16",
 "proc-macro2",
 "quote",
 "semver",
@@ -5810,7 +5862,7 @@ dependencies = [
 "objc2-core-graphics",
 "objc2-foundation 0.3.1",
 "once_cell",
- "png",
+ "png 0.17.16",
 "serde",
 "thiserror 2.0.17",
 "windows-sys 0.59.0",
@@ -1,6 +1,6 @@
 [package]
 name = "cc-switch"
-version = "3.8.2"
+version = "3.9.0-2"
 description = "All-in-One Assistant for Claude Code, Codex & Gemini CLI"
 authors = ["Jason Young"]
 license = "MIT"
@@ -26,7 +26,7 @@ serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 log = "0.4"
 chrono = { version = "0.4", features = ["serde"] }
-tauri = { version = "2.8.2", features = ["tray-icon", "protocol-asset"] }
+tauri = { version = "2.8.2", features = ["tray-icon", "protocol-asset", "image-png"] }
 tauri-plugin-log = "2"
 tauri-plugin-opener = "2"
 tauri-plugin-process = "2"
@@ -105,6 +105,55 @@ pub fn read_mcp_json() -> Result<Option<String>, AppError> {
    Ok(Some(content))
 }

+/// 在 ~/.claude.json 根对象写入 hasCompletedOnboarding=true（用于跳过 Claude Code 初次安装确认）
+/// 仅增量写入该字段，其他字段保持不变
+pub fn set_has_completed_onboarding() -> Result<bool, AppError> {
+    let path = user_config_path();
+    let mut root = if path.exists() {
+        read_json_value(&path)?
+    } else {
+        serde_json::json!({})
+    };
+
+    let obj = root
+        .as_object_mut()
+        .ok_or_else(|| AppError::Config("~/.claude.json 根必须是对象".into()))?;
+
+    let already = obj
+        .get("hasCompletedOnboarding")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false);
+    if already {
+        return Ok(false);
+    }
+
+    obj.insert("hasCompletedOnboarding".into(), Value::Bool(true));
+    write_json_value(&path, &root)?;
+    Ok(true)
+}
+
+/// 删除 ~/.claude.json 根对象的 hasCompletedOnboarding 字段（恢复 Claude Code 初次安装确认）
+/// 仅增量删除该字段，其他字段保持不变
+pub fn clear_has_completed_onboarding() -> Result<bool, AppError> {
+    let path = user_config_path();
+    if !path.exists() {
+        return Ok(false);
+    }
+
+    let mut root = read_json_value(&path)?;
+    let obj = root
+        .as_object_mut()
+        .ok_or_else(|| AppError::Config("~/.claude.json 根必须是对象".into()))?;
+
+    let existed = obj.remove("hasCompletedOnboarding").is_some();
+    if !existed {
+        return Ok(false);
+    }
+
+    write_json_value(&path, &root)?;
+    Ok(true)
+}
+
 pub fn upsert_mcp_server(id: &str, spec: Value) -> Result<bool, AppError> {
    if id.trim().is_empty() {
        return Err(AppError::InvalidInput("MCP 服务器 ID 不能为空".into()));
@@ -0,0 +1,90 @@
+//! 故障转移队列命令
+//!
+//! 管理代理模式下的故障转移队列（基于 providers 表的 in_failover_queue 字段）
+
+use crate::database::FailoverQueueItem;
+use crate::provider::Provider;
+use crate::store::AppState;
+
+/// 获取故障转移队列
+#[tauri::command]
+pub async fn get_failover_queue(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+) -> Result<Vec<FailoverQueueItem>, String> {
+    state
+        .db
+        .get_failover_queue(&app_type)
+        .map_err(|e| e.to_string())
+}
+
+/// 获取可添加到故障转移队列的供应商（不在队列中的）
+#[tauri::command]
+pub async fn get_available_providers_for_failover(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+) -> Result<Vec<Provider>, String> {
+    state
+        .db
+        .get_available_providers_for_failover(&app_type)
+        .map_err(|e| e.to_string())
+}
+
+/// 添加供应商到故障转移队列
+#[tauri::command]
+pub async fn add_to_failover_queue(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+    provider_id: String,
+) -> Result<(), String> {
+    state
+        .db
+        .add_to_failover_queue(&app_type, &provider_id)
+        .map_err(|e| e.to_string())
+}
+
+/// 从故障转移队列移除供应商
+#[tauri::command]
+pub async fn remove_from_failover_queue(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+    provider_id: String,
+) -> Result<(), String> {
+    state
+        .db
+        .remove_from_failover_queue(&app_type, &provider_id)
+        .map_err(|e| e.to_string())
+}
+
+/// 获取指定应用的自动故障转移开关状态
+#[tauri::command]
+pub async fn get_auto_failover_enabled(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+) -> Result<bool, String> {
+    let key = format!("auto_failover_enabled_{app_type}");
+    state
+        .db
+        .get_setting(&key)
+        .map(|v| v.map(|s| s == "true").unwrap_or(false)) // 默认关闭
+        .map_err(|e| e.to_string())
+}
+
+/// 设置指定应用的自动故障转移开关状态
+///
+/// 注意：关闭故障转移时不会清除队列，队列内容会保留供下次开启时使用
+#[tauri::command]
+pub async fn set_auto_failover_enabled(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+    enabled: bool,
+) -> Result<(), String> {
+    let key = format!("auto_failover_enabled_{app_type}");
+    let value = if enabled { "true" } else { "false" };
+
+    log::info!(
+        "[Failover] Setting auto_failover_enabled: key='{key}', value='{value}', app_type='{app_type}'"
+    );
+
+    state.db.set_setting(&key, value).map_err(|e| e.to_string())
+}
@@ -4,6 +4,12 @@ use crate::init_status::InitErrorPayload;
 use tauri::AppHandle;
 use tauri_plugin_opener::OpenerExt;

+#[cfg(target_os = "windows")]
+use std::os::windows::process::CommandExt;
+
+#[cfg(target_os = "windows")]
+const CREATE_NO_WINDOW: u32 = 0x08000000;
+
 /// 打开外部链接
 #[tauri::command]
 pub async fn open_external(app: AppHandle, url: String) -> Result<bool, String> {
@@ -58,3 +64,221 @@ pub async fn get_init_error() -> Result<Option<InitErrorPayload>, String> {
 pub async fn get_migration_result() -> Result<bool, String> {
    Ok(crate::init_status::take_migration_success())
 }
+
+#[derive(serde::Serialize)]
+pub struct ToolVersion {
+    name: String,
+    version: Option<String>,
+    latest_version: Option<String>, // 新增字段：最新版本
+    error: Option<String>,
+}
+
+#[tauri::command]
+pub async fn get_tool_versions() -> Result<Vec<ToolVersion>, String> {
+    let tools = vec!["claude", "codex", "gemini"];
+    let mut results = Vec::new();
+
+    // 用于获取远程版本的 client
+    let client = reqwest::Client::builder()
+        .user_agent("cc-switch/1.0")
+        .build()
+        .map_err(|e| e.to_string())?;
+
+    for tool in tools {
+        // 1. 获取本地版本 - 先尝试直接执行，失败则扫描常见路径
+        let (local_version, local_error) = {
+            // 先尝试直接执行
+            let direct_result = try_get_version(tool);
+
+            if direct_result.0.is_some() {
+                direct_result
+            } else {
+                // 扫描常见的 npm 全局安装路径
+                scan_cli_version(tool)
+            }
+        };
+
+        // 2. 获取远程最新版本
+        let latest_version = match tool {
+            "claude" => fetch_npm_latest_version(&client, "@anthropic-ai/claude-code").await,
+            "codex" => fetch_npm_latest_version(&client, "@openai/codex").await,
+            "gemini" => fetch_npm_latest_version(&client, "@google/gemini-cli").await,
+            _ => None,
+        };
+
+        results.push(ToolVersion {
+            name: tool.to_string(),
+            version: local_version,
+            latest_version,
+            error: local_error,
+        });
+    }
+
+    Ok(results)
+}
+
+/// Helper function to fetch latest version from npm registry
+async fn fetch_npm_latest_version(client: &reqwest::Client, package: &str) -> Option<String> {
+    let url = format!("https://registry.npmjs.org/{package}");
+    match client.get(&url).send().await {
+        Ok(resp) => {
+            if let Ok(json) = resp.json::<serde_json::Value>().await {
+                json.get("dist-tags")
+                    .and_then(|tags| tags.get("latest"))
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string())
+            } else {
+                None
+            }
+        }
+        Err(_) => None,
+    }
+}
+
+/// 从版本输出中提取纯版本号
+fn extract_version(raw: &str) -> String {
+    // 匹配 semver 格式: x.y.z 或 x.y.z-xxx
+    let re = regex::Regex::new(r"\d+\.\d+\.\d+(-[\w.]+)?").unwrap();
+    re.find(raw)
+        .map(|m| m.as_str().to_string())
+        .unwrap_or_else(|| raw.to_string())
+}
+
+/// 尝试直接执行命令获取版本
+fn try_get_version(tool: &str) -> (Option<String>, Option<String>) {
+    use std::process::Command;
+
+    #[cfg(target_os = "windows")]
+    let output = {
+        Command::new("cmd")
+            .args(["/C", &format!("{tool} --version")])
+            .creation_flags(CREATE_NO_WINDOW)
+            .output()
+    };
+
+    #[cfg(not(target_os = "windows"))]
+    let output = {
+        Command::new("sh")
+            .arg("-c")
+            .arg(format!("{tool} --version"))
+            .output()
+    };
+
+    match output {
+        Ok(out) => {
+            let stdout = String::from_utf8_lossy(&out.stdout).trim().to_string();
+            let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
+            if out.status.success() {
+                let raw = if stdout.is_empty() { &stderr } else { &stdout };
+                if raw.is_empty() {
+                    (None, Some("未安装或无法执行".to_string()))
+                } else {
+                    (Some(extract_version(raw)), None)
+                }
+            } else {
+                let err = if stderr.is_empty() { stdout } else { stderr };
+                (
+                    None,
+                    Some(if err.is_empty() {
+                        "未安装或无法执行".to_string()
+                    } else {
+                        err
+                    }),
+                )
+            }
+        }
+        Err(e) => (None, Some(e.to_string())),
+    }
+}
+
+/// 扫描常见路径查找 CLI
+fn scan_cli_version(tool: &str) -> (Option<String>, Option<String>) {
+    use std::process::Command;
+
+    let home = dirs::home_dir().unwrap_or_default();
+
+    // 常见的 npm 全局安装路径
+    let mut search_paths: Vec<std::path::PathBuf> = vec![
+        home.join(".npm-global/bin"),
+        home.join(".local/bin"),
+        home.join("n/bin"), // n version manager
+    ];
+
+    #[cfg(target_os = "macos")]
+    {
+        search_paths.push(std::path::PathBuf::from("/opt/homebrew/bin"));
+        search_paths.push(std::path::PathBuf::from("/usr/local/bin"));
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        search_paths.push(std::path::PathBuf::from("/usr/local/bin"));
+        search_paths.push(std::path::PathBuf::from("/usr/bin"));
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        if let Some(appdata) = dirs::data_dir() {
+            search_paths.push(appdata.join("npm"));
+        }
+        search_paths.push(std::path::PathBuf::from("C:\\Program Files\\nodejs"));
+    }
+
+    // 扫描 nvm 目录下的所有 node 版本
+    let nvm_base = home.join(".nvm/versions/node");
+    if nvm_base.exists() {
+        if let Ok(entries) = std::fs::read_dir(&nvm_base) {
+            for entry in entries.flatten() {
+                let bin_path = entry.path().join("bin");
+                if bin_path.exists() {
+                    search_paths.push(bin_path);
+                }
+            }
+        }
+    }
+
+    // 在每个路径中查找工具
+    for path in &search_paths {
+        let tool_path = if cfg!(target_os = "windows") {
+            path.join(format!("{tool}.cmd"))
+        } else {
+            path.join(tool)
+        };
+
+        if tool_path.exists() {
+            // 构建 PATH 环境变量，确保 node 可被找到
+            let current_path = std::env::var("PATH").unwrap_or_default();
+            let new_path = format!("{}:{}", path.display(), current_path);
+
+            #[cfg(target_os = "windows")]
+            let output = {
+                Command::new(&tool_path)
+                    .arg("--version")
+                    .env("PATH", &new_path)
+                    .creation_flags(CREATE_NO_WINDOW)
+                    .output()
+            };
+
+            #[cfg(not(target_os = "windows"))]
+            let output = {
+                Command::new(&tool_path)
+                    .arg("--version")
+                    .env("PATH", &new_path)
+                    .output()
+            };
+
+            if let Ok(out) = output {
+                let stdout = String::from_utf8_lossy(&out.stdout).trim().to_string();
+                let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
+                if out.status.success() {
+                    let raw = if stdout.is_empty() { &stderr } else { &stdout };
+                    if !raw.is_empty() {
+                        return (Some(extract_version(raw)), None);
+                    }
+                }
+            }
+        }
+    }
+
+    (None, Some("未安装或无法执行".to_string()))
+}
@@ -3,29 +3,31 @@
 mod config;
 mod deeplink;
 mod env;
+mod failover;
 mod import_export;
 mod mcp;
 mod misc;
-mod model_test;
 mod plugin;
 mod prompt;
 mod provider;
 mod proxy;
 mod settings;
 pub mod skill;
+mod stream_check;
 mod usage;

 pub use config::*;
 pub use deeplink::*;
 pub use env::*;
+pub use failover::*;
 pub use import_export::*;
 pub use mcp::*;
 pub use misc::*;
-pub use model_test::*;
 pub use plugin::*;
 pub use prompt::*;
 pub use provider::*;
 pub use proxy::*;
 pub use settings::*;
 pub use skill::*;
+pub use stream_check::*;
 pub use usage::*;
@@ -1,128 +0,0 @@
-//! 模型测试相关命令
-
-use crate::app_config::AppType;
-use crate::error::AppError;
-use crate::services::model_test::{
-    ModelTestConfig, ModelTestLog, ModelTestResult, ModelTestService,
-};
-use crate::store::AppState;
-use tauri::State;
-
-/// 测试单个供应商的模型可用性
-#[tauri::command]
-pub async fn test_provider_model(
-    state: State<'_, AppState>,
-    app_type: AppType,
-    provider_id: String,
-) -> Result<ModelTestResult, AppError> {
-    // 获取测试配置
-    let config = state.db.get_model_test_config()?;
-
-    // 获取供应商
-    let providers = state.db.get_all_providers(app_type.as_str())?;
-    let provider = providers
-        .get(&provider_id)
-        .ok_or_else(|| AppError::Message(format!("供应商 {provider_id} 不存在")))?;
-
-    // 执行测试
-    let result = ModelTestService::test_provider(&app_type, provider, &config).await?;
-
-    // 记录日志
-    let _ = state.db.save_model_test_log(
-        &provider_id,
-        &provider.name,
-        app_type.as_str(),
-        &result.model_used,
-        &config.test_prompt,
-        &result,
-    );
-
-    Ok(result)
-}
-
-/// 批量测试所有供应商
-#[tauri::command]
-pub async fn test_all_providers_model(
-    state: State<'_, AppState>,
-    app_type: AppType,
-    proxy_targets_only: bool,
-) -> Result<Vec<(String, ModelTestResult)>, AppError> {
-    let config = state.db.get_model_test_config()?;
-    let providers = state.db.get_all_providers(app_type.as_str())?;
-
-    let mut results = Vec::new();
-
-    for (id, provider) in providers {
-        // 如果只测试代理目标，跳过非代理目标
-        if proxy_targets_only && !provider.is_proxy_target.unwrap_or(false) {
-            continue;
-        }
-
-        match ModelTestService::test_provider(&app_type, &provider, &config).await {
-            Ok(result) => {
-                // 记录日志
-                let _ = state.db.save_model_test_log(
-                    &id,
-                    &provider.name,
-                    app_type.as_str(),
-                    &result.model_used,
-                    &config.test_prompt,
-                    &result,
-                );
-                results.push((id, result));
-            }
-            Err(e) => {
-                let error_result = ModelTestResult {
-                    success: false,
-                    message: e.to_string(),
-                    response_time_ms: None,
-                    http_status: None,
-                    model_used: String::new(),
-                    tested_at: chrono::Utc::now().timestamp(),
-                };
-                results.push((id, error_result));
-            }
-        }
-    }
-
-    Ok(results)
-}
-
-/// 获取模型测试配置
-#[tauri::command]
-pub fn get_model_test_config(state: State<'_, AppState>) -> Result<ModelTestConfig, AppError> {
-    state.db.get_model_test_config()
-}
-
-/// 保存模型测试配置
-#[tauri::command]
-pub fn save_model_test_config(
-    state: State<'_, AppState>,
-    config: ModelTestConfig,
-) -> Result<(), AppError> {
-    state.db.save_model_test_config(&config)
-}
-
-/// 获取模型测试日志
-#[tauri::command]
-pub fn get_model_test_logs(
-    state: State<'_, AppState>,
-    app_type: Option<String>,
-    provider_id: Option<String>,
-    limit: Option<u32>,
-) -> Result<Vec<ModelTestLog>, AppError> {
-    state.db.get_model_test_logs(
-        app_type.as_deref(),
-        provider_id.as_deref(),
-        limit.unwrap_or(50),
-    )
-}
-
-/// 清理旧的测试日志
-#[tauri::command]
-pub fn cleanup_model_test_logs(
-    state: State<'_, AppState>,
-    keep_count: Option<u32>,
-) -> Result<u64, AppError> {
-    state.db.cleanup_model_test_logs(keep_count.unwrap_or(100))
-}
@@ -34,3 +34,15 @@ pub async fn apply_claude_plugin_config(official: bool) -> Result<bool, String>
 pub async fn is_claude_plugin_applied() -> Result<bool, String> {
    crate::claude_plugin::is_claude_config_applied().map_err(|e| e.to_string())
 }
+
+/// Claude Code：跳过初次安装确认（写入 ~/.claude.json 的 hasCompletedOnboarding=true）
+#[tauri::command]
+pub async fn apply_claude_onboarding_skip() -> Result<bool, String> {
+    crate::claude_mcp::set_has_completed_onboarding().map_err(|e| e.to_string())
+}
+
+/// Claude Code：恢复初次安装确认（删除 ~/.claude.json 的 hasCompletedOnboarding 字段）
+#[tauri::command]
+pub async fn clear_claude_onboarding_skip() -> Result<bool, String> {
+    crate::claude_mcp::clear_has_completed_onboarding().map_err(|e| e.to_string())
+}
@@ -86,19 +86,6 @@ pub fn switch_provider(
        .map_err(|e| e.to_string())
 }

-/// 设置代理目标供应商
-#[tauri::command]
-pub fn set_proxy_target_provider(
-    state: State<'_, AppState>,
-    app: String,
-    id: String,
-) -> Result<bool, String> {
-    let app_type = AppType::from_str(&app).map_err(|e| e.to_string())?;
-    ProviderService::set_proxy_target(state.inner(), app_type, &id)
-        .map(|_| true)
-        .map_err(|e| e.to_string())
-}
-
 fn import_default_config_internal(state: &AppState, app_type: AppType) -> Result<bool, AppError> {
    ProviderService::import_default_config(state, app_type)
 }
@@ -3,9 +3,10 @@
 //! 提供前端调用的 API 接口

 use crate::proxy::types::*;
+use crate::proxy::{CircuitBreakerConfig, CircuitBreakerStats};
 use crate::store::AppState;

-/// 启动代理服务器
+/// 启动代理服务器（仅启动服务，不接管 Live 配置）
 #[tauri::command]
 pub async fn start_proxy_server(
    state: tauri::State<'_, AppState>,
@@ -13,10 +14,31 @@ pub async fn start_proxy_server(
    state.proxy_service.start().await
 }

-/// 停止代理服务器
+/// 停止代理服务器（恢复 Live 配置）
 #[tauri::command]
-pub async fn stop_proxy_server(state: tauri::State<'_, AppState>) -> Result<(), String> {
-    state.proxy_service.stop().await
+pub async fn stop_proxy_with_restore(state: tauri::State<'_, AppState>) -> Result<(), String> {
+    state.proxy_service.stop_with_restore().await
+}
+
+/// 获取各应用接管状态
+#[tauri::command]
+pub async fn get_proxy_takeover_status(
+    state: tauri::State<'_, AppState>,
+) -> Result<ProxyTakeoverStatus, String> {
+    state.proxy_service.get_takeover_status().await
+}
+
+/// 为指定应用开启/关闭接管
+#[tauri::command]
+pub async fn set_proxy_takeover_for_app(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+    enabled: bool,
+) -> Result<(), String> {
+    state
+        .proxy_service
+        .set_takeover_for_app(&app_type, enabled)
+        .await
 }

 /// 获取代理服务器状态
@@ -45,3 +67,179 @@ pub async fn update_proxy_config(
 pub async fn is_proxy_running(state: tauri::State<'_, AppState>) -> Result<bool, String> {
    Ok(state.proxy_service.is_running().await)
 }
+
+/// 检查是否处于 Live 接管模式
+#[tauri::command]
+pub async fn is_live_takeover_active(state: tauri::State<'_, AppState>) -> Result<bool, String> {
+    state.proxy_service.is_takeover_active().await
+}
+
+/// 代理模式下切换供应商（热切换）
+#[tauri::command]
+pub async fn switch_proxy_provider(
+    state: tauri::State<'_, AppState>,
+    app_type: String,
+    provider_id: String,
+) -> Result<(), String> {
+    state
+        .proxy_service
+        .switch_proxy_target(&app_type, &provider_id)
+        .await
+}
+
+// ==================== 故障转移相关命令 ====================
+
+/// 获取供应商健康状态
+#[tauri::command]
+pub async fn get_provider_health(
+    state: tauri::State<'_, AppState>,
+    provider_id: String,
+    app_type: String,
+) -> Result<ProviderHealth, String> {
+    let db = &state.db;
+    db.get_provider_health(&provider_id, &app_type)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+/// 重置熔断器
+///
+/// 重置后会检查是否应该切回队列中优先级更高的供应商：
+/// 1. 检查自动故障转移是否开启
+/// 2. 如果恢复的供应商在队列中优先级更高（queue_order 更小），则自动切换
+#[tauri::command]
+pub async fn reset_circuit_breaker(
+    app_handle: tauri::AppHandle,
+    state: tauri::State<'_, AppState>,
+    provider_id: String,
+    app_type: String,
+) -> Result<(), String> {
+    // 1. 重置数据库健康状态
+    let db = &state.db;
+    db.update_provider_health(&provider_id, &app_type, true, None)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    // 2. 如果代理正在运行，重置内存中的熔断器状态
+    state
+        .proxy_service
+        .reset_provider_circuit_breaker(&provider_id, &app_type)
+        .await?;
+
+    // 3. 检查是否应该切回优先级更高的供应商
+    let failover_key = format!("auto_failover_enabled_{app_type}");
+    let auto_failover_enabled = match db.get_setting(&failover_key) {
+        Ok(Some(value)) => value == "true",
+        Ok(None) => {
+            log::debug!(
+                "[{app_type}] Failover setting '{failover_key}' not found, defaulting to disabled"
+            );
+            false
+        }
+        Err(e) => {
+            log::error!(
+                "[{app_type}] Failed to read failover setting '{failover_key}': {e}, defaulting to disabled"
+            );
+            false
+        }
+    };
+
+    if auto_failover_enabled && state.proxy_service.is_running().await {
+        // 获取当前供应商 ID
+        let current_id = db
+            .get_current_provider(&app_type)
+            .map_err(|e| e.to_string())?;
+
+        if let Some(current_id) = current_id {
+            // 获取故障转移队列
+            let queue = db
+                .get_failover_queue(&app_type)
+                .map_err(|e| e.to_string())?;
+
+            // 找到恢复的供应商和当前供应商在队列中的位置（使用 sort_index）
+            let restored_order = queue
+                .iter()
+                .find(|item| item.provider_id == provider_id)
+                .and_then(|item| item.sort_index);
+
+            let current_order = queue
+                .iter()
+                .find(|item| item.provider_id == current_id)
+                .and_then(|item| item.sort_index);
+
+            // 如果恢复的供应商优先级更高（sort_index 更小），则切换
+            if let (Some(restored), Some(current)) = (restored_order, current_order) {
+                if restored < current {
+                    log::info!(
+                        "[Recovery] 供应商 {provider_id} 已恢复且优先级更高 (P{restored} vs P{current})，自动切换"
+                    );
+
+                    // 获取供应商名称用于日志和事件
+                    let provider_name = db
+                        .get_all_providers(&app_type)
+                        .ok()
+                        .and_then(|providers| providers.get(&provider_id).map(|p| p.name.clone()))
+                        .unwrap_or_else(|| provider_id.clone());
+
+                    // 创建故障转移切换管理器并执行切换
+                    let switch_manager =
+                        crate::proxy::failover_switch::FailoverSwitchManager::new(db.clone());
+                    if let Err(e) = switch_manager
+                        .try_switch(Some(&app_handle), &app_type, &provider_id, &provider_name)
+                        .await
+                    {
+                        log::error!("[Recovery] 自动切换失败: {e}");
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// 获取熔断器配置
+#[tauri::command]
+pub async fn get_circuit_breaker_config(
+    state: tauri::State<'_, AppState>,
+) -> Result<CircuitBreakerConfig, String> {
+    let db = &state.db;
+    db.get_circuit_breaker_config()
+        .await
+        .map_err(|e| e.to_string())
+}
+
+/// 更新熔断器配置
+#[tauri::command]
+pub async fn update_circuit_breaker_config(
+    state: tauri::State<'_, AppState>,
+    config: CircuitBreakerConfig,
+) -> Result<(), String> {
+    let db = &state.db;
+
+    // 1. 更新数据库配置
+    db.update_circuit_breaker_config(&config)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    // 2. 如果代理正在运行，热更新内存中的熔断器配置
+    state
+        .proxy_service
+        .update_circuit_breaker_configs(config)
+        .await?;
+
+    Ok(())
+}
+
+/// 获取熔断器统计信息（仅当代理服务器运行时）
+#[tauri::command]
+pub async fn get_circuit_breaker_stats(
+    state: tauri::State<'_, AppState>,
+    provider_id: String,
+    app_type: String,
+) -> Result<Option<CircuitBreakerStats>, String> {
+    // 这个功能需要访问运行中的代理服务器的内存状态
+    // 目前先返回 None，后续可以通过 ProxyService 暴露接口来实现
+    let _ = (state, provider_id, app_type);
+    Ok(None)
+}
@@ -1,3 +1,4 @@
+use crate::app_config::AppType;
 use crate::error::format_skill_error;
 use crate::services::skill::SkillState;
 use crate::services::{Skill, SkillRepo, SkillService};
@@ -8,15 +9,46 @@ use tauri::State;

 pub struct SkillServiceState(pub Arc<SkillService>);

+/// 解析 app 参数为 AppType
+fn parse_app_type(app: &str) -> Result<AppType, String> {
+    match app.to_lowercase().as_str() {
+        "claude" => Ok(AppType::Claude),
+        "codex" => Ok(AppType::Codex),
+        "gemini" => Ok(AppType::Gemini),
+        _ => Err(format!("不支持的 app 类型: {app}")),
+    }
+}
+
+/// 根据 app_type 生成带前缀的 skill key
+fn get_skill_key(app_type: &AppType, directory: &str) -> String {
+    let prefix = match app_type {
+        AppType::Claude => "claude",
+        AppType::Codex => "codex",
+        AppType::Gemini => "gemini",
+    };
+    format!("{prefix}:{directory}")
+}
+
 #[tauri::command]
 pub async fn get_skills(
    service: State<'_, SkillServiceState>,
    app_state: State<'_, AppState>,
 ) -> Result<Vec<Skill>, String> {
+    get_skills_for_app("claude".to_string(), service, app_state).await
+}
+
+#[tauri::command]
+pub async fn get_skills_for_app(
+    app: String,
+    _service: State<'_, SkillServiceState>,
+    app_state: State<'_, AppState>,
+) -> Result<Vec<Skill>, String> {
+    let app_type = parse_app_type(&app)?;
+    let service = SkillService::new_for_app(app_type.clone()).map_err(|e| e.to_string())?;
+
    let repos = app_state.db.get_skill_repos().map_err(|e| e.to_string())?;

    let skills = service
-        .0
        .list_skills(repos)
        .await
        .map_err(|e| e.to_string())?;
@@ -26,16 +58,19 @@ pub async fn get_skills(
    let existing_states = app_state.db.get_skills().unwrap_or_default();

    for skill in &skills {
-        if skill.installed && !existing_states.contains_key(&skill.directory) {
-            // 本地有该 skill，但数据库中没有记录，自动添加
-            if let Err(e) = app_state.db.update_skill_state(
-                &skill.directory,
-                &SkillState {
-                    installed: true,
-                    installed_at: Utc::now(),
-                },
-            ) {
-                log::warn!("同步本地 skill {} 状态到数据库失败: {}", skill.directory, e);
+        if skill.installed {
+            let key = get_skill_key(&app_type, &skill.directory);
+            if !existing_states.contains_key(&key) {
+                // 本地有该 skill，但数据库中没有记录，自动添加
+                if let Err(e) = app_state.db.update_skill_state(
+                    &key,
+                    &SkillState {
+                        installed: true,
+                        installed_at: Utc::now(),
+                    },
+                ) {
+                    log::warn!("同步本地 skill {key} 状态到数据库失败: {e}");
+                }
            }
        }
    }
@@ -49,11 +84,23 @@ pub async fn install_skill(
    service: State<'_, SkillServiceState>,
    app_state: State<'_, AppState>,
 ) -> Result<bool, String> {
+    install_skill_for_app("claude".to_string(), directory, service, app_state).await
+}
+
+#[tauri::command]
+pub async fn install_skill_for_app(
+    app: String,
+    directory: String,
+    _service: State<'_, SkillServiceState>,
+    app_state: State<'_, AppState>,
+) -> Result<bool, String> {
+    let app_type = parse_app_type(&app)?;
+    let service = SkillService::new_for_app(app_type.clone()).map_err(|e| e.to_string())?;
+
    // 先在不持有写锁的情况下收集仓库与技能信息
    let repos = app_state.db.get_skill_repos().map_err(|e| e.to_string())?;

    let skills = service
-        .0
        .list_skills(repos)
        .await
        .map_err(|e| e.to_string())?;
@@ -93,16 +140,16 @@ pub async fn install_skill(
        };

        service
-            .0
            .install_skill(directory.clone(), repo)
            .await
            .map_err(|e| e.to_string())?;
    }

+    let key = get_skill_key(&app_type, &directory);
    app_state
        .db
        .update_skill_state(
-            &directory,
+            &key,
            &SkillState {
                installed: true,
                installed_at: Utc::now(),
@@ -119,16 +166,29 @@ pub fn uninstall_skill(
    service: State<'_, SkillServiceState>,
    app_state: State<'_, AppState>,
 ) -> Result<bool, String> {
+    uninstall_skill_for_app("claude".to_string(), directory, service, app_state)
+}
+
+#[tauri::command]
+pub fn uninstall_skill_for_app(
+    app: String,
+    directory: String,
+    _service: State<'_, SkillServiceState>,
+    app_state: State<'_, AppState>,
+) -> Result<bool, String> {
+    let app_type = parse_app_type(&app)?;
+    let service = SkillService::new_for_app(app_type.clone()).map_err(|e| e.to_string())?;
+
    service
-        .0
        .uninstall_skill(directory.clone())
        .map_err(|e| e.to_string())?;

    // Remove from database by setting installed = false
+    let key = get_skill_key(&app_type, &directory);
    app_state
        .db
        .update_skill_state(
-            &directory,
+            &key,
            &SkillState {
                installed: false,
                installed_at: Utc::now(),
@@ -0,0 +1,106 @@
+//! 流式健康检查命令
+
+use crate::app_config::AppType;
+use crate::error::AppError;
+use crate::services::stream_check::{
+    HealthStatus, StreamCheckConfig, StreamCheckResult, StreamCheckService,
+};
+use crate::store::AppState;
+use std::collections::HashSet;
+use tauri::State;
+
+/// 流式健康检查（单个供应商）
+#[tauri::command]
+pub async fn stream_check_provider(
+    state: State<'_, AppState>,
+    app_type: AppType,
+    provider_id: String,
+) -> Result<StreamCheckResult, AppError> {
+    let config = state.db.get_stream_check_config()?;
+
+    let providers = state.db.get_all_providers(app_type.as_str())?;
+    let provider = providers
+        .get(&provider_id)
+        .ok_or_else(|| AppError::Message(format!("供应商 {provider_id} 不存在")))?;
+
+    let result = StreamCheckService::check_with_retry(&app_type, provider, &config).await?;
+
+    // 记录日志
+    let _ =
+        state
+            .db
+            .save_stream_check_log(&provider_id, &provider.name, app_type.as_str(), &result);
+
+    Ok(result)
+}
+
+/// 批量流式健康检查
+#[tauri::command]
+pub async fn stream_check_all_providers(
+    state: State<'_, AppState>,
+    app_type: AppType,
+    proxy_targets_only: bool,
+) -> Result<Vec<(String, StreamCheckResult)>, AppError> {
+    let config = state.db.get_stream_check_config()?;
+    let providers = state.db.get_all_providers(app_type.as_str())?;
+
+    let mut results = Vec::new();
+    let allowed_ids: Option<HashSet<String>> = if proxy_targets_only {
+        let mut ids = HashSet::new();
+        if let Ok(Some(current_id)) = state.db.get_current_provider(app_type.as_str()) {
+            ids.insert(current_id);
+        }
+        if let Ok(queue) = state.db.get_failover_queue(app_type.as_str()) {
+            for item in queue {
+                ids.insert(item.provider_id);
+            }
+        }
+        Some(ids)
+    } else {
+        None
+    };
+
+    for (id, provider) in providers {
+        if let Some(ids) = &allowed_ids {
+            if !ids.contains(&id) {
+                continue;
+            }
+        }
+
+        let result = StreamCheckService::check_with_retry(&app_type, &provider, &config)
+            .await
+            .unwrap_or_else(|e| StreamCheckResult {
+                status: HealthStatus::Failed,
+                success: false,
+                message: e.to_string(),
+                response_time_ms: None,
+                http_status: None,
+                model_used: String::new(),
+                tested_at: chrono::Utc::now().timestamp(),
+                retry_count: 0,
+            });
+
+        let _ = state
+            .db
+            .save_stream_check_log(&id, &provider.name, app_type.as_str(), &result);
+
+        results.push((id, result));
+    }
+
+    Ok(results)
+}
+
+/// 获取流式检查配置
+#[tauri::command]
+pub fn get_stream_check_config(state: State<'_, AppState>) -> Result<StreamCheckConfig, AppError> {
+    state.db.get_stream_check_config()
+}
+
+/// 保存流式检查配置
+#[tauri::command]
+pub fn save_stream_check_config(
+    state: State<'_, AppState>,
+    config: StreamCheckConfig,
+) -> Result<(), AppError> {
+    state.db.save_stream_check_config(&config)
+}
@@ -13,6 +13,8 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use tempfile::NamedTempFile;

+const CC_SWITCH_SQL_EXPORT_HEADER: &str = "-- CC Switch SQLite 导出";
+
 impl Database {
    /// 导出为 SQLite 兼容的 SQL 文本
    pub fn export_sql(&self, target_path: &Path) -> Result<(), AppError> {
@@ -36,7 +38,8 @@ impl Database {
        }

        let sql_raw = fs::read_to_string(source_path).map_err(|e| AppError::io(source_path, e))?;
-        let sql_content = Self::sanitize_import_sql(&sql_raw);
+        let sql_content = sql_raw.trim_start_matches('\u{feff}');
+        Self::validate_cc_switch_sql_export(sql_content)?;

        // 导入前备份现有数据库
        let backup_path = self.backup_database_file()?;
@@ -51,7 +54,7 @@ impl Database {
            Connection::open(&temp_path).map_err(|e| AppError::Database(e.to_string()))?;

        temp_conn
-            .execute_batch(&sql_content)
+            .execute_batch(sql_content)
            .map_err(|e| AppError::Database(format!("执行 SQL 导入失败: {e}")))?;

        // 补齐缺失表/索引并进行基础校验
@@ -93,26 +96,17 @@ impl Database {
        Ok(snapshot)
    }

-    /// 移除 SQLite 保留对象相关语句（如 sqlite_sequence），避免导入报错
-    fn sanitize_import_sql(sql: &str) -> String {
-        let mut cleaned = String::new();
-        let lower_keyword = "sqlite_sequence";
-
-        for stmt in sql.split(';') {
-            let trimmed = stmt.trim();
-            if trimmed.is_empty() {
-                continue;
-            }
-
-            if trimmed.to_ascii_lowercase().contains(lower_keyword) {
-                continue;
-            }
-
-            cleaned.push_str(trimmed);
-            cleaned.push_str(";\n");
+    fn validate_cc_switch_sql_export(sql: &str) -> Result<(), AppError> {
+        let trimmed = sql.trim_start();
+        if trimmed.starts_with(CC_SWITCH_SQL_EXPORT_HEADER) {
+            return Ok(());
        }

-        cleaned
+        Err(AppError::localized(
+            "backup.sql.invalid_format",
+            "仅支持导入由 CC Switch 导出的 SQL 备份文件。",
+            "Only SQL backups exported by CC Switch are supported.",
+        ))
    }

    /// 生成一致性快照备份，返回备份文件路径（不存在主库时返回 None）
@@ -129,8 +123,15 @@ impl Database {

        fs::create_dir_all(&backup_dir).map_err(|e| AppError::io(&backup_dir, e))?;

-        let backup_id = format!("db_backup_{}", Utc::now().format("%Y%m%d_%H%M%S"));
-        let backup_path = backup_dir.join(format!("{backup_id}.db"));
+        let base_id = format!("db_backup_{}", Utc::now().format("%Y%m%d_%H%M%S"));
+        let mut backup_id = base_id.clone();
+        let mut backup_path = backup_dir.join(format!("{backup_id}.db"));
+        let mut counter = 1;
+        while backup_path.exists() {
+            backup_id = format!("{base_id}_{counter}");
+            backup_path = backup_dir.join(format!("{backup_id}.db"));
+            counter += 1;
+        }

        {
            let conn = lock_conn!(self.conn);
@@ -0,0 +1,146 @@
+//! 故障转移队列 DAO
+//!
+//! 管理代理模式下的故障转移队列（基于 providers 表的 in_failover_queue 字段）
+
+use crate::database::{lock_conn, Database};
+use crate::error::AppError;
+use crate::provider::Provider;
+use serde::{Deserialize, Serialize};
+
+/// 故障转移队列条目（简化版，用于前端展示）
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FailoverQueueItem {
+    pub provider_id: String,
+    pub provider_name: String,
+    pub sort_index: Option<usize>,
+}
+
+impl Database {
+    /// 获取故障转移队列（按 sort_index 排序）
+    pub fn get_failover_queue(&self, app_type: &str) -> Result<Vec<FailoverQueueItem>, AppError> {
+        let conn = lock_conn!(self.conn);
+
+        let mut stmt = conn
+            .prepare(
+                "SELECT id, name, sort_index
+                 FROM providers
+                 WHERE app_type = ?1 AND in_failover_queue = 1
+                 ORDER BY COALESCE(sort_index, 999999), id ASC",
+            )
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        let items = stmt
+            .query_map([app_type], |row| {
+                Ok(FailoverQueueItem {
+                    provider_id: row.get(0)?,
+                    provider_name: row.get(1)?,
+                    sort_index: row.get(2)?,
+                })
+            })
+            .map_err(|e| AppError::Database(e.to_string()))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        Ok(items)
+    }
+
+    /// 获取故障转移队列中的供应商（完整 Provider 信息，按顺序）
+    pub fn get_failover_providers(&self, app_type: &str) -> Result<Vec<Provider>, AppError> {
+        let all_providers = self.get_all_providers(app_type)?;
+
+        let result: Vec<Provider> = all_providers
+            .into_values()
+            .filter(|p| p.in_failover_queue)
+            .collect();
+
+        Ok(result)
+    }
+
+    /// 添加供应商到故障转移队列
+    pub fn add_to_failover_queue(&self, app_type: &str, provider_id: &str) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+
+        conn.execute(
+            "UPDATE providers SET in_failover_queue = 1 WHERE id = ?1 AND app_type = ?2",
+            rusqlite::params![provider_id, app_type],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+
+    /// 从故障转移队列中移除供应商
+    pub fn remove_from_failover_queue(
+        &self,
+        app_type: &str,
+        provider_id: &str,
+    ) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+
+        // 1. 从队列中移除
+        conn.execute(
+            "UPDATE providers SET in_failover_queue = 0 WHERE id = ?1 AND app_type = ?2",
+            rusqlite::params![provider_id, app_type],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        // 2. 清除该供应商的健康状态（退出队列后不再需要健康监控）
+        conn.execute(
+            "DELETE FROM provider_health WHERE provider_id = ?1 AND app_type = ?2",
+            rusqlite::params![provider_id, app_type],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        log::info!("已从故障转移队列移除供应商 {provider_id} ({app_type}), 并清除其健康状态");
+
+        Ok(())
+    }
+
+    /// 清空故障转移队列
+    pub fn clear_failover_queue(&self, app_type: &str) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+
+        conn.execute(
+            "UPDATE providers SET in_failover_queue = 0 WHERE app_type = ?1",
+            [app_type],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+
+    /// 检查供应商是否在故障转移队列中
+    pub fn is_in_failover_queue(
+        &self,
+        app_type: &str,
+        provider_id: &str,
+    ) -> Result<bool, AppError> {
+        let conn = lock_conn!(self.conn);
+
+        let in_queue: bool = conn
+            .query_row(
+                "SELECT in_failover_queue FROM providers WHERE id = ?1 AND app_type = ?2",
+                rusqlite::params![provider_id, app_type],
+                |row| row.get(0),
+            )
+            .unwrap_or(false);
+
+        Ok(in_queue)
+    }
+
+    /// 获取可添加到故障转移队列的供应商（不在队列中的）
+    pub fn get_available_providers_for_failover(
+        &self,
+        app_type: &str,
+    ) -> Result<Vec<Provider>, AppError> {
+        let all_providers = self.get_all_providers(app_type)?;
+
+        let available: Vec<Provider> = all_providers
+            .into_values()
+            .filter(|p| !p.in_failover_queue)
+            .collect();
+
+        Ok(available)
+    }
+}
@@ -2,11 +2,15 @@
 //!
 //! Database access operations for each domain

+pub mod failover;
 pub mod mcp;
 pub mod prompts;
 pub mod providers;
 pub mod proxy;
 pub mod settings;
 pub mod skills;
+pub mod stream_check;

 // 所有 DAO 方法都通过 Database impl 提供，无需单独导出
+// 导出 FailoverQueueItem 供外部使用
+pub use failover::FailoverQueueItem;
@@ -17,7 +17,7 @@ impl Database {
    ) -> Result<IndexMap<String, Provider>, AppError> {
        let conn = lock_conn!(self.conn);
        let mut stmt = conn.prepare(
-            "SELECT id, name, settings_config, website_url, category, created_at, sort_index, notes, icon, icon_color, meta, is_proxy_target
+            "SELECT id, name, settings_config, website_url, category, created_at, sort_index, notes, icon, icon_color, meta, in_failover_queue
             FROM providers WHERE app_type = ?1
             ORDER BY COALESCE(sort_index, 999999), created_at ASC, id ASC"
        ).map_err(|e| AppError::Database(e.to_string()))?;
@@ -35,7 +35,7 @@ impl Database {
                let icon: Option<String> = row.get(8)?;
                let icon_color: Option<String> = row.get(9)?;
                let meta_str: String = row.get(10)?;
-                let is_proxy_target: bool = row.get(11)?;
+                let in_failover_queue: bool = row.get(11)?;

                let settings_config =
                    serde_json::from_str(&settings_config_str).unwrap_or(serde_json::Value::Null);
@@ -55,7 +55,7 @@ impl Database {
                        meta: Some(meta),
                        icon,
                        icon_color,
-                        is_proxy_target: Some(is_proxy_target),
+                        in_failover_queue,
                    },
                ))
            })
@@ -131,7 +131,7 @@ impl Database {
    ) -> Result<Option<Provider>, AppError> {
        let conn = lock_conn!(self.conn);
        let result = conn.query_row(
-            "SELECT name, settings_config, website_url, category, created_at, sort_index, notes, icon, icon_color, meta, is_proxy_target
+            "SELECT name, settings_config, website_url, category, created_at, sort_index, notes, icon, icon_color, meta, in_failover_queue
             FROM providers WHERE id = ?1 AND app_type = ?2",
            params![id, app_type],
            |row| {
@@ -145,7 +145,7 @@ impl Database {
                let icon: Option<String> = row.get(7)?;
                let icon_color: Option<String> = row.get(8)?;
                let meta_str: String = row.get(9)?;
-                let is_proxy_target: bool = row.get(10)?;
+                let in_failover_queue: bool = row.get(10)?;

                let settings_config = serde_json::from_str(&settings_config_str).unwrap_or(serde_json::Value::Null);
                let meta: ProviderMeta = serde_json::from_str(&meta_str).unwrap_or_default();
@@ -162,7 +162,7 @@ impl Database {
                    meta: Some(meta),
                    icon,
                    icon_color,
-                    is_proxy_target: Some(is_proxy_target),
+                    in_failover_queue,
                })
            },
        );
@@ -174,26 +174,6 @@ impl Database {
        }
    }

-    /// 获取代理目标供应商 ID
-    pub fn get_proxy_target_provider(&self, app_type: &str) -> Result<Option<String>, AppError> {
-        let conn = lock_conn!(self.conn);
-        let mut stmt = conn
-            .prepare("SELECT id FROM providers WHERE app_type = ?1 AND is_proxy_target = 1 LIMIT 1")
-            .map_err(|e| AppError::Database(e.to_string()))?;
-
-        let mut rows = stmt
-            .query(params![app_type])
-            .map_err(|e| AppError::Database(e.to_string()))?;
-
-        if let Some(row) = rows.next().map_err(|e| AppError::Database(e.to_string()))? {
-            Ok(Some(
-                row.get(0).map_err(|e| AppError::Database(e.to_string()))?,
-            ))
-        } else {
-            Ok(None)
-        }
-    }
-
    /// 保存供应商（新增或更新）
    ///
    /// 注意：更新模式下不同步 endpoints，因为编辑模式下端点通过单独的 API 管理
@@ -208,17 +188,18 @@ impl Database {
        let mut meta_clone = provider.meta.clone().unwrap_or_default();
        let endpoints = std::mem::take(&mut meta_clone.custom_endpoints);

-        // 检查是否存在（用于判断新增/更新，以及保留 is_current 和 is_proxy_target）
+        // 检查是否存在（用于判断新增/更新，以及保留 is_current 和 in_failover_queue）
        let existing: Option<(bool, bool)> = tx
            .query_row(
-                "SELECT is_current, is_proxy_target FROM providers WHERE id = ?1 AND app_type = ?2",
+                "SELECT is_current, in_failover_queue FROM providers WHERE id = ?1 AND app_type = ?2",
                params![provider.id, app_type],
                |row| Ok((row.get(0)?, row.get(1)?)),
            )
            .ok();

        let is_update = existing.is_some();
-        let (is_current, is_proxy_target) = existing.unwrap_or((false, false));
+        let (is_current, in_failover_queue) =
+            existing.unwrap_or((false, provider.in_failover_queue));

        if is_update {
            // 更新模式：使用 UPDATE 避免触发 ON DELETE CASCADE
@@ -235,7 +216,7 @@ impl Database {
                    icon_color = ?9,
                    meta = ?10,
                    is_current = ?11,
-                    is_proxy_target = ?12
+                    in_failover_queue = ?12
                WHERE id = ?13 AND app_type = ?14",
                params![
                    provider.name,
@@ -249,7 +230,7 @@ impl Database {
                    provider.icon_color,
                    serde_json::to_string(&meta_clone).unwrap(),
                    is_current,
-                    is_proxy_target,
+                    in_failover_queue,
                    provider.id,
                    app_type,
                ],
@@ -260,7 +241,7 @@ impl Database {
            tx.execute(
                "INSERT INTO providers (
                    id, app_type, name, settings_config, website_url, category,
-                    created_at, sort_index, notes, icon, icon_color, meta, is_current, is_proxy_target
+                    created_at, sort_index, notes, icon, icon_color, meta, is_current, in_failover_queue
                ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14)",
                params![
                    provider.id,
@@ -276,7 +257,7 @@ impl Database {
                    provider.icon_color,
                    serde_json::to_string(&meta_clone).unwrap(),
                    is_current,
-                    is_proxy_target,
+                    in_failover_queue,
                ],
            )
            .map_err(|e| AppError::Database(e.to_string()))?;
@@ -332,45 +313,24 @@ impl Database {
        Ok(())
    }

-    /// 设置代理目标供应商
-    pub fn set_proxy_target_provider(&self, app_type: &str, id: &str) -> Result<(), AppError> {
-        let mut conn = lock_conn!(self.conn);
-        let tx = conn
-            .transaction()
-            .map_err(|e| AppError::Database(e.to_string()))?;
-
-        // 重置所有为 0
-        tx.execute(
-            "UPDATE providers SET is_proxy_target = 0 WHERE app_type = ?1",
-            params![app_type],
-        )
-        .map_err(|e| AppError::Database(e.to_string()))?;
-
-        // 设置新的代理目标供应商
-        tx.execute(
-            "UPDATE providers SET is_proxy_target = 1 WHERE id = ?1 AND app_type = ?2",
-            params![id, app_type],
-        )
-        .map_err(|e| AppError::Database(e.to_string()))?;
-
-        tx.commit().map_err(|e| AppError::Database(e.to_string()))?;
-        Ok(())
-    }
-
-    /// 获取所有活跃的代理目标
-    pub fn get_all_proxy_targets(&self) -> Result<Vec<(String, String, String)>, AppError> {
+    /// 更新供应商的 settings_config（仅更新配置，不改变其他字段）
+    pub fn update_provider_settings_config(
+        &self,
+        app_type: &str,
+        provider_id: &str,
+        settings_config: &serde_json::Value,
+    ) -> Result<(), AppError> {
        let conn = lock_conn!(self.conn);
-        let mut stmt = conn
-            .prepare("SELECT app_type, name, id FROM providers WHERE is_proxy_target = 1")
-            .map_err(|e| AppError::Database(e.to_string()))?;
-
-        let targets = stmt
-            .query_map([], |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)))
-            .map_err(|e| AppError::Database(e.to_string()))?
-            .collect::<Result<Vec<_>, _>>()
-            .map_err(|e| AppError::Database(e.to_string()))?;
-
-        Ok(targets)
+        conn.execute(
+            "UPDATE providers SET settings_config = ?1 WHERE id = ?2 AND app_type = ?3",
+            params![
+                serde_json::to_string(settings_config).unwrap(),
+                provider_id,
+                app_type
+            ],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+        Ok(())
    }

    /// 添加自定义端点
@@ -16,18 +16,18 @@ impl Database {
        let result = {
            let conn = lock_conn!(self.conn);
            conn.query_row(
-                "SELECT enabled, listen_address, listen_port, max_retries,
-                        request_timeout, enable_logging
+                "SELECT listen_address, listen_port, max_retries,
+                        request_timeout, enable_logging, live_takeover_active
                 FROM proxy_config WHERE id = 1",
                [],
                |row| {
                    Ok(ProxyConfig {
-                        enabled: row.get::<_, i32>(0)? != 0,
-                        listen_address: row.get(1)?,
-                        listen_port: row.get::<_, i32>(2)? as u16,
-                        max_retries: row.get::<_, i32>(3)? as u8,
-                        request_timeout: row.get::<_, i32>(4)? as u64,
-                        enable_logging: row.get::<_, i32>(5)? != 0,
+                        listen_address: row.get(0)?,
+                        listen_port: row.get::<_, i32>(1)? as u16,
+                        max_retries: row.get::<_, i32>(2)? as u8,
+                        request_timeout: row.get::<_, i32>(3)? as u64,
+                        enable_logging: row.get::<_, i32>(4)? != 0,
+                        live_takeover_active: row.get::<_, i32>(5).unwrap_or(0) != 0,
                    })
                },
            )
@@ -51,17 +51,18 @@ impl Database {

        conn.execute(
            "INSERT OR REPLACE INTO proxy_config
-             (id, enabled, listen_address, listen_port, max_retries, request_timeout, enable_logging, target_app, created_at, updated_at)
-             VALUES (1, ?1, ?2, ?3, ?4, ?5, ?6, ?7,
+             (id, enabled, listen_address, listen_port, max_retries, request_timeout, enable_logging, live_takeover_active, target_app, created_at, updated_at)
+             VALUES (1, ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8,
                     COALESCE((SELECT created_at FROM proxy_config WHERE id = 1), datetime('now')),
                     datetime('now'))",
            rusqlite::params![
-                if config.enabled { 1 } else { 0 },
+                0, // 已移除自动启用逻辑，保留列但固定为 0
                config.listen_address,
                config.listen_port as i32,
                config.max_retries as i32,
                config.request_timeout as i32,
                if config.enable_logging { 1 } else { 0 },
+                if config.live_takeover_active { 1 } else { 0 },
                "claude", // 兼容旧字段，写入默认值
            ],
        )
@@ -70,6 +71,29 @@ impl Database {
        Ok(())
    }

+    /// 设置 Live 接管状态（仅更新 proxy_config 表，兼容旧逻辑）
+    ///
+    /// 注意：此方法不会清除 settings 表中的 proxy_takeover_* 状态。
+    /// settings 表的状态由 set_proxy_takeover_enabled 单独管理，用于跨重启保持状态。
+    pub async fn set_live_takeover_active(&self, active: bool) -> Result<(), AppError> {
+        // 仅更新 proxy_config 表（兼容旧版本）
+        let conn = lock_conn!(self.conn);
+        conn.execute(
+            "UPDATE proxy_config SET live_takeover_active = ?1, updated_at = datetime('now') WHERE id = 1",
+            rusqlite::params![if active { 1 } else { 0 }],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+
+    /// 检查是否处于 Live 接管模式
+    ///
+    /// v3.8.0+：以 settings 表中的 `proxy_takeover_{app_type}` 为真实来源
+    pub async fn is_live_takeover_active(&self) -> Result<bool, AppError> {
+        self.has_any_proxy_takeover()
+    }
+
    // ==================== Provider Health ====================

    /// 获取Provider健康状态
@@ -78,37 +102,73 @@ impl Database {
        provider_id: &str,
        app_type: &str,
    ) -> Result<ProviderHealth, AppError> {
-        let conn = lock_conn!(self.conn);
+        let result = {
+            let conn = lock_conn!(self.conn);

-        conn.query_row(
-            "SELECT provider_id, app_type, is_healthy, consecutive_failures,
-                    last_success_at, last_failure_at, last_error, updated_at
-             FROM provider_health
-             WHERE provider_id = ?1 AND app_type = ?2",
-            rusqlite::params![provider_id, app_type],
-            |row| {
-                Ok(ProviderHealth {
-                    provider_id: row.get(0)?,
-                    app_type: row.get(1)?,
-                    is_healthy: row.get::<_, i64>(2)? != 0,
-                    consecutive_failures: row.get::<_, i64>(3)? as u32,
-                    last_success_at: row.get(4)?,
-                    last_failure_at: row.get(5)?,
-                    last_error: row.get(6)?,
-                    updated_at: row.get(7)?,
-                })
-            },
-        )
-        .map_err(|e| AppError::Database(e.to_string()))
+            conn.query_row(
+                "SELECT provider_id, app_type, is_healthy, consecutive_failures,
+                        last_success_at, last_failure_at, last_error, updated_at
+                 FROM provider_health
+                 WHERE provider_id = ?1 AND app_type = ?2",
+                rusqlite::params![provider_id, app_type],
+                |row| {
+                    Ok(ProviderHealth {
+                        provider_id: row.get(0)?,
+                        app_type: row.get(1)?,
+                        is_healthy: row.get::<_, i64>(2)? != 0,
+                        consecutive_failures: row.get::<_, i64>(3)? as u32,
+                        last_success_at: row.get(4)?,
+                        last_failure_at: row.get(5)?,
+                        last_error: row.get(6)?,
+                        updated_at: row.get(7)?,
+                    })
+                },
+            )
+        };
+
+        match result {
+            Ok(health) => Ok(health),
+            // 缺少记录时视为健康（关闭后清空状态，再次打开时默认正常）
+            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(ProviderHealth {
+                provider_id: provider_id.to_string(),
+                app_type: app_type.to_string(),
+                is_healthy: true,
+                consecutive_failures: 0,
+                last_success_at: None,
+                last_failure_at: None,
+                last_error: None,
+                updated_at: chrono::Utc::now().to_rfc3339(),
+            }),
+            Err(e) => Err(AppError::Database(e.to_string())),
+        }
    }

    /// 更新Provider健康状态
+    ///
+    /// 使用默认阈值（5）判断是否健康，建议使用 `update_provider_health_with_threshold` 传入配置的阈值
    pub async fn update_provider_health(
        &self,
        provider_id: &str,
        app_type: &str,
        success: bool,
        error_msg: Option<String>,
+    ) -> Result<(), AppError> {
+        // 默认阈值与 CircuitBreakerConfig::default() 保持一致
+        self.update_provider_health_with_threshold(provider_id, app_type, success, error_msg, 5)
+            .await
+    }
+
+    /// 更新Provider健康状态（带阈值参数）
+    ///
+    /// # Arguments
+    /// * `failure_threshold` - 连续失败多少次后标记为不健康
+    pub async fn update_provider_health_with_threshold(
+        &self,
+        provider_id: &str,
+        app_type: &str,
+        success: bool,
+        error_msg: Option<String>,
+        failure_threshold: u32,
    ) -> Result<(), AppError> {
        let conn = lock_conn!(self.conn);

@@ -116,7 +176,7 @@ impl Database {

        // 先查询当前状态
        let current = conn.query_row(
-            "SELECT consecutive_failures FROM provider_health 
+            "SELECT consecutive_failures FROM provider_health
             WHERE provider_id = ?1 AND app_type = ?2",
            rusqlite::params![provider_id, app_type],
            |row| Ok(row.get::<_, i64>(0)? as u32),
@@ -128,7 +188,8 @@ impl Database {
        } else {
            // 失败：增加失败计数
            let failures = current.unwrap_or(0) + 1;
-            let healthy = if failures >= 3 { 0 } else { 1 };
+            // 使用传入的阈值而非硬编码
+            let healthy = if failures >= failure_threshold { 0 } else { 1 };
            (healthy, failures)
        };

@@ -143,10 +204,10 @@ impl Database {
            "INSERT OR REPLACE INTO provider_health
             (provider_id, app_type, is_healthy, consecutive_failures,
              last_success_at, last_failure_at, last_error, updated_at)
-             VALUES (?1, ?2, ?3, ?4, 
-                     COALESCE(?5, (SELECT last_success_at FROM provider_health 
+             VALUES (?1, ?2, ?3, ?4,
+                     COALESCE(?5, (SELECT last_success_at FROM provider_health
                                   WHERE provider_id = ?1 AND app_type = ?2)),
-                     COALESCE(?6, (SELECT last_failure_at FROM provider_health 
+                     COALESCE(?6, (SELECT last_failure_at FROM provider_health
                                   WHERE provider_id = ?1 AND app_type = ?2)),
                     ?7, ?8)",
            rusqlite::params![
@@ -165,28 +226,101 @@ impl Database {
        Ok(())
    }

-    // ==================== Proxy Usage (可选) ====================
-
-    /// 记录代理使用统计
-    #[allow(dead_code)]
-    pub async fn record_proxy_usage(&self, record: &ProxyUsageRecord) -> Result<(), AppError> {
+    /// 重置Provider健康状态
+    pub async fn reset_provider_health(
+        &self,
+        provider_id: &str,
+        app_type: &str,
+    ) -> Result<(), AppError> {
        let conn = lock_conn!(self.conn);

        conn.execute(
-            "INSERT INTO proxy_usage 
-             (provider_id, app_type, endpoint, request_tokens, response_tokens,
-              status_code, latency_ms, error, timestamp)
-             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
+            "DELETE FROM provider_health WHERE provider_id = ?1 AND app_type = ?2",
+            rusqlite::params![provider_id, app_type],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        log::debug!("Reset health status for provider {provider_id} (app: {app_type})");
+
+        Ok(())
+    }
+
+    /// 清空指定应用的健康状态（关闭单个代理时使用）
+    pub async fn clear_provider_health_for_app(&self, app_type: &str) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+
+        conn.execute(
+            "DELETE FROM provider_health WHERE app_type = ?1",
+            [app_type],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        log::debug!("Cleared provider health records for app {app_type}");
+        Ok(())
+    }
+
+    /// 清空所有Provider健康状态（代理停止时调用）
+    pub async fn clear_all_provider_health(&self) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+
+        conn.execute("DELETE FROM provider_health", [])
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        log::debug!("Cleared all provider health records");
+        Ok(())
+    }
+
+    // ==================== Circuit Breaker Config ====================
+
+    /// 获取熔断器配置
+    pub async fn get_circuit_breaker_config(
+        &self,
+    ) -> Result<crate::proxy::circuit_breaker::CircuitBreakerConfig, AppError> {
+        let conn = lock_conn!(self.conn);
+
+        let config = conn
+            .query_row(
+                "SELECT failure_threshold, success_threshold, timeout_seconds,
+                        error_rate_threshold, min_requests
+                 FROM circuit_breaker_config WHERE id = 1",
+                [],
+                |row| {
+                    Ok(crate::proxy::circuit_breaker::CircuitBreakerConfig {
+                        failure_threshold: row.get::<_, i32>(0)? as u32,
+                        success_threshold: row.get::<_, i32>(1)? as u32,
+                        timeout_seconds: row.get::<_, i64>(2)? as u64,
+                        error_rate_threshold: row.get(3)?,
+                        min_requests: row.get::<_, i32>(4)? as u32,
+                    })
+                },
+            )
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        Ok(config)
+    }
+
+    /// 更新熔断器配置
+    pub async fn update_circuit_breaker_config(
+        &self,
+        config: &crate::proxy::circuit_breaker::CircuitBreakerConfig,
+    ) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+
+        conn.execute(
+            "UPDATE circuit_breaker_config
+             SET failure_threshold = ?1,
+                 success_threshold = ?2,
+                 timeout_seconds = ?3,
+                 error_rate_threshold = ?4,
+                 min_requests = ?5,
+                 updated_at = CURRENT_TIMESTAMP
+             WHERE id = 1",
            rusqlite::params![
-                &record.provider_id,
-                &record.app_type,
-                &record.endpoint,
-                record.request_tokens,
-                record.response_tokens,
-                record.status_code as i64,
-                record.latency_ms as i64,
-                &record.error,
-                &record.timestamp,
+                config.failure_threshold as i32,
+                config.success_threshold as i32,
+                config.timeout_seconds as i64,
+                config.error_rate_threshold,
+                config.min_requests as i32,
            ],
        )
        .map_err(|e| AppError::Database(e.to_string()))?;
@@ -194,51 +328,84 @@ impl Database {
        Ok(())
    }

-    /// 查询最近的使用统计
-    #[allow(dead_code)]
-    pub async fn get_recent_usage(
+    // ==================== Live Backup ====================
+
+    /// 保存 Live 配置备份
+    pub async fn save_live_backup(
        &self,
-        provider_id: &str,
        app_type: &str,
-        limit: usize,
-    ) -> Result<Vec<ProxyUsageRecord>, AppError> {
+        config_json: &str,
+    ) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+        let now = chrono::Utc::now().to_rfc3339();
+
+        conn.execute(
+            "INSERT OR REPLACE INTO proxy_live_backup (app_type, original_config, backed_up_at)
+             VALUES (?1, ?2, ?3)",
+            rusqlite::params![app_type, config_json, now],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        log::info!("已备份 {app_type} Live 配置");
+        Ok(())
+    }
+
+    /// 检查是否存在任意 Live 配置备份
+    pub async fn has_any_live_backup(&self) -> Result<bool, AppError> {
+        let conn = lock_conn!(self.conn);
+        let count: i64 = conn
+            .query_row("SELECT COUNT(*) FROM proxy_live_backup", [], |row| {
+                row.get(0)
+            })
+            .map_err(|e| AppError::Database(e.to_string()))?;
+        Ok(count > 0)
+    }
+
+    /// 获取 Live 配置备份
+    pub async fn get_live_backup(&self, app_type: &str) -> Result<Option<LiveBackup>, AppError> {
        let conn = lock_conn!(self.conn);

-        let mut stmt = conn
-            .prepare(
-                "SELECT provider_id, app_type, endpoint, request_tokens, response_tokens,
-                        status_code, latency_ms, error, timestamp
-                 FROM proxy_usage
-                 WHERE provider_id = ?1 AND app_type = ?2
-                 ORDER BY timestamp DESC
-                 LIMIT ?3",
-            )
-            .map_err(|e| AppError::Database(e.to_string()))?;
+        let result = conn.query_row(
+            "SELECT app_type, original_config, backed_up_at FROM proxy_live_backup WHERE app_type = ?1",
+            rusqlite::params![app_type],
+            |row| {
+                Ok(LiveBackup {
+                    app_type: row.get(0)?,
+                    original_config: row.get(1)?,
+                    backed_up_at: row.get(2)?,
+                })
+            },
+        );

-        let rows = stmt
-            .query_map(
-                rusqlite::params![provider_id, app_type, limit as i64],
-                |row| {
-                    Ok(ProxyUsageRecord {
-                        provider_id: row.get(0)?,
-                        app_type: row.get(1)?,
-                        endpoint: row.get(2)?,
-                        request_tokens: row.get(3)?,
-                        response_tokens: row.get(4)?,
-                        status_code: row.get::<_, i64>(5)? as u16,
-                        latency_ms: row.get::<_, i64>(6)? as u64,
-                        error: row.get(7)?,
-                        timestamp: row.get(8)?,
-                    })
-                },
-            )
-            .map_err(|e| AppError::Database(e.to_string()))?;
-
-        let mut records = Vec::new();
-        for row in rows {
-            records.push(row.map_err(|e| AppError::Database(e.to_string()))?);
+        match result {
+            Ok(backup) => Ok(Some(backup)),
+            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+            Err(e) => Err(AppError::Database(e.to_string())),
        }
+    }

-        Ok(records)
+    /// 删除 Live 配置备份
+    pub async fn delete_live_backup(&self, app_type: &str) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+
+        conn.execute(
+            "DELETE FROM proxy_live_backup WHERE app_type = ?1",
+            rusqlite::params![app_type],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        log::info!("已删除 {app_type} Live 配置备份");
+        Ok(())
+    }
+
+    /// 删除所有 Live 配置备份
+    pub async fn delete_all_live_backups(&self) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+
+        conn.execute("DELETE FROM proxy_live_backup", [])
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        log::info!("已删除所有 Live 配置备份");
+        Ok(())
    }
 }
@@ -62,4 +62,56 @@ impl Database {
            Ok(())
        }
    }
+
+    // --- 代理接管状态管理 ---
+
+    /// 获取指定应用的代理接管状态
+    ///
+    /// 使用 settings 表存储各应用的接管状态，key 格式: `proxy_takeover_{app_type}`
+    pub fn get_proxy_takeover_enabled(&self, app_type: &str) -> Result<bool, AppError> {
+        let key = format!("proxy_takeover_{app_type}");
+        match self.get_setting(&key)? {
+            Some(value) => Ok(value == "true"),
+            None => Ok(false),
+        }
+    }
+
+    /// 设置指定应用的代理接管状态
+    ///
+    /// - `true` = 开启代理接管
+    /// - `false` = 关闭代理接管
+    pub fn set_proxy_takeover_enabled(
+        &self,
+        app_type: &str,
+        enabled: bool,
+    ) -> Result<(), AppError> {
+        let key = format!("proxy_takeover_{app_type}");
+        let value = if enabled { "true" } else { "false" };
+        self.set_setting(&key, value)
+    }
+
+    /// 检查是否有任一应用开启了代理接管
+    pub fn has_any_proxy_takeover(&self) -> Result<bool, AppError> {
+        let conn = lock_conn!(self.conn);
+        let count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM settings WHERE key LIKE 'proxy_takeover_%' AND value = 'true'",
+                [],
+                |row| row.get(0),
+            )
+            .map_err(|e| AppError::Database(e.to_string()))?;
+        Ok(count > 0)
+    }
+
+    /// 清除所有代理接管状态（将所有 proxy_takeover_* 设置为 false）
+    pub fn clear_all_proxy_takeover(&self) -> Result<(), AppError> {
+        let conn = lock_conn!(self.conn);
+        conn.execute(
+            "UPDATE settings SET value = 'false' WHERE key LIKE 'proxy_takeover_%'",
+            [],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+        log::info!("已清除所有代理接管状态");
+        Ok(())
+    }
 }
@@ -13,18 +13,22 @@ impl Database {
    pub fn get_skills(&self) -> Result<IndexMap<String, SkillState>, AppError> {
        let conn = lock_conn!(self.conn);
        let mut stmt = conn
-            .prepare("SELECT key, installed, installed_at FROM skills ORDER BY key ASC")
+            .prepare("SELECT directory, app_type, installed, installed_at FROM skills ORDER BY directory ASC, app_type ASC")
            .map_err(|e| AppError::Database(e.to_string()))?;

        let skill_iter = stmt
            .query_map([], |row| {
-                let key: String = row.get(0)?;
-                let installed: bool = row.get(1)?;
-                let installed_at_ts: i64 = row.get(2)?;
+                let directory: String = row.get(0)?;
+                let app_type: String = row.get(1)?;
+                let installed: bool = row.get(2)?;
+                let installed_at_ts: i64 = row.get(3)?;

                let installed_at =
                    chrono::DateTime::from_timestamp(installed_at_ts, 0).unwrap_or_default();

+                // 构建复合 key："app_type:directory"
+                let key = format!("{app_type}:{directory}");
+
                Ok((
                    key,
                    SkillState {
@@ -44,11 +48,21 @@ impl Database {
    }

    /// 更新 Skill 状态
+    /// key 格式为 "app_type:directory"
    pub fn update_skill_state(&self, key: &str, state: &SkillState) -> Result<(), AppError> {
+        // 解析 key
+        let (app_type, directory) = if let Some(idx) = key.find(':') {
+            let (app, dir) = key.split_at(idx);
+            (app, &dir[1..]) // 跳过冒号
+        } else {
+            // 向后兼容：如果没有前缀，默认为 claude
+            ("claude", key)
+        };
+
        let conn = lock_conn!(self.conn);
        conn.execute(
-            "INSERT OR REPLACE INTO skills (key, installed, installed_at) VALUES (?1, ?2, ?3)",
-            params![key, state.installed, state.installed_at.timestamp()],
+            "INSERT OR REPLACE INTO skills (directory, app_type, installed, installed_at) VALUES (?1, ?2, ?3, ?4)",
+            params![directory, app_type, state.installed, state.installed_at.timestamp()],
        )
        .map_err(|e| AppError::Database(e.to_string()))?;
        Ok(())
@@ -0,0 +1,57 @@
+//! 流式健康检查日志 DAO
+
+use crate::database::{lock_conn, Database};
+use crate::error::AppError;
+use crate::services::stream_check::{StreamCheckConfig, StreamCheckResult};
+
+impl Database {
+    /// 保存流式检查日志
+    pub fn save_stream_check_log(
+        &self,
+        provider_id: &str,
+        provider_name: &str,
+        app_type: &str,
+        result: &StreamCheckResult,
+    ) -> Result<i64, AppError> {
+        let conn = lock_conn!(self.conn);
+
+        conn.execute(
+            "INSERT INTO stream_check_logs 
+             (provider_id, provider_name, app_type, status, success, message, 
+              response_time_ms, http_status, model_used, retry_count, tested_at)
+             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)",
+            rusqlite::params![
+                provider_id,
+                provider_name,
+                app_type,
+                format!("{:?}", result.status).to_lowercase(),
+                result.success,
+                result.message,
+                result.response_time_ms.map(|t| t as i64),
+                result.http_status.map(|s| s as i64),
+                result.model_used,
+                result.retry_count as i64,
+                result.tested_at,
+            ],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        Ok(conn.last_insert_rowid())
+    }
+
+    /// 获取流式检查配置
+    pub fn get_stream_check_config(&self) -> Result<StreamCheckConfig, AppError> {
+        match self.get_setting("stream_check_config")? {
+            Some(json) => serde_json::from_str(&json)
+                .map_err(|e| AppError::Message(format!("解析配置失败: {e}"))),
+            None => Ok(StreamCheckConfig::default()),
+        }
+    }
+
+    /// 保存流式检查配置
+    pub fn save_stream_check_config(&self, config: &StreamCheckConfig) -> Result<(), AppError> {
+        let json = serde_json::to_string(config)
+            .map_err(|e| AppError::Message(format!("序列化配置失败: {e}")))?;
+        self.set_setting("stream_check_config", &json)
+    }
+}
@@ -31,6 +31,9 @@ mod schema;
 #[cfg(test)]
 mod tests;

+// DAO 类型导出供外部使用
+pub use dao::FailoverQueueItem;
+
 use crate::config::get_app_config_dir;
 use crate::error::AppError;
 use rusqlite::Connection;
@@ -31,19 +31,13 @@ impl Database {
                icon_color TEXT,
                meta TEXT NOT NULL DEFAULT '{}',
                is_current BOOLEAN NOT NULL DEFAULT 0,
-                is_proxy_target BOOLEAN NOT NULL DEFAULT 0,
+                in_failover_queue BOOLEAN NOT NULL DEFAULT 0,
                PRIMARY KEY (id, app_type)
            )",
            [],
        )
        .map_err(|e| AppError::Database(e.to_string()))?;

-        // 尝试添加 is_proxy_target 列（如果表已存在但缺少该列）
-        let _ = conn.execute(
-            "ALTER TABLE providers ADD COLUMN is_proxy_target BOOLEAN NOT NULL DEFAULT 0",
-            [],
-        );
-
        // 2. Provider Endpoints 表
        conn.execute(
            "CREATE TABLE IF NOT EXISTS provider_endpoints (
@@ -96,9 +90,11 @@ impl Database {
        // 5. Skills 表
        conn.execute(
            "CREATE TABLE IF NOT EXISTS skills (
-                key TEXT PRIMARY KEY,
+                directory TEXT NOT NULL,
+                app_type TEXT NOT NULL,
                installed BOOLEAN NOT NULL DEFAULT 0,
-                installed_at INTEGER NOT NULL DEFAULT 0
+                installed_at INTEGER NOT NULL DEFAULT 0,
+                PRIMARY KEY (directory, app_type)
            )",
            [],
        )
@@ -171,40 +167,7 @@ impl Database {
        )
        .map_err(|e| AppError::Database(e.to_string()))?;

-        // 10. Proxy Usage 表 (代理使用统计，可选)
-        conn.execute(
-            "CREATE TABLE IF NOT EXISTS proxy_usage (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                provider_id TEXT NOT NULL,
-                app_type TEXT NOT NULL,
-                endpoint TEXT NOT NULL,
-                request_tokens INTEGER,
-                response_tokens INTEGER,
-                status_code INTEGER NOT NULL,
-                latency_ms INTEGER NOT NULL,
-                error TEXT,
-                timestamp TEXT NOT NULL
-            )",
-            [],
-        )
-        .map_err(|e| AppError::Database(e.to_string()))?;
-
-        // 为 proxy_usage 创建索引
-        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_proxy_usage_timestamp
-             ON proxy_usage(timestamp)",
-            [],
-        )
-        .map_err(|e| AppError::Database(e.to_string()))?;
-
-        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_proxy_usage_provider
-             ON proxy_usage(provider_id, app_type)",
-            [],
-        )
-        .map_err(|e| AppError::Database(e.to_string()))?;
-
-        // 11. Proxy Request Logs 表 (详细请求日志)
+        // 10. Proxy Request Logs 表 (详细请求日志)
        conn.execute(
            "CREATE TABLE IF NOT EXISTS proxy_request_logs (
                request_id TEXT PRIMARY KEY,
@@ -270,7 +233,7 @@ impl Database {
        )
        .map_err(|e| AppError::Database(e.to_string()))?;

-        // 12. Model Pricing 表 (模型定价)
+        // 11. Model Pricing 表 (模型定价)
        conn.execute(
            "CREATE TABLE IF NOT EXISTS model_pricing (
                model_id TEXT PRIMARY KEY,
@@ -284,38 +247,20 @@ impl Database {
        )
        .map_err(|e| AppError::Database(e.to_string()))?;

-        // 13. Usage Daily Stats 表 (每日聚合统计)
+        // 12. Stream Check Logs 表 (流式健康检查日志)
        conn.execute(
-            "CREATE TABLE IF NOT EXISTS usage_daily_stats (
-                date TEXT NOT NULL,
-                provider_id TEXT NOT NULL,
-                app_type TEXT NOT NULL,
-                model TEXT NOT NULL,
-                request_count INTEGER NOT NULL DEFAULT 0,
-                total_input_tokens INTEGER NOT NULL DEFAULT 0,
-                total_output_tokens INTEGER NOT NULL DEFAULT 0,
-                total_cost_usd TEXT NOT NULL DEFAULT '0',
-                success_count INTEGER NOT NULL DEFAULT 0,
-                error_count INTEGER NOT NULL DEFAULT 0,
-                PRIMARY KEY (date, provider_id, app_type, model)
-            )",
-            [],
-        )
-        .map_err(|e| AppError::Database(e.to_string()))?;
-
-        // 14. Model Test Logs 表 (模型测试日志，独立于代理使用统计)
-        conn.execute(
-            "CREATE TABLE IF NOT EXISTS model_test_logs (
+            "CREATE TABLE IF NOT EXISTS stream_check_logs (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                provider_id TEXT NOT NULL,
                provider_name TEXT NOT NULL,
                app_type TEXT NOT NULL,
-                model TEXT NOT NULL,
-                prompt TEXT NOT NULL,
+                status TEXT NOT NULL,
                success INTEGER NOT NULL,
                message TEXT NOT NULL,
                response_time_ms INTEGER,
                http_status INTEGER,
+                model_used TEXT,
+                retry_count INTEGER DEFAULT 0,
                tested_at INTEGER NOT NULL
            )",
            [],
@@ -323,19 +268,70 @@ impl Database {
        .map_err(|e| AppError::Database(e.to_string()))?;

        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_model_test_logs_provider
-             ON model_test_logs(provider_id, app_type)",
+            "CREATE INDEX IF NOT EXISTS idx_stream_check_logs_provider
+             ON stream_check_logs(app_type, provider_id, tested_at DESC)",
            [],
        )
        .map_err(|e| AppError::Database(e.to_string()))?;

+        // 13. Circuit Breaker Config 表 (熔断器配置)
        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_model_test_logs_tested_at
-             ON model_test_logs(tested_at DESC)",
+            "CREATE TABLE IF NOT EXISTS circuit_breaker_config (
+                id INTEGER PRIMARY KEY CHECK (id = 1),
+                failure_threshold INTEGER NOT NULL DEFAULT 5,
+                success_threshold INTEGER NOT NULL DEFAULT 2,
+                timeout_seconds INTEGER NOT NULL DEFAULT 60,
+                error_rate_threshold REAL NOT NULL DEFAULT 0.5,
+                min_requests INTEGER NOT NULL DEFAULT 10,
+                updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+            )",
            [],
        )
        .map_err(|e| AppError::Database(e.to_string()))?;

+        // 插入默认熔断器配置
+        conn.execute(
+            "INSERT OR IGNORE INTO circuit_breaker_config (id) VALUES (1)",
+            [],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        // 16. Proxy Live Backup 表 (Live 配置备份)
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS proxy_live_backup (
+                app_type TEXT PRIMARY KEY,
+                original_config TEXT NOT NULL,
+                backed_up_at TEXT NOT NULL
+            )",
+            [],
+        )
+        .map_err(|e| AppError::Database(e.to_string()))?;
+
+        // 尝试添加 live_takeover_active 列到 proxy_config 表
+        let _ = conn.execute(
+            "ALTER TABLE proxy_config ADD COLUMN live_takeover_active INTEGER NOT NULL DEFAULT 0",
+            [],
+        );
+
+        // 确保 in_failover_queue 列存在（对于已存在的 v2 数据库）
+        Self::add_column_if_missing(
+            conn,
+            "providers",
+            "in_failover_queue",
+            "BOOLEAN NOT NULL DEFAULT 0",
+        )?;
+
+        // 删除旧的 failover_queue 表（如果存在）
+        let _ = conn.execute("DROP INDEX IF EXISTS idx_failover_queue_order", []);
+        let _ = conn.execute("DROP TABLE IF EXISTS failover_queue", []);
+
+        // 为故障转移队列创建索引（基于 providers 表）
+        let _ = conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_providers_failover
+             ON providers(app_type, in_failover_queue, sort_index)",
+            [],
+        );
+
        Ok(())
    }

@@ -369,7 +365,9 @@ impl Database {
                        Self::set_user_version(conn, 1)?;
                    }
                    1 => {
-                        log::info!("迁移数据库从 v1 到 v2（添加使用统计表和完整字段）");
+                        log::info!(
+                            "迁移数据库从 v1 到 v2（添加使用统计表和完整字段，重构 skills 表）"
+                        );
                        Self::migrate_v1_to_v2(conn)?;
                        Self::set_user_version(conn, 2)?;
                    }
@@ -458,7 +456,7 @@ impl Database {
        Ok(())
    }

-    /// v1 -> v2 迁移：添加使用统计表和完整字段
+    /// v1 -> v2 迁移：添加使用统计表和完整字段，重构 skills 表
    fn migrate_v1_to_v2(conn: &Connection) -> Result<(), AppError> {
        // providers 表字段
        Self::add_column_if_missing(
@@ -470,6 +468,26 @@ impl Database {
        Self::add_column_if_missing(conn, "providers", "limit_daily_usd", "TEXT")?;
        Self::add_column_if_missing(conn, "providers", "limit_monthly_usd", "TEXT")?;
        Self::add_column_if_missing(conn, "providers", "provider_type", "TEXT")?;
+        Self::add_column_if_missing(
+            conn,
+            "providers",
+            "in_failover_queue",
+            "BOOLEAN NOT NULL DEFAULT 0",
+        )?;
+
+        // 删除旧的 failover_queue 表（如果存在）
+        conn.execute("DROP INDEX IF EXISTS idx_failover_queue_order", [])
+            .map_err(|e| AppError::Database(format!("删除 failover_queue 索引失败: {e}")))?;
+        conn.execute("DROP TABLE IF EXISTS failover_queue", [])
+            .map_err(|e| AppError::Database(format!("删除 failover_queue 表失败: {e}")))?;
+
+        // 创建 failover 索引
+        conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_providers_failover
+             ON providers(app_type, in_failover_queue, sort_index)",
+            [],
+        )
+        .map_err(|e| AppError::Database(format!("创建 failover 索引失败: {e}")))?;

        // proxy_request_logs 表（包含所有字段）
        conn.execute(
@@ -531,29 +549,87 @@ impl Database {
            [],
        )?;

-        // usage_daily_stats 表
-        conn.execute(
-            "CREATE TABLE IF NOT EXISTS usage_daily_stats (
-                date TEXT NOT NULL,
-                provider_id TEXT NOT NULL,
-                app_type TEXT NOT NULL,
-                model TEXT NOT NULL,
-                request_count INTEGER NOT NULL DEFAULT 0,
-                total_input_tokens INTEGER NOT NULL DEFAULT 0,
-                total_output_tokens INTEGER NOT NULL DEFAULT 0,
-                total_cost_usd TEXT NOT NULL DEFAULT '0',
-                success_count INTEGER NOT NULL DEFAULT 0,
-                error_count INTEGER NOT NULL DEFAULT 0,
-                PRIMARY KEY (date, provider_id, app_type, model)
-            )",
-            [],
-        )?;
-
        // 清空并重新插入模型定价
        conn.execute("DELETE FROM model_pricing", [])
            .map_err(|e| AppError::Database(format!("清空模型定价失败: {e}")))?;
        Self::seed_model_pricing(conn)?;

+        // 重构 skills 表（添加 app_type 字段）
+        Self::migrate_skills_table(conn)?;
+
+        Ok(())
+    }
+
+    /// 迁移 skills 表：从单 key 主键改为 (directory, app_type) 复合主键
+    fn migrate_skills_table(conn: &Connection) -> Result<(), AppError> {
+        // 检查是否已经是新表结构
+        if Self::has_column(conn, "skills", "app_type")? {
+            log::info!("skills 表已经包含 app_type 字段，跳过迁移");
+            return Ok(());
+        }
+
+        log::info!("开始迁移 skills 表...");
+
+        // 1. 重命名旧表
+        conn.execute("ALTER TABLE skills RENAME TO skills_old", [])
+            .map_err(|e| AppError::Database(format!("重命名旧 skills 表失败: {e}")))?;
+
+        // 2. 创建新表
+        conn.execute(
+            "CREATE TABLE skills (
+                directory TEXT NOT NULL,
+                app_type TEXT NOT NULL,
+                installed BOOLEAN NOT NULL DEFAULT 0,
+                installed_at INTEGER NOT NULL DEFAULT 0,
+                PRIMARY KEY (directory, app_type)
+            )",
+            [],
+        )
+        .map_err(|e| AppError::Database(format!("创建新 skills 表失败: {e}")))?;
+
+        // 3. 迁移数据：解析 key 格式（如 "claude:my-skill" 或 "codex:foo"）
+        //    旧数据如果没有前缀，默认为 claude
+        let mut stmt = conn
+            .prepare("SELECT key, installed, installed_at FROM skills_old")
+            .map_err(|e| AppError::Database(format!("查询旧 skills 数据失败: {e}")))?;
+
+        let old_skills: Vec<(String, bool, i64)> = stmt
+            .query_map([], |row| {
+                Ok((
+                    row.get::<_, String>(0)?,
+                    row.get::<_, bool>(1)?,
+                    row.get::<_, i64>(2)?,
+                ))
+            })
+            .map_err(|e| AppError::Database(format!("读取旧 skills 数据失败: {e}")))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| AppError::Database(format!("解析旧 skills 数据失败: {e}")))?;
+
+        let count = old_skills.len();
+
+        for (key, installed, installed_at) in old_skills {
+            // 解析 key: "app:directory" 或 "directory"（默认 claude）
+            let (app_type, directory) = if let Some(idx) = key.find(':') {
+                let (app, dir) = key.split_at(idx);
+                (app.to_string(), dir[1..].to_string()) // 跳过冒号
+            } else {
+                ("claude".to_string(), key.clone())
+            };
+
+            conn.execute(
+                "INSERT INTO skills (directory, app_type, installed, installed_at) VALUES (?1, ?2, ?3, ?4)",
+                rusqlite::params![directory, app_type, installed, installed_at],
+            )
+            .map_err(|e| {
+                AppError::Database(format!("迁移 skill {key} 到新表失败: {e}"))
+            })?;
+        }
+
+        // 4. 删除旧表
+        conn.execute("DROP TABLE skills_old", [])
+            .map_err(|e| AppError::Database(format!("删除旧 skills 表失败: {e}")))?;
+
+        log::info!("skills 表迁移完成，共迁移 {count} 条记录");
        Ok(())
    }

@@ -245,7 +245,7 @@ fn dry_run_validates_schema_compatibility() {
            meta: None,
            icon: None,
            icon_color: None,
-            is_proxy_target: Some(false),
+            in_failover_queue: false,
        },
    );

@@ -113,4 +113,27 @@ pub struct DeepLinkImportRequest {
    /// Remote config URL
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config_url: Option<String>,
+
+    // ============ Usage script fields (v3.9+) ============
+    /// Whether to enable usage query (default: true if usage_script is provided)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub usage_enabled: Option<bool>,
+    /// Base64 encoded usage query script code
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub usage_script: Option<String>,
+    /// Usage query API key (if different from provider API key)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub usage_api_key: Option<String>,
+    /// Usage query base URL (if different from provider endpoint)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub usage_base_url: Option<String>,
+    /// Usage query access token (for NewAPI template)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub usage_access_token: Option<String>,
+    /// Usage query user ID (for NewAPI template)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub usage_user_id: Option<String>,
+    /// Auto query interval in minutes (0 to disable)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub usage_auto_interval: Option<u64>,
 }
@@ -122,6 +122,19 @@ fn parse_provider_deeplink(
    let config_url = params.get("configUrl").cloned();
    let enabled = params.get("enabled").and_then(|v| v.parse::<bool>().ok());

+    // Extract usage script fields (v3.9+)
+    let usage_enabled = params
+        .get("usageEnabled")
+        .and_then(|v| v.parse::<bool>().ok());
+    let usage_script = params.get("usageScript").cloned();
+    let usage_api_key = params.get("usageApiKey").cloned();
+    let usage_base_url = params.get("usageBaseUrl").cloned();
+    let usage_access_token = params.get("usageAccessToken").cloned();
+    let usage_user_id = params.get("usageUserId").cloned();
+    let usage_auto_interval = params
+        .get("usageAutoInterval")
+        .and_then(|v| v.parse::<u64>().ok());
+
    Ok(DeepLinkImportRequest {
        version,
        resource,
@@ -146,6 +159,13 @@ fn parse_provider_deeplink(
        config,
        config_format,
        config_url,
+        usage_enabled,
+        usage_script,
+        usage_api_key,
+        usage_base_url,
+        usage_access_token,
+        usage_user_id,
+        usage_auto_interval,
    })
 }

@@ -206,6 +226,13 @@ fn parse_prompt_deeplink(
        config: None,
        config_format: None,
        config_url: None,
+        usage_enabled: None,
+        usage_script: None,
+        usage_api_key: None,
+        usage_base_url: None,
+        usage_access_token: None,
+        usage_user_id: None,
+        usage_auto_interval: None,
    })
 }

@@ -261,6 +288,13 @@ fn parse_mcp_deeplink(
        directory: None,
        branch: None,
        config_url: None,
+        usage_enabled: None,
+        usage_script: None,
+        usage_api_key: None,
+        usage_base_url: None,
+        usage_access_token: None,
+        usage_user_id: None,
+        usage_auto_interval: None,
    })
 }

@@ -309,5 +343,12 @@ fn parse_skill_deeplink(
        config: None,
        config_format: None,
        config_url: None,
+        usage_enabled: None,
+        usage_script: None,
+        usage_api_key: None,
+        usage_base_url: None,
+        usage_access_token: None,
+        usage_user_id: None,
+        usage_auto_interval: None,
    })
 }
@@ -5,7 +5,7 @@
 use super::utils::{decode_base64_param, infer_homepage_from_endpoint};
 use super::DeepLinkImportRequest;
 use crate::error::AppError;
-use crate::provider::Provider;
+use crate::provider::{Provider, ProviderMeta, UsageScript};
 use crate::services::ProviderService;
 use crate::store::AppState;
 use crate::AppType;
@@ -117,6 +117,9 @@ pub(crate) fn build_provider_from_request(
        AppType::Gemini => build_gemini_settings(request),
    };

+    // Build usage script configuration if provided
+    let meta = build_provider_meta(request)?;
+
    let provider = Provider {
        id: String::new(), // Will be generated by caller
        name: request.name.clone().unwrap_or_default(),
@@ -126,15 +129,66 @@ pub(crate) fn build_provider_from_request(
        created_at: None,
        sort_index: None,
        notes: request.notes.clone(),
-        meta: None,
+        meta,
        icon: request.icon.clone(),
        icon_color: None,
-        is_proxy_target: None,
+        in_failover_queue: false,
    };

    Ok(provider)
 }

+/// Build provider meta with usage script configuration
+fn build_provider_meta(request: &DeepLinkImportRequest) -> Result<Option<ProviderMeta>, AppError> {
+    // Check if any usage script fields are provided
+    if request.usage_script.is_none()
+        && request.usage_enabled.is_none()
+        && request.usage_api_key.is_none()
+        && request.usage_base_url.is_none()
+        && request.usage_access_token.is_none()
+        && request.usage_user_id.is_none()
+        && request.usage_auto_interval.is_none()
+    {
+        return Ok(None);
+    }
+
+    // Decode usage script code if provided
+    let code = if let Some(script_b64) = &request.usage_script {
+        let decoded = decode_base64_param("usage_script", script_b64)?;
+        String::from_utf8(decoded)
+            .map_err(|e| AppError::InvalidInput(format!("Invalid UTF-8 in usage_script: {e}")))?
+    } else {
+        String::new()
+    };
+
+    // Determine enabled state: explicit param > has code > false
+    let enabled = request.usage_enabled.unwrap_or(!code.is_empty());
+
+    // Build UsageScript - use provider's API key and endpoint as defaults
+    let usage_script = UsageScript {
+        enabled,
+        language: "javascript".to_string(),
+        code,
+        timeout: Some(10),
+        api_key: request
+            .usage_api_key
+            .clone()
+            .or_else(|| request.api_key.clone()),
+        base_url: request
+            .usage_base_url
+            .clone()
+            .or_else(|| request.endpoint.clone()),
+        access_token: request.usage_access_token.clone(),
+        user_id: request.usage_user_id.clone(),
+        auto_query_interval: request.usage_auto_interval,
+    };
+
+    Ok(Some(ProviderMeta {
+        usage_script: Some(usage_script),
+        ..Default::default()
+    }))
+}
+
 /// Build Claude settings configuration
 fn build_claude_settings(request: &DeepLinkImportRequest) -> serde_json::Value {
    let mut env = serde_json::Map::new();
@@ -145,6 +145,13 @@ fn test_build_gemini_provider_with_model() {
        content: None,
        description: None,
        enabled: None,
+        usage_enabled: None,
+        usage_script: None,
+        usage_api_key: None,
+        usage_base_url: None,
+        usage_access_token: None,
+        usage_user_id: None,
+        usage_auto_interval: None,
    };

    let provider = build_provider_from_request(&AppType::Gemini, &request).unwrap();
@@ -191,6 +198,13 @@ fn test_build_gemini_provider_without_model() {
        content: None,
        description: None,
        enabled: None,
+        usage_enabled: None,
+        usage_script: None,
+        usage_api_key: None,
+        usage_base_url: None,
+        usage_access_token: None,
+        usage_user_id: None,
+        usage_auto_interval: None,
    };

    let provider = build_provider_from_request(&AppType::Gemini, &request).unwrap();
@@ -232,6 +246,13 @@ fn test_parse_and_merge_config_claude() {
        content: None,
        description: None,
        enabled: None,
+        usage_enabled: None,
+        usage_script: None,
+        usage_api_key: None,
+        usage_base_url: None,
+        usage_access_token: None,
+        usage_user_id: None,
+        usage_auto_interval: None,
    };

    let merged = parse_and_merge_config(&request).unwrap();
@@ -275,6 +296,13 @@ fn test_parse_and_merge_config_url_override() {
        content: None,
        description: None,
        enabled: None,
+        usage_enabled: None,
+        usage_script: None,
+        usage_api_key: None,
+        usage_base_url: None,
+        usage_access_token: None,
+        usage_user_id: None,
+        usage_auto_interval: None,
    };

    let merged = parse_and_merge_config(&request).unwrap();
@@ -42,8 +42,8 @@ fn write_json_value(path: &Path, value: &Value) -> Result<(), AppError> {
 ///
 /// 执行反向格式转换以保持与统一 MCP 结构的兼容性：
 /// - httpUrl → url + type: "http"
-/// - 仅有 url 字段 → 保持不变（SSE 类型）
-/// - 仅有 command 字段 → 保持不变（stdio 类型）
+/// - 仅有 url 字段 → 补齐 type: "sse"（Gemini 以字段名推断传输类型）
+/// - 仅有 command 字段 → 补齐 type: "stdio"
 pub fn read_mcp_servers_map() -> Result<std::collections::HashMap<String, Value>, AppError> {
    let path = user_config_path();
    if !path.exists() {
@@ -65,8 +65,15 @@ pub fn read_mcp_servers_map() -> Result<std::collections::HashMap<String, Value>
                obj.insert("url".to_string(), http_url);
                obj.insert("type".to_string(), Value::String("http".to_string()));
            }
-            // 如果有 url 但没有 type，不添加 type（默认为 SSE）
-            // 如果有 command 但没有 type，不添加 type（默认为 stdio）
+
+            // Gemini CLI 不使用 type 字段：这里补齐成统一结构，便于校验与导入
+            if obj.get("type").is_none() {
+                if obj.contains_key("command") {
+                    obj.insert("type".to_string(), Value::String("stdio".to_string()));
+                } else if obj.contains_key("url") {
+                    obj.insert("type".to_string(), Value::String("sse".to_string()));
+                }
+            }
        }
    }

@@ -39,8 +39,8 @@ pub use mcp::{
 };
 pub use provider::{Provider, ProviderMeta};
 pub use services::{
-    ConfigService, EndpointLatency, McpService, PromptService, ProviderService, SkillService,
-    SpeedtestService,
+    ConfigService, EndpointLatency, McpService, PromptService, ProviderService, ProxyService,
+    SkillService, SpeedtestService,
 };
 pub use settings::{update_settings, AppSettings};
 pub use store::AppState;
@@ -48,8 +48,9 @@ use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_dialog::{DialogExt, MessageDialogButtons, MessageDialogKind};

 use std::sync::Arc;
-use tauri::tray::{TrayIconBuilder, TrayIconEvent};
 #[cfg(target_os = "macos")]
+use tauri::image::Image;
+use tauri::tray::{TrayIconBuilder, TrayIconEvent};
 use tauri::RunEvent;
 use tauri::{Emitter, Manager};

@@ -134,6 +135,19 @@ async fn update_tray_menu(
    }
 }

+#[cfg(target_os = "macos")]
+fn macos_tray_icon() -> Option<Image<'static>> {
+    const ICON_BYTES: &[u8] = include_bytes!("../icons/tray/macos/statusbar_template_3x.png");
+
+    match Image::from_bytes(ICON_BYTES) {
+        Ok(icon) => Some(icon),
+        Err(err) => {
+            log::warn!("Failed to load macOS tray icon: {err}");
+            None
+        }
+    }
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
    let mut builder = tauri::Builder::default();
@@ -209,44 +223,6 @@ pub fn run() {
                    log::warn!("初始化 Updater 插件失败，已跳过：{e}");
                }
            }
-            #[cfg(target_os = "macos")]
-            {
-                // 设置 macOS 标题栏背景色为主界面蓝色
-                if let Some(window) = app.get_webview_window("main") {
-                    use objc2::rc::Retained;
-                    use objc2::runtime::AnyObject;
-                    use objc2_app_kit::NSColor;
-
-                    match window.ns_window() {
-                        Ok(ns_window_ptr) => {
-                            if let Some(ns_window) =
-                                unsafe { Retained::retain(ns_window_ptr as *mut AnyObject) }
-                            {
-                                // 使用与主界面 banner 相同的蓝色 #3498db
-                                // #3498db = RGB(52, 152, 219)
-                                let bg_color = unsafe {
-                                    NSColor::colorWithRed_green_blue_alpha(
-                                        52.0 / 255.0,  // R: 52
-                                        152.0 / 255.0, // G: 152
-                                        219.0 / 255.0, // B: 219
-                                        1.0,           // Alpha: 1.0
-                                    )
-                                };
-
-                                unsafe {
-                                    use objc2::msg_send;
-                                    let _: () =
-                                        msg_send![&*ns_window, setBackgroundColor: &*bg_color];
-                                }
-                            } else {
-                                log::warn!("Failed to retain NSWindow reference");
-                            }
-                        }
-                        Err(e) => log::warn!("Failed to get NSWindow pointer: {e}"),
-                    }
-                }
-            }
-
            // 初始化日志
            if cfg!(debug_assertions) {
                app.handle().plugin(
@@ -332,6 +308,9 @@ pub fn run() {

            let app_state = AppState::new(db);

+            // 设置 AppHandle 用于代理故障转移时的 UI 更新
+            app_state.proxy_service.set_app_handle(app.handle().clone());
+
            // ============================================================
            // 按表独立判断的导入逻辑（各类数据独立检查，互不影响）
            // ============================================================
@@ -501,11 +480,26 @@ pub fn run() {
                })
                .show_menu_on_left_click(true);

-            // 统一使用应用默认图标；待托盘模板图标就绪后再启用
-            if let Some(icon) = app.default_window_icon() {
-                tray_builder = tray_builder.icon(icon.clone());
-            } else {
-                log::warn!("Failed to get default window icon for tray");
+            // 使用平台对应的托盘图标（macOS 使用模板图标适配深浅色）
+            #[cfg(target_os = "macos")]
+            {
+                if let Some(icon) = macos_tray_icon() {
+                    tray_builder = tray_builder.icon(icon).icon_as_template(true);
+                } else if let Some(icon) = app.default_window_icon() {
+                    log::warn!("Falling back to default window icon for tray");
+                    tray_builder = tray_builder.icon(icon.clone());
+                } else {
+                    log::warn!("Failed to load macOS tray icon for tray");
+                }
+            }
+
+            #[cfg(not(target_os = "macos"))]
+            {
+                if let Some(icon) = app.default_window_icon() {
+                    tray_builder = tray_builder.icon(icon.clone());
+                } else {
+                    log::warn!("Failed to get default window icon for tray");
+                }
            }

            let _tray = tray_builder.build(app)?;
@@ -522,26 +516,33 @@ pub fn run() {
                }
            }

-            // 自动启动代理服务器
+            // 异常退出恢复 + 代理状态自动恢复
            let app_handle = app.handle().clone();
            tauri::async_runtime::spawn(async move {
                let state = app_handle.state::<AppState>();
-                match state.db.get_proxy_config().await {
-                    Ok(config) => {
-                        if config.enabled {
-                            log::info!("代理服务配置为启用，正在启动...");
-                            match state.proxy_service.start().await {
-                                Ok(info) => log::info!(
-                                    "代理服务器自动启动成功: {}:{}",
-                                    info.address,
-                                    info.port
-                                ),
-                                Err(e) => log::error!("代理服务器自动启动失败: {e}"),
-                            }
-                        }
+
+                // 检查是否有 Live 备份（表示上次异常退出时可能处于接管状态）
+                let has_backups = match state.db.has_any_live_backup().await {
+                    Ok(v) => v,
+                    Err(e) => {
+                        log::error!("检查 Live 备份失败: {e}");
+                        false
+                    }
+                };
+                // 检查 Live 配置是否仍处于被接管状态（包含占位符）
+                let live_taken_over = state.proxy_service.detect_takeover_in_live_configs();
+
+                if has_backups || live_taken_over {
+                    log::warn!("检测到上次异常退出（存在接管残留），正在恢复 Live 配置...");
+                    if let Err(e) = state.proxy_service.recover_from_crash().await {
+                        log::error!("恢复 Live 配置失败: {e}");
+                    } else {
+                        log::info!("Live 配置已恢复");
                    }
-                    Err(e) => log::error!("启动时获取代理配置失败: {e}"),
                }
+
+                // 检查 settings 表中的代理状态，自动恢复代理服务
+                restore_proxy_state_on_startup(&state).await;
            });

            Ok(())
@@ -553,7 +554,6 @@ pub fn run() {
            commands::update_provider,
            commands::delete_provider,
            commands::switch_provider,
-            commands::set_proxy_target_provider,
            commands::import_default_config,
            commands::get_claude_config_status,
            commands::get_config_status,
@@ -580,6 +580,8 @@ pub fn run() {
            commands::read_claude_plugin_config,
            commands::apply_claude_plugin_config,
            commands::is_claude_plugin_applied,
+            commands::apply_claude_onboarding_skip,
+            commands::clear_claude_onboarding_skip,
            // Claude MCP management
            commands::get_claude_mcp_status,
            commands::read_claude_mcp_config,
@@ -635,8 +637,11 @@ pub fn run() {
            commands::restore_env_backup,
            // Skill management
            commands::get_skills,
+            commands::get_skills_for_app,
            commands::install_skill,
+            commands::install_skill_for_app,
            commands::uninstall_skill,
+            commands::uninstall_skill_for_app,
            commands::get_skill_repos,
            commands::add_skill_repo,
            commands::remove_skill_repo,
@@ -645,11 +650,28 @@ pub fn run() {
            commands::get_auto_launch_status,
            // Proxy server management
            commands::start_proxy_server,
-            commands::stop_proxy_server,
+            commands::stop_proxy_with_restore,
+            commands::get_proxy_takeover_status,
+            commands::set_proxy_takeover_for_app,
            commands::get_proxy_status,
            commands::get_proxy_config,
            commands::update_proxy_config,
            commands::is_proxy_running,
+            commands::is_live_takeover_active,
+            commands::switch_proxy_provider,
+            // Proxy failover commands
+            commands::get_provider_health,
+            commands::reset_circuit_breaker,
+            commands::get_circuit_breaker_config,
+            commands::update_circuit_breaker_config,
+            commands::get_circuit_breaker_stats,
+            // Failover queue management
+            commands::get_failover_queue,
+            commands::get_available_providers_for_failover,
+            commands::add_to_failover_queue,
+            commands::remove_from_failover_queue,
+            commands::get_auto_failover_enabled,
+            commands::set_auto_failover_enabled,
            // Usage statistics
            commands::get_usage_summary,
            commands::get_usage_trends,
@@ -661,13 +683,12 @@ pub fn run() {
            commands::update_model_pricing,
            commands::delete_model_pricing,
            commands::check_provider_limits,
-            // Model testing
-            commands::test_provider_model,
-            commands::test_all_providers_model,
-            commands::get_model_test_config,
-            commands::save_model_test_config,
-            commands::get_model_test_logs,
-            commands::cleanup_model_test_logs,
+            // Stream health check
+            commands::stream_check_provider,
+            commands::stream_check_all_providers,
+            commands::get_stream_check_config,
+            commands::save_stream_check_config,
+            commands::get_tool_versions,
        ]);

    let app = builder
@@ -675,6 +696,26 @@ pub fn run() {
        .expect("error while running tauri application");

    app.run(|app_handle, event| {
+        // 处理退出请求（所有平台）
+        if let RunEvent::ExitRequested { api, .. } = &event {
+            log::info!("收到退出请求，开始清理...");
+            // 阻止立即退出，执行清理
+            api.prevent_exit();
+
+            let app_handle = app_handle.clone();
+            tauri::async_runtime::spawn(async move {
+                cleanup_before_exit(&app_handle).await;
+                log::info!("清理完成，退出应用");
+
+                // 短暂等待确保所有 I/O 操作（如数据库写入）刷新到磁盘
+                tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+
+                // 使用 std::process::exit 避免再次触发 ExitRequested
+                std::process::exit(0);
+            });
+            return;
+        }
+
        #[cfg(target_os = "macos")]
        {
            match event {
@@ -754,6 +795,101 @@ pub fn run() {
    });
 }

+// ============================================================
+// 应用退出清理
+// ============================================================
+
+/// 应用退出前的清理工作
+///
+/// 在应用退出前检查代理服务器状态，如果正在运行则停止代理并恢复 Live 配置。
+/// 确保 Claude Code/Codex/Gemini 的配置不会处于损坏状态。
+/// 使用 stop_with_restore_keep_state 保留 settings 表中的代理状态，下次启动时自动恢复。
+pub async fn cleanup_before_exit(app_handle: &tauri::AppHandle) {
+    if let Some(state) = app_handle.try_state::<store::AppState>() {
+        let proxy_service = &state.proxy_service;
+
+        // 退出时也需要兜底：代理可能已崩溃/未运行，但 Live 接管残留仍在（占位符/备份）。
+        let has_backups = match state.db.has_any_live_backup().await {
+            Ok(v) => v,
+            Err(e) => {
+                log::error!("退出时检查 Live 备份失败: {e}");
+                false
+            }
+        };
+        let live_taken_over = proxy_service.detect_takeover_in_live_configs();
+        let needs_restore = has_backups || live_taken_over;
+
+        if needs_restore {
+            log::info!("检测到接管残留，开始恢复 Live 配置（保留代理状态）...");
+            // 使用 keep_state 版本，保留 settings 表中的代理状态
+            if let Err(e) = proxy_service.stop_with_restore_keep_state().await {
+                log::error!("退出时恢复 Live 配置失败: {e}");
+            } else {
+                log::info!("已恢复 Live 配置（代理状态已保留，下次启动将自动恢复）");
+            }
+            return;
+        }
+
+        // 非接管模式：代理在运行则仅停止代理
+        if proxy_service.is_running().await {
+            log::info!("检测到代理服务器正在运行，开始停止...");
+            if let Err(e) = proxy_service.stop().await {
+                log::error!("退出时停止代理失败: {e}");
+            }
+            log::info!("代理服务器清理完成");
+        }
+    }
+}
+
+// ============================================================
+// 启动时恢复代理状态
+// ============================================================
+
+/// 启动时根据 settings 表中的代理状态自动恢复代理服务
+///
+/// 检查 `proxy_takeover_claude`、`proxy_takeover_codex`、`proxy_takeover_gemini` 的值，
+/// 如果有任一应用的状态为 `true`，则自动启动代理服务并接管对应应用的 Live 配置。
+async fn restore_proxy_state_on_startup(state: &store::AppState) {
+    // 收集需要恢复接管的应用列表
+    let apps_to_restore: Vec<&str> = ["claude", "codex", "gemini"]
+        .iter()
+        .filter(|app_type| {
+            state
+                .db
+                .get_proxy_takeover_enabled(app_type)
+                .unwrap_or(false)
+        })
+        .copied()
+        .collect();
+
+    if apps_to_restore.is_empty() {
+        log::debug!("启动时无需恢复代理状态");
+        return;
+    }
+
+    log::info!("检测到上次代理状态需要恢复，应用列表: {apps_to_restore:?}");
+
+    // 逐个恢复接管状态
+    for app_type in apps_to_restore {
+        match state
+            .proxy_service
+            .set_takeover_for_app(app_type, true)
+            .await
+        {
+            Ok(()) => {
+                log::info!("✓ 已恢复 {app_type} 的代理接管状态");
+            }
+            Err(e) => {
+                log::error!("✗ 恢复 {app_type} 的代理接管状态失败: {e}");
+                // 失败时清除该应用的状态，避免下次启动再次尝试
+                if let Err(clear_err) = state.db.set_proxy_takeover_enabled(app_type, false) {
+                    log::error!("清除 {app_type} 代理状态失败: {clear_err}");
+                }
+            }
+        }
+    }
+}
+
 // ============================================================
 // 迁移错误对话框辅助函数
 // ============================================================
@@ -8,6 +8,12 @@ use crate::error::AppError;

 use super::validation::{extract_server_spec, validate_server_spec};

+fn should_sync_claude_mcp() -> bool {
+    // Claude 未安装/未初始化时：通常 ~/.claude 目录与 ~/.claude.json 都不存在。
+    // 按用户偏好：此时跳过写入/删除，不创建任何文件或目录。
+    crate::config::get_claude_config_dir().exists() || crate::config::get_claude_mcp_path().exists()
+}
+
 /// 返回已启用的 MCP 服务器（过滤 enabled==true）
 fn collect_enabled_servers(cfg: &McpConfig) -> HashMap<String, Value> {
    let mut out = HashMap::new();
@@ -33,6 +39,9 @@ fn collect_enabled_servers(cfg: &McpConfig) -> HashMap<String, Value> {

 /// 将 config.json 中 enabled==true 的项投影写入 ~/.claude.json
 pub fn sync_enabled_to_claude(config: &MultiAppConfig) -> Result<(), AppError> {
+    if !should_sync_claude_mcp() {
+        return Ok(());
+    }
    let enabled = collect_enabled_servers(&config.mcp.claude);
    crate::claude_mcp::set_mcp_servers_map(&enabled)
 }
@@ -107,6 +116,9 @@ pub fn sync_single_server_to_claude(
    id: &str,
    server_spec: &Value,
 ) -> Result<(), AppError> {
+    if !should_sync_claude_mcp() {
+        return Ok(());
+    }
    // 读取现有的 MCP 配置
    let current = crate::claude_mcp::read_mcp_servers_map()?;

@@ -120,6 +132,9 @@ pub fn sync_single_server_to_claude(

 /// 从 Claude live 配置中移除单个 MCP 服务器
 pub fn remove_server_from_claude(id: &str) -> Result<(), AppError> {
+    if !should_sync_claude_mcp() {
+        return Ok(());
+    }
    // 读取现有的 MCP 配置
    let mut current = crate::claude_mcp::read_mcp_servers_map()?;

@@ -13,6 +13,12 @@ use crate::error::AppError;

 use super::validation::{extract_server_spec, validate_server_spec};

+fn should_sync_codex_mcp() -> bool {
+    // Codex 未安装/未初始化时：~/.codex 目录不存在。
+    // 按用户偏好：目录缺失时跳过写入/删除，不创建任何文件或目录。
+    crate::codex_config::get_codex_config_dir().exists()
+}
+
 /// 返回已启用的 MCP 服务器（过滤 enabled==true）
 fn collect_enabled_servers(cfg: &McpConfig) -> HashMap<String, Value> {
    let mut out = HashMap::new();
@@ -273,6 +279,9 @@ pub fn import_from_codex(config: &mut MultiAppConfig) -> Result<usize, AppError>
 /// - 仅更新 `mcp_servers` 表，保留其它键
 /// - 仅写入启用项；无启用项时清理 mcp_servers 表
 pub fn sync_enabled_to_codex(config: &MultiAppConfig) -> Result<(), AppError> {
+    if !should_sync_codex_mcp() {
+        return Ok(());
+    }
    use toml_edit::{Item, Table};

    // 1) 收集启用项（Codex 维度）
@@ -339,6 +348,9 @@ pub fn sync_single_server_to_codex(
    id: &str,
    server_spec: &Value,
 ) -> Result<(), AppError> {
+    if !should_sync_codex_mcp() {
+        return Ok(());
+    }
    use toml_edit::Item;

    // 读取现有的 config.toml
@@ -376,7 +388,8 @@ pub fn sync_single_server_to_codex(
    doc["mcp_servers"][id] = Item::Table(toml_table);

    // 写回文件
-    std::fs::write(&config_path, doc.to_string()).map_err(|e| AppError::io(&config_path, e))?;
+    let new_text = doc.to_string();
+    crate::config::write_text_file(&config_path, &new_text)?;

    Ok(())
 }
@@ -384,6 +397,9 @@ pub fn sync_single_server_to_codex(
 /// 从 Codex live 配置中移除单个 MCP 服务器
 /// 从正确的 [mcp_servers] 表中删除，同时清理可能存在于错误位置 [mcp.servers] 的数据
 pub fn remove_server_from_codex(id: &str) -> Result<(), AppError> {
+    if !should_sync_codex_mcp() {
+        return Ok(());
+    }
    let config_path = crate::codex_config::get_codex_config_path();

    if !config_path.exists() {
@@ -412,7 +428,8 @@ pub fn remove_server_from_codex(id: &str) -> Result<(), AppError> {
    }

    // 写回文件
-    std::fs::write(&config_path, doc.to_string()).map_err(|e| AppError::io(&config_path, e))?;
+    let new_text = doc.to_string();
+    crate::config::write_text_file(&config_path, &new_text)?;

    Ok(())
 }
@@ -8,6 +8,12 @@ use crate::error::AppError;

 use super::validation::{extract_server_spec, validate_server_spec};

+fn should_sync_gemini_mcp() -> bool {
+    // Gemini 未安装/未初始化时：~/.gemini 目录不存在。
+    // 按用户偏好：目录缺失时跳过写入/删除，不创建任何文件或目录。
+    crate::gemini_config::get_gemini_dir().exists()
+}
+
 /// 返回已启用的 MCP 服务器（过滤 enabled==true）
 fn collect_enabled_servers(cfg: &McpConfig) -> HashMap<String, Value> {
    let mut out = HashMap::new();
@@ -33,6 +39,9 @@ fn collect_enabled_servers(cfg: &McpConfig) -> HashMap<String, Value> {

 /// 将 config.json 中 Gemini 的 enabled==true 项写入 Gemini MCP 配置
 pub fn sync_enabled_to_gemini(config: &MultiAppConfig) -> Result<(), AppError> {
+    if !should_sync_gemini_mcp() {
+        return Ok(());
+    }
    let enabled = collect_enabled_servers(&config.mcp.gemini);
    crate::gemini_mcp::set_mcp_servers_map(&enabled)
 }
@@ -103,6 +112,9 @@ pub fn sync_single_server_to_gemini(
    id: &str,
    server_spec: &Value,
 ) -> Result<(), AppError> {
+    if !should_sync_gemini_mcp() {
+        return Ok(());
+    }
    // 读取现有的 MCP 配置
    let mut current = crate::gemini_mcp::read_mcp_servers_map()?;

@@ -115,6 +127,9 @@ pub fn sync_single_server_to_gemini(

 /// 从 Gemini live 配置中移除单个 MCP 服务器
 pub fn remove_server_from_gemini(id: &str) -> Result<(), AppError> {
+    if !should_sync_gemini_mcp() {
+        return Ok(());
+    }
    // 读取现有的 MCP 配置
    let mut current = crate::gemini_mcp::read_mcp_servers_map()?;

@@ -36,10 +36,10 @@ pub struct Provider {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "iconColor")]
    pub icon_color: Option<String>,
-    /// 是否为代理目标（数据库专用字段，不写入配置文件）
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(rename = "isProxyTarget")]
-    pub is_proxy_target: Option<bool>,
+    /// 是否加入故障转移队列
+    #[serde(default)]
+    #[serde(rename = "inFailoverQueue")]
+    pub in_failover_queue: bool,
 }

 impl Provider {
@@ -62,7 +62,7 @@ impl Provider {
            meta: None,
            icon: None,
            icon_color: None,
-            is_proxy_target: None,
+            in_failover_queue: false,
        }
    }
 }
@@ -0,0 +1,506 @@
+//! 熔断器模块
+//!
+//! 实现熔断器模式，用于防止向不健康的供应商发送请求
+
+use serde::{Deserialize, Serialize};
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::Arc;
+use std::time::Instant;
+use tokio::sync::RwLock;
+
+/// 熔断器状态
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CircuitState {
+    /// 关闭状态 - 正常工作
+    Closed,
+    /// 打开状态 - 熔断激活，拒绝请求
+    Open,
+    /// 半开状态 - 尝试恢复，允许部分请求通过
+    HalfOpen,
+}
+
+impl std::fmt::Display for CircuitState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CircuitState::Closed => write!(f, "closed"),
+            CircuitState::Open => write!(f, "open"),
+            CircuitState::HalfOpen => write!(f, "half_open"),
+        }
+    }
+}
+
+/// 熔断器配置
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CircuitBreakerConfig {
+    /// 失败阈值 - 连续失败多少次后打开熔断器
+    pub failure_threshold: u32,
+    /// 成功阈值 - 半开状态下成功多少次后关闭熔断器
+    pub success_threshold: u32,
+    /// 超时时间 - 熔断器打开后多久尝试半开（秒）
+    pub timeout_seconds: u64,
+    /// 错误率阈值 - 错误率超过此值时打开熔断器 (0.0-1.0)
+    pub error_rate_threshold: f64,
+    /// 最小请求数 - 计算错误率前的最小请求数
+    pub min_requests: u32,
+}
+
+impl Default for CircuitBreakerConfig {
+    fn default() -> Self {
+        Self {
+            failure_threshold: 5,
+            success_threshold: 2,
+            timeout_seconds: 60,
+            error_rate_threshold: 0.5,
+            min_requests: 10,
+        }
+    }
+}
+
+/// 熔断器实例
+pub struct CircuitBreaker {
+    /// 当前状态
+    state: Arc<RwLock<CircuitState>>,
+    /// 连续失败计数
+    consecutive_failures: Arc<AtomicU32>,
+    /// 连续成功计数（半开状态）
+    consecutive_successes: Arc<AtomicU32>,
+    /// 总请求计数
+    total_requests: Arc<AtomicU32>,
+    /// 失败请求计数
+    failed_requests: Arc<AtomicU32>,
+    /// 上次打开时间
+    last_opened_at: Arc<RwLock<Option<Instant>>>,
+    /// 配置（支持热更新）
+    config: Arc<RwLock<CircuitBreakerConfig>>,
+    /// 半开状态已放行的请求数（用于限流）
+    half_open_requests: Arc<AtomicU32>,
+}
+
+/// 熔断器放行结果
+///
+/// `used_half_open_permit` 表示本次放行是否占用了 HalfOpen 探测名额。
+/// 调用方应在请求结束后把该值传回 `record_success` / `record_failure` 用于正确释放名额。
+#[derive(Debug, Clone, Copy)]
+pub struct AllowResult {
+    pub allowed: bool,
+    pub used_half_open_permit: bool,
+}
+
+impl CircuitBreaker {
+    /// 创建新的熔断器
+    pub fn new(config: CircuitBreakerConfig) -> Self {
+        Self {
+            state: Arc::new(RwLock::new(CircuitState::Closed)),
+            consecutive_failures: Arc::new(AtomicU32::new(0)),
+            consecutive_successes: Arc::new(AtomicU32::new(0)),
+            total_requests: Arc::new(AtomicU32::new(0)),
+            failed_requests: Arc::new(AtomicU32::new(0)),
+            last_opened_at: Arc::new(RwLock::new(None)),
+            config: Arc::new(RwLock::new(config)),
+            half_open_requests: Arc::new(AtomicU32::new(0)),
+        }
+    }
+
+    /// 更新熔断器配置（热更新，不重置状态）
+    pub async fn update_config(&self, new_config: CircuitBreakerConfig) {
+        *self.config.write().await = new_config;
+        log::debug!("Circuit breaker config updated");
+    }
+
+    /// 判断当前 Provider 是否“可被纳入候选链路”
+    ///
+    /// 这个方法不会占用 HalfOpen 探测名额，仅用于路由选择阶段的“可用性判断”：
+    /// - Closed / HalfOpen：可用（返回 true）
+    /// - Open：若超时到达则切到 HalfOpen 并返回 true，否则返回 false
+    ///
+    /// 注意：真正发起请求前仍需调用 `allow_request()` 来获取 HalfOpen 探测名额，
+    /// 并在请求结束后通过 `record_success()` / `record_failure()` 释放。
+    pub async fn is_available(&self) -> bool {
+        let state = *self.state.read().await;
+        let config = self.config.read().await;
+
+        match state {
+            CircuitState::Closed | CircuitState::HalfOpen => true,
+            CircuitState::Open => {
+                if let Some(opened_at) = *self.last_opened_at.read().await {
+                    if opened_at.elapsed().as_secs() >= config.timeout_seconds {
+                        drop(config); // 释放读锁再转换状态
+                        log::info!(
+                            "Circuit breaker transitioning from Open to HalfOpen (timeout reached)"
+                        );
+                        self.transition_to_half_open().await;
+                        return true;
+                    }
+                }
+                false
+            }
+        }
+    }
+
+    /// 检查是否允许请求通过
+    pub async fn allow_request(&self) -> AllowResult {
+        let state = *self.state.read().await;
+
+        match state {
+            CircuitState::Closed => AllowResult {
+                allowed: true,
+                used_half_open_permit: false,
+            },
+            CircuitState::Open => {
+                let config = self.config.read().await;
+                // 检查是否应该尝试半开
+                if let Some(opened_at) = *self.last_opened_at.read().await {
+                    if opened_at.elapsed().as_secs() >= config.timeout_seconds {
+                        drop(config); // 释放读锁再转换状态
+                        log::info!(
+                            "Circuit breaker transitioning from Open to HalfOpen (timeout reached)"
+                        );
+                        self.transition_to_half_open().await;
+
+                        // 转换后按当前状态决定是否需要获取 HalfOpen 探测名额
+                        let current_state = *self.state.read().await;
+                        return match current_state {
+                            CircuitState::Closed => AllowResult {
+                                allowed: true,
+                                used_half_open_permit: false,
+                            },
+                            CircuitState::HalfOpen => self.allow_half_open_probe(),
+                            CircuitState::Open => AllowResult {
+                                allowed: false,
+                                used_half_open_permit: false,
+                            },
+                        };
+                    }
+                }
+
+                AllowResult {
+                    allowed: false,
+                    used_half_open_permit: false,
+                }
+            }
+            CircuitState::HalfOpen => self.allow_half_open_probe(),
+        }
+    }
+
+    /// 记录成功
+    pub async fn record_success(&self, used_half_open_permit: bool) {
+        let state = *self.state.read().await;
+        let config = self.config.read().await;
+
+        if used_half_open_permit {
+            self.release_half_open_permit();
+        }
+
+        // 重置失败计数
+        self.consecutive_failures.store(0, Ordering::SeqCst);
+        self.total_requests.fetch_add(1, Ordering::SeqCst);
+
+        match state {
+            CircuitState::HalfOpen => {
+                let successes = self.consecutive_successes.fetch_add(1, Ordering::SeqCst) + 1;
+                log::debug!(
+                    "Circuit breaker HalfOpen: {} consecutive successes (threshold: {})",
+                    successes,
+                    config.success_threshold
+                );
+
+                if successes >= config.success_threshold {
+                    drop(config); // 释放读锁再转换状态
+                    log::info!("Circuit breaker transitioning from HalfOpen to Closed (success threshold reached)");
+                    self.transition_to_closed().await;
+                }
+            }
+            CircuitState::Closed => {
+                log::debug!("Circuit breaker Closed: request succeeded");
+            }
+            _ => {}
+        }
+    }
+
+    /// 记录失败
+    pub async fn record_failure(&self, used_half_open_permit: bool) {
+        let state = *self.state.read().await;
+        let config = self.config.read().await;
+
+        if used_half_open_permit {
+            self.release_half_open_permit();
+        }
+
+        // 更新计数器
+        let failures = self.consecutive_failures.fetch_add(1, Ordering::SeqCst) + 1;
+        self.total_requests.fetch_add(1, Ordering::SeqCst);
+        self.failed_requests.fetch_add(1, Ordering::SeqCst);
+
+        // 重置成功计数
+        self.consecutive_successes.store(0, Ordering::SeqCst);
+
+        log::debug!(
+            "Circuit breaker {:?}: {} consecutive failures (threshold: {})",
+            state,
+            failures,
+            config.failure_threshold
+        );
+
+        // 检查是否应该打开熔断器
+        match state {
+            CircuitState::HalfOpen => {
+                // HalfOpen 状态下失败，立即转为 Open
+                log::warn!("Circuit breaker HalfOpen probe failed, transitioning to Open");
+                drop(config);
+                self.transition_to_open().await;
+            }
+            CircuitState::Closed => {
+                // 检查连续失败次数
+                if failures >= config.failure_threshold {
+                    log::warn!(
+                        "Circuit breaker opening due to {} consecutive failures (threshold: {})",
+                        failures,
+                        config.failure_threshold
+                    );
+                    drop(config); // 释放读锁再转换状态
+                    self.transition_to_open().await;
+                } else {
+                    // 检查错误率
+                    let total = self.total_requests.load(Ordering::SeqCst);
+                    let failed = self.failed_requests.load(Ordering::SeqCst);
+
+                    if total >= config.min_requests {
+                        let error_rate = failed as f64 / total as f64;
+                        log::debug!(
+                            "Circuit breaker error rate: {:.2}% ({}/{} requests)",
+                            error_rate * 100.0,
+                            failed,
+                            total
+                        );
+
+                        if error_rate >= config.error_rate_threshold {
+                            log::warn!(
+                                "Circuit breaker opening due to high error rate: {:.2}% (threshold: {:.2}%)",
+                                error_rate * 100.0,
+                                config.error_rate_threshold * 100.0
+                            );
+                            drop(config); // 释放读锁再转换状态
+                            self.transition_to_open().await;
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    /// 获取当前状态
+    #[allow(dead_code)]
+    pub async fn get_state(&self) -> CircuitState {
+        *self.state.read().await
+    }
+
+    /// 获取统计信息
+    #[allow(dead_code)]
+    pub async fn get_stats(&self) -> CircuitBreakerStats {
+        CircuitBreakerStats {
+            state: *self.state.read().await,
+            consecutive_failures: self.consecutive_failures.load(Ordering::SeqCst),
+            consecutive_successes: self.consecutive_successes.load(Ordering::SeqCst),
+            total_requests: self.total_requests.load(Ordering::SeqCst),
+            failed_requests: self.failed_requests.load(Ordering::SeqCst),
+        }
+    }
+
+    /// 重置熔断器（手动恢复）
+    #[allow(dead_code)]
+    pub async fn reset(&self) {
+        log::info!("Circuit breaker manually reset to Closed state");
+        self.transition_to_closed().await;
+    }
+
+    fn allow_half_open_probe(&self) -> AllowResult {
+        // 半开状态限流：只允许有限请求通过进行探测
+        // 默认最多允许 1 个请求（可在配置中扩展）
+        let max_half_open_requests = 1u32;
+        let current = self.half_open_requests.fetch_add(1, Ordering::SeqCst);
+
+        if current < max_half_open_requests {
+            log::debug!(
+                "Circuit breaker HalfOpen: allowing probe request ({}/{})",
+                current + 1,
+                max_half_open_requests
+            );
+            AllowResult {
+                allowed: true,
+                used_half_open_permit: true,
+            }
+        } else {
+            // 超过限额，回退计数，拒绝请求
+            self.half_open_requests.fetch_sub(1, Ordering::SeqCst);
+            log::debug!(
+                "Circuit breaker HalfOpen: rejecting request (limit reached: {max_half_open_requests})"
+            );
+            AllowResult {
+                allowed: false,
+                used_half_open_permit: false,
+            }
+        }
+    }
+
+    fn release_half_open_permit(&self) {
+        let mut current = self.half_open_requests.load(Ordering::SeqCst);
+        loop {
+            if current == 0 {
+                // 理论上不应该发生：说明调用方传入的 used_half_open_permit 与实际占用不一致
+                log::debug!("Circuit breaker HalfOpen permit already released (counter=0)");
+                return;
+            }
+
+            match self.half_open_requests.compare_exchange(
+                current,
+                current - 1,
+                Ordering::SeqCst,
+                Ordering::SeqCst,
+            ) {
+                Ok(_) => return,
+                Err(actual) => current = actual,
+            }
+        }
+    }
+
+    /// 转换到打开状态
+    async fn transition_to_open(&self) {
+        *self.state.write().await = CircuitState::Open;
+        *self.last_opened_at.write().await = Some(Instant::now());
+        self.consecutive_failures.store(0, Ordering::SeqCst);
+        self.consecutive_successes.store(0, Ordering::SeqCst);
+    }
+
+    /// 转换到半开状态
+    async fn transition_to_half_open(&self) {
+        let mut state = self.state.write().await;
+        if *state != CircuitState::Open {
+            return;
+        }
+
+        *state = CircuitState::HalfOpen;
+        self.consecutive_successes.store(0, Ordering::SeqCst);
+        // 重置半开状态的请求限流计数
+        self.half_open_requests.store(0, Ordering::SeqCst);
+    }
+
+    /// 转换到关闭状态
+    async fn transition_to_closed(&self) {
+        *self.state.write().await = CircuitState::Closed;
+        self.consecutive_failures.store(0, Ordering::SeqCst);
+        self.consecutive_successes.store(0, Ordering::SeqCst);
+        // 重置计数器
+        self.total_requests.store(0, Ordering::SeqCst);
+        self.failed_requests.store(0, Ordering::SeqCst);
+    }
+}
+
+/// 熔断器统计信息
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CircuitBreakerStats {
+    pub state: CircuitState,
+    pub consecutive_failures: u32,
+    pub consecutive_successes: u32,
+    pub total_requests: u32,
+    pub failed_requests: u32,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_circuit_breaker_closed_to_open() {
+        let config = CircuitBreakerConfig {
+            failure_threshold: 3,
+            ..Default::default()
+        };
+        let breaker = CircuitBreaker::new(config);
+
+        // 初始状态应该是关闭
+        assert_eq!(breaker.get_state().await, CircuitState::Closed);
+        assert!(breaker.allow_request().await.allowed);
+
+        // 记录 3 次失败
+        for _ in 0..3 {
+            breaker.record_failure(false).await;
+        }
+
+        // 应该转换到打开状态
+        assert_eq!(breaker.get_state().await, CircuitState::Open);
+        assert!(!breaker.allow_request().await.allowed);
+    }
+
+    #[tokio::test]
+    async fn test_circuit_breaker_half_open_to_closed() {
+        let config = CircuitBreakerConfig {
+            failure_threshold: 2,
+            success_threshold: 2,
+            ..Default::default()
+        };
+        let breaker = CircuitBreaker::new(config);
+
+        // 打开熔断器
+        breaker.record_failure(false).await;
+        breaker.record_failure(false).await;
+        assert_eq!(breaker.get_state().await, CircuitState::Open);
+
+        // 手动转换到半开状态
+        breaker.transition_to_half_open().await;
+        assert_eq!(breaker.get_state().await, CircuitState::HalfOpen);
+
+        // 记录 2 次成功
+        breaker.record_success(false).await;
+        breaker.record_success(false).await;
+
+        // 应该转换到关闭状态
+        assert_eq!(breaker.get_state().await, CircuitState::Closed);
+    }
+
+    #[tokio::test]
+    async fn test_half_open_transition_does_not_reset_inflight_permit() {
+        let config = CircuitBreakerConfig {
+            timeout_seconds: 0,
+            ..Default::default()
+        };
+        let breaker = CircuitBreaker::new(config);
+
+        // 进入 Open，然后由于 timeout_seconds=0，allow_request 会立即切换到 HalfOpen 并占用探测名额
+        breaker.transition_to_open().await;
+        let first = breaker.allow_request().await;
+        assert!(first.allowed);
+        assert!(first.used_half_open_permit);
+        assert_eq!(breaker.get_state().await, CircuitState::HalfOpen);
+
+        // 模拟并发下的“重复 HalfOpen 转换调用”，不应重置 in-flight 计数
+        breaker.transition_to_half_open().await;
+
+        // 由于名额仍被占用，第二次请求应被拒绝
+        let second = breaker.allow_request().await;
+        assert!(!second.allowed);
+        assert!(!second.used_half_open_permit);
+    }
+
+    #[tokio::test]
+    async fn test_circuit_breaker_reset() {
+        let config = CircuitBreakerConfig {
+            failure_threshold: 2,
+            ..Default::default()
+        };
+        let breaker = CircuitBreaker::new(config);
+
+        // 打开熔断器
+        breaker.record_failure(false).await;
+        breaker.record_failure(false).await;
+        assert_eq!(breaker.get_state().await, CircuitState::Open);
+
+        // 重置
+        breaker.reset().await;
+        assert_eq!(breaker.get_state().await, CircuitState::Closed);
+        assert!(breaker.allow_request().await.allowed);
+    }
+}
@@ -0,0 +1,110 @@
+//! 错误类型到 HTTP 状态码的映射
+//!
+//! 将 ProxyError 映射到合适的 HTTP 状态码，用于日志记录
+
+use super::ProxyError;
+
+/// 将 ProxyError 映射到 HTTP 状态码
+///
+/// 映射规则：
+/// - 上游错误：直接使用上游返回的状态码
+/// - 超时：504 Gateway Timeout
+/// - 连接失败：502 Bad Gateway
+/// - 无可用 Provider：503 Service Unavailable
+/// - 重试耗尽：503 Service Unavailable
+/// - 其他错误：500 Internal Server Error
+pub fn map_proxy_error_to_status(error: &ProxyError) -> u16 {
+    match error {
+        // 上游错误：使用实际状态码
+        ProxyError::UpstreamError { status, .. } => *status,
+
+        // 超时错误：504 Gateway Timeout
+        ProxyError::Timeout(_) => 504,
+
+        // 转发失败/连接失败：502 Bad Gateway
+        ProxyError::ForwardFailed(_) => 502,
+
+        // 无可用 Provider：503 Service Unavailable
+        ProxyError::NoAvailableProvider => 503,
+
+        // 重试耗尽：503 Service Unavailable
+        ProxyError::MaxRetriesExceeded => 503,
+
+        // Provider 不健康：503 Service Unavailable
+        ProxyError::ProviderUnhealthy(_) => 503,
+
+        // 数据库错误：500 Internal Server Error
+        ProxyError::DatabaseError(_) => 500,
+
+        // 转换错误：500 Internal Server Error
+        ProxyError::TransformError(_) => 500,
+
+        // 其他未知错误：500 Internal Server Error
+        _ => 500,
+    }
+}
+
+/// 将 ProxyError 转换为用户友好的错误消息
+pub fn get_error_message(error: &ProxyError) -> String {
+    match error {
+        ProxyError::UpstreamError { status, body } => {
+            if let Some(body) = body {
+                format!("上游错误 ({status}): {body}")
+            } else {
+                format!("上游错误 ({status})")
+            }
+        }
+        ProxyError::Timeout(msg) => format!("请求超时: {msg}"),
+        ProxyError::ForwardFailed(msg) => format!("转发失败: {msg}"),
+        ProxyError::NoAvailableProvider => "无可用 Provider".to_string(),
+        ProxyError::MaxRetriesExceeded => "所有 Provider 都失败，重试耗尽".to_string(),
+        ProxyError::ProviderUnhealthy(msg) => format!("Provider 不健康: {msg}"),
+        ProxyError::DatabaseError(msg) => format!("数据库错误: {msg}"),
+        ProxyError::TransformError(msg) => format!("请求/响应转换错误: {msg}"),
+        _ => error.to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_map_upstream_error() {
+        let error = ProxyError::UpstreamError {
+            status: 401,
+            body: Some("Unauthorized".to_string()),
+        };
+        assert_eq!(map_proxy_error_to_status(&error), 401);
+    }
+
+    #[test]
+    fn test_map_timeout_error() {
+        let error = ProxyError::Timeout("Request timeout".to_string());
+        assert_eq!(map_proxy_error_to_status(&error), 504);
+    }
+
+    #[test]
+    fn test_map_connection_error() {
+        let error = ProxyError::ForwardFailed("Connection refused".to_string());
+        assert_eq!(map_proxy_error_to_status(&error), 502);
+    }
+
+    #[test]
+    fn test_map_no_provider_error() {
+        let error = ProxyError::NoAvailableProvider;
+        assert_eq!(map_proxy_error_to_status(&error), 503);
+    }
+
+    #[test]
+    fn test_get_error_message() {
+        let error = ProxyError::UpstreamError {
+            status: 500,
+            body: Some("Internal Server Error".to_string()),
+        };
+        let msg = get_error_message(&error);
+        assert!(msg.contains("上游错误"));
+        assert!(msg.contains("500"));
+        assert!(msg.contains("Internal Server Error"));
+    }
+}
@@ -0,0 +1,134 @@
+//! 故障转移切换模块
+//!
+//! 处理故障转移成功后的供应商切换逻辑，包括：
+//! - 去重控制（避免多个请求同时触发）
+//! - 数据库更新
+//! - 托盘菜单更新
+//! - 前端事件发射
+//! - Live 备份更新
+
+use crate::database::Database;
+use crate::error::AppError;
+use std::collections::HashSet;
+use std::str::FromStr;
+use std::sync::Arc;
+use tauri::{Emitter, Manager};
+use tokio::sync::RwLock;
+
+/// 故障转移切换管理器
+///
+/// 负责处理故障转移成功后的供应商切换，确保 UI 能够直观反映当前使用的供应商。
+#[derive(Clone)]
+pub struct FailoverSwitchManager {
+    /// 正在处理中的切换（key = "app_type:provider_id"）
+    pending_switches: Arc<RwLock<HashSet<String>>>,
+    db: Arc<Database>,
+}
+
+impl FailoverSwitchManager {
+    pub fn new(db: Arc<Database>) -> Self {
+        Self {
+            pending_switches: Arc::new(RwLock::new(HashSet::new())),
+            db,
+        }
+    }
+
+    /// 尝试执行故障转移切换
+    ///
+    /// 如果相同的切换已在进行中，则跳过；否则执行切换逻辑。
+    ///
+    /// # Returns
+    /// - `Ok(true)` - 切换成功执行
+    /// - `Ok(false)` - 切换已在进行中，跳过
+    /// - `Err(e)` - 切换过程中发生错误
+    pub async fn try_switch(
+        &self,
+        app_handle: Option<&tauri::AppHandle>,
+        app_type: &str,
+        provider_id: &str,
+        provider_name: &str,
+    ) -> Result<bool, AppError> {
+        let switch_key = format!("{app_type}:{provider_id}");
+
+        // 去重检查：如果相同切换已在进行中，跳过
+        {
+            let mut pending = self.pending_switches.write().await;
+            if pending.contains(&switch_key) {
+                log::debug!("[Failover] 切换已在进行中，跳过: {app_type} -> {provider_id}");
+                return Ok(false);
+            }
+            pending.insert(switch_key.clone());
+        }
+
+        // 执行切换（确保最后清理 pending 标记）
+        let result = self
+            .do_switch(app_handle, app_type, provider_id, provider_name)
+            .await;
+
+        // 清理 pending 标记
+        {
+            let mut pending = self.pending_switches.write().await;
+            pending.remove(&switch_key);
+        }
+
+        result
+    }
+
+    async fn do_switch(
+        &self,
+        app_handle: Option<&tauri::AppHandle>,
+        app_type: &str,
+        provider_id: &str,
+        provider_name: &str,
+    ) -> Result<bool, AppError> {
+        log::info!("[Failover] 开始切换供应商: {app_type} -> {provider_name} ({provider_id})");
+
+        // 1. 更新数据库 is_current
+        self.db.set_current_provider(app_type, provider_id)?;
+
+        // 2. 更新本地 settings（设备级）
+        let app_type_enum = crate::app_config::AppType::from_str(app_type)
+            .map_err(|_| AppError::Message(format!("无效的应用类型: {app_type}")))?;
+        crate::settings::set_current_provider(&app_type_enum, Some(provider_id))?;
+
+        // 3. 更新托盘菜单和发射事件
+        if let Some(app) = app_handle {
+            // 更新托盘菜单
+            if let Some(app_state) = app.try_state::<crate::store::AppState>() {
+                // 更新 Live 备份（确保代理停止时恢复正确配置）
+                if let Ok(Some(provider)) = self.db.get_provider_by_id(provider_id, app_type) {
+                    if let Err(e) = app_state
+                        .proxy_service
+                        .update_live_backup_from_provider(app_type, &provider)
+                        .await
+                    {
+                        log::warn!("[Failover] 更新 Live 备份失败: {e}");
+                    }
+                }
+
+                // 重建托盘菜单
+                if let Ok(new_menu) = crate::tray::create_tray_menu(app, app_state.inner()) {
+                    if let Some(tray) = app.tray_by_id("main") {
+                        if let Err(e) = tray.set_menu(Some(new_menu)) {
+                            log::error!("[Failover] 更新托盘菜单失败: {e}");
+                        }
+                    }
+                }
+            }
+
+            // 发射事件到前端
+            let event_data = serde_json::json!({
+                "appType": app_type,
+                "providerId": provider_id,
+                "source": "failover"  // 标识来源是故障转移
+            });
+            if let Err(e) = app.emit("provider-switched", event_data) {
+                log::error!("[Failover] 发射供应商切换事件失败: {e}");
+            }
+        }
+
+        log::info!("[Failover] 供应商切换完成: {app_type} -> {provider_name} ({provider_id})");
+
+        Ok(true)
+    }
+}
@@ -4,31 +4,56 @@

 use super::{
    error::*,
+    failover_switch::FailoverSwitchManager,
+    provider_router::ProviderRouter,
    providers::{get_adapter, ProviderAdapter},
-    router::ProviderRouter,
    types::ProxyStatus,
    ProxyError,
 };
-use crate::{app_config::AppType, database::Database, provider::Provider};
+use crate::{app_config::AppType, provider::Provider};
 use reqwest::{Client, Response};
 use serde_json::Value;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::sync::RwLock;

+pub struct ForwardResult {
+    pub response: Response,
+    pub provider: Provider,
+}
+
+pub struct ForwardError {
+    pub error: ProxyError,
+    pub provider: Option<Provider>,
+}
+
 pub struct RequestForwarder {
    client: Client,
-    router: ProviderRouter,
+    /// 共享的 ProviderRouter（持有熔断器状态）
+    router: Arc<ProviderRouter>,
+    /// 单个 Provider 内的最大重试次数
    max_retries: u8,
    status: Arc<RwLock<ProxyStatus>>,
+    current_providers: Arc<RwLock<std::collections::HashMap<String, (String, String)>>>,
+    /// 故障转移切换管理器
+    failover_manager: Arc<FailoverSwitchManager>,
+    /// AppHandle，用于发射事件和更新托盘
+    app_handle: Option<tauri::AppHandle>,
+    /// 请求开始时的“当前供应商 ID”（用于判断是否需要同步 UI/托盘）
+    current_provider_id_at_start: String,
 }

 impl RequestForwarder {
+    #[allow(clippy::too_many_arguments)]
    pub fn new(
-        db: Arc<Database>,
+        router: Arc<ProviderRouter>,
        timeout_secs: u64,
        max_retries: u8,
        status: Arc<RwLock<ProxyStatus>>,
+        current_providers: Arc<RwLock<std::collections::HashMap<String, (String, String)>>>,
+        failover_manager: Arc<FailoverSwitchManager>,
+        app_handle: Option<tauri::AppHandle>,
+        current_provider_id_at_start: String,
    ) -> Self {
        let mut client_builder = Client::builder();
        if timeout_secs > 0 {
@@ -41,35 +66,133 @@ impl RequestForwarder {

        Self {
            client,
-            router: ProviderRouter::new(db),
+            router,
            max_retries,
            status,
+            current_providers,
+            failover_manager,
+            app_handle,
+            current_provider_id_at_start,
        }
    }

-    /// 转发请求（带重试和故障转移）
+    /// 对单个 Provider 执行请求（带重试）
+    ///
+    /// 在同一个 Provider 上最多重试 max_retries 次，使用指数退避
+    async fn forward_with_provider_retry(
+        &self,
+        provider: &Provider,
+        endpoint: &str,
+        body: &Value,
+        headers: &axum::http::HeaderMap,
+        adapter: &dyn ProviderAdapter,
+    ) -> Result<Response, ProxyError> {
+        let mut last_error = None;
+
+        for attempt in 0..=self.max_retries {
+            if attempt > 0 {
+                // 指数退避：100ms, 200ms, 400ms, ...
+                let delay_ms = 100 * 2u64.pow(attempt as u32 - 1);
+                log::info!(
+                    "[{}] 重试第 {}/{} 次（等待 {}ms）",
+                    adapter.name(),
+                    attempt,
+                    self.max_retries,
+                    delay_ms
+                );
+                tokio::time::sleep(Duration::from_millis(delay_ms)).await;
+            }
+
+            match self
+                .forward(provider, endpoint, body, headers, adapter)
+                .await
+            {
+                Ok(response) => return Ok(response),
+                Err(e) => {
+                    // 只有“同一 Provider 内可重试”的错误才继续重试
+                    if !self.should_retry_same_provider(&e) {
+                        return Err(e);
+                    }
+
+                    log::debug!(
+                        "[{}] Provider {} 第 {} 次请求失败: {}",
+                        adapter.name(),
+                        provider.name,
+                        attempt + 1,
+                        e
+                    );
+                    last_error = Some(e);
+                }
+            }
+        }
+
+        Err(last_error.unwrap_or(ProxyError::MaxRetriesExceeded))
+    }
+
+    /// 转发请求（带故障转移）
+    ///
+    /// # Arguments
+    /// * `app_type` - 应用类型
+    /// * `endpoint` - API 端点
+    /// * `body` - 请求体
+    /// * `headers` - 请求头
+    /// * `providers` - 已选择的 Provider 列表（由 RequestContext 提供，避免重复调用 select_providers）
    pub async fn forward_with_retry(
        &self,
        app_type: &AppType,
        endpoint: &str,
        body: Value,
        headers: axum::http::HeaderMap,
-    ) -> Result<Response, ProxyError> {
-        let mut failed_ids = Vec::new();
-        let mut failover_happened = false;
-
+        providers: Vec<Provider>,
+    ) -> Result<ForwardResult, ForwardError> {
        // 获取适配器
        let adapter = get_adapter(app_type);
+        let app_type_str = app_type.as_str();

-        for attempt in 0..self.max_retries {
-            // 选择Provider
-            let provider = self.router.select_provider(app_type, &failed_ids).await?;
+        if providers.is_empty() {
+            return Err(ForwardError {
+                error: ProxyError::NoAvailableProvider,
+                provider: None,
+            });
+        }

-            log::debug!(
-                "尝试 {} - 使用Provider: {} ({})",
-                attempt + 1,
+        log::info!(
+            "[{}] 故障转移链: {} 个可用供应商",
+            app_type_str,
+            providers.len()
+        );
+
+        let mut last_error = None;
+        let mut last_provider = None;
+        let mut attempted_providers = 0usize;
+
+        // 依次尝试每个供应商
+        for provider in providers.iter() {
+            // 发起请求前先获取熔断器放行许可（HalfOpen 会占用探测名额）
+            let permit = self
+                .router
+                .allow_provider_request(&provider.id, app_type_str)
+                .await;
+            if !permit.allowed {
+                log::debug!(
+                    "[{}] Provider {} 熔断器拒绝本次请求，跳过",
+                    app_type_str,
+                    provider.name
+                );
+                continue;
+            }
+
+            let used_half_open_permit = permit.used_half_open_permit;
+
+            attempted_providers += 1;
+
+            log::info!(
+                "[{}] 尝试 {}/{} - 使用Provider: {} (sort_index: {})",
+                app_type_str,
+                attempted_providers,
+                providers.len(),
                provider.name,
-                provider.id
+                provider.sort_index.unwrap_or(999999)
            );

            // 更新状态中的当前Provider信息
@@ -79,33 +202,71 @@ impl RequestForwarder {
                status.current_provider_id = Some(provider.id.clone());
                status.total_requests += 1;
                status.last_request_at = Some(chrono::Utc::now().to_rfc3339());
-                if attempt > 0 {
-                    failover_happened = true;
-                }
            }

            let start = Instant::now();

-            // 转发请求
+            // 转发请求（带单 Provider 内重试）
            match self
-                .forward(&provider, endpoint, &body, &headers, adapter.as_ref())
+                .forward_with_provider_retry(provider, endpoint, &body, &headers, adapter.as_ref())
                .await
            {
                Ok(response) => {
-                    let _latency = start.elapsed().as_millis() as u64;
+                    let latency = start.elapsed().as_millis() as u64;

-                    // 成功：更新健康状态
-                    self.router
-                        .update_health(&provider, app_type, true, None)
-                        .await;
+                    // 成功：记录成功并更新熔断器
+                    if let Err(e) = self
+                        .router
+                        .record_result(
+                            &provider.id,
+                            app_type_str,
+                            used_half_open_permit,
+                            true,
+                            None,
+                        )
+                        .await
+                    {
+                        log::warn!("Failed to record success: {e}");
+                    }
+
+                    // 更新当前应用类型使用的 provider
+                    {
+                        let mut current_providers = self.current_providers.write().await;
+                        current_providers.insert(
+                            app_type_str.to_string(),
+                            (provider.id.clone(), provider.name.clone()),
+                        );
+                    }

                    // 更新成功统计
                    {
                        let mut status = self.status.write().await;
                        status.success_requests += 1;
                        status.last_error = None;
-                        if failover_happened {
+                        let should_switch =
+                            self.current_provider_id_at_start.as_str() != provider.id.as_str();
+                        if should_switch {
                            status.failover_count += 1;
+                            log::info!(
+                                "[{}] 代理目标已切换到 Provider: {} (耗时: {}ms)",
+                                app_type_str,
+                                provider.name,
+                                latency
+                            );
+
+                            // 异步触发供应商切换，更新 UI/托盘，并把“当前供应商”同步为实际使用的 provider
+                            let fm = self.failover_manager.clone();
+                            let ah = self.app_handle.clone();
+                            let pid = provider.id.clone();
+                            let pname = provider.name.clone();
+                            let at = app_type_str.to_string();
+
+                            tokio::spawn(async move {
+                                if let Err(e) = fm.try_switch(ah.as_ref(), &at, &pid, &pname).await
+                                {
+                                    log::error!("[Failover] 切换供应商失败: {e}");
+                                }
+                            });
                        }
                        // 重新计算成功率
                        if status.total_requests > 0 {
@@ -115,23 +276,42 @@ impl RequestForwarder {
                        }
                    }

-                    return Ok(response);
+                    log::info!(
+                        "[{}] 请求成功 - Provider: {} - {}ms",
+                        app_type_str,
+                        provider.name,
+                        latency
+                    );
+
+                    return Ok(ForwardResult {
+                        response,
+                        provider: provider.clone(),
+                    });
                }
                Err(e) => {
                    let latency = start.elapsed().as_millis() as u64;

-                    // 失败：分类错误
+                    // 失败：记录失败并更新熔断器
+                    if let Err(record_err) = self
+                        .router
+                        .record_result(
+                            &provider.id,
+                            app_type_str,
+                            used_half_open_permit,
+                            false,
+                            Some(e.to_string()),
+                        )
+                        .await
+                    {
+                        log::warn!("Failed to record failure: {record_err}");
+                    }
+
+                    // 分类错误
                    let category = self.categorize_proxy_error(&e);

                    match category {
                        ErrorCategory::Retryable => {
-                            // 可重试：更新健康状态，添加到失败列表
-                            self.router
-                                .update_health(&provider, app_type, false, Some(e.to_string()))
-                                .await;
-                            failed_ids.push(provider.id.clone());
-
-                            // 更新错误信息
+                            // 可重试：更新错误信息，继续尝试下一个供应商
                            {
                                let mut status = self.status.write().await;
                                status.last_error =
@@ -139,15 +319,20 @@ impl RequestForwarder {
                            }

                            log::warn!(
-                                "请求失败（可重试）: Provider {} - {} - {}ms",
+                                "[{}] Provider {} 失败（可重试）: {} - {}ms",
+                                app_type_str,
                                provider.name,
                                e,
                                latency
                            );
+
+                            last_error = Some(e);
+                            last_provider = Some(provider.clone());
+                            // 继续尝试下一个供应商
                            continue;
                        }
                        ErrorCategory::NonRetryable | ErrorCategory::ClientAbort => {
-                            // 不可重试：更新失败统计并返回
+                            // 不可重试：直接返回错误
                            {
                                let mut status = self.status.write().await;
                                status.failed_requests += 1;
@@ -158,26 +343,60 @@ impl RequestForwarder {
                                        * 100.0;
                                }
                            }
-                            log::error!("请求失败（不可重试）: {e}");
-                            return Err(e);
+                            log::error!(
+                                "[{}] Provider {} 失败（不可重试）: {}",
+                                app_type_str,
+                                provider.name,
+                                e
+                            );
+                            return Err(ForwardError {
+                                error: e,
+                                provider: Some(provider.clone()),
+                            });
                        }
                    }
                }
            }
        }

-        // 所有重试都失败
+        if attempted_providers == 0 {
+            // providers 列表非空，但全部被熔断器拒绝（典型：HalfOpen 探测名额被占用）
+            {
+                let mut status = self.status.write().await;
+                status.failed_requests += 1;
+                status.last_error = Some("所有供应商暂时不可用（熔断器限制）".to_string());
+                if status.total_requests > 0 {
+                    status.success_rate =
+                        (status.success_requests as f32 / status.total_requests as f32) * 100.0;
+                }
+            }
+            return Err(ForwardError {
+                error: ProxyError::NoAvailableProvider,
+                provider: None,
+            });
+        }
+
+        // 所有供应商都失败了
        {
            let mut status = self.status.write().await;
            status.failed_requests += 1;
-            status.last_error = Some("已达到最大重试次数".to_string());
+            status.last_error = Some("所有供应商都失败".to_string());
            if status.total_requests > 0 {
                status.success_rate =
                    (status.success_requests as f32 / status.total_requests as f32) * 100.0;
            }
        }

-        Err(ProxyError::MaxRetriesExceeded)
+        log::error!(
+            "[{}] 所有 {} 个供应商都失败了",
+            app_type_str,
+            providers.len()
+        );
+
+        Err(ForwardError {
+            error: last_error.unwrap_or(ProxyError::MaxRetriesExceeded),
+            provider: last_provider,
+        })
    }

    /// 转发单个请求（使用适配器）
@@ -307,21 +526,43 @@ impl RequestForwarder {
    }

    /// 分类ProxyError
+    ///
+    /// 决定哪些错误应该触发故障转移到下一个 Provider
+    ///
+    /// 设计原则：既然用户配置了多个供应商，就应该让所有供应商都尝试一遍。
+    /// 只有明确是客户端中断的情况才不重试。
+    fn should_retry_same_provider(&self, error: &ProxyError) -> bool {
+        match error {
+            // 网络类错误：短暂抖动时同一 Provider 内重试有意义
+            ProxyError::Timeout(_) => true,
+            ProxyError::ForwardFailed(_) => true,
+            // 上游 HTTP 错误：只对“可能瞬态”的状态码做同 Provider 重试（其余交给 failover）
+            ProxyError::UpstreamError { status, .. } => {
+                *status == 408 || *status == 429 || *status >= 500
+            }
+            _ => false,
+        }
+    }
+
    fn categorize_proxy_error(&self, error: &ProxyError) -> ErrorCategory {
        match error {
+            // 网络和上游错误：都应该尝试下一个供应商
            ProxyError::Timeout(_) => ErrorCategory::Retryable,
            ProxyError::ForwardFailed(_) => ErrorCategory::Retryable,
-            ProxyError::UpstreamError { status, .. } => {
-                if *status >= 500 {
-                    ErrorCategory::Retryable
-                } else if *status >= 400 && *status < 500 {
-                    ErrorCategory::NonRetryable
-                } else {
-                    ErrorCategory::Retryable
-                }
-            }
            ProxyError::ProviderUnhealthy(_) => ErrorCategory::Retryable,
+            // 上游 HTTP 错误：无论状态码如何，都尝试下一个供应商
+            // 原因：不同供应商有不同的限制和认证，一个供应商的 4xx 错误
+            // 不代表其他供应商也会失败
+            ProxyError::UpstreamError { .. } => ErrorCategory::Retryable,
+            // Provider 级配置/转换问题：换一个 Provider 可能就能成功
+            ProxyError::ConfigError(_) => ErrorCategory::Retryable,
+            ProxyError::TransformError(_) => ErrorCategory::Retryable,
+            ProxyError::AuthError(_) => ErrorCategory::Retryable,
+            ProxyError::StreamIdleTimeout(_) => ErrorCategory::Retryable,
+            ProxyError::MaxRetriesExceeded => ErrorCategory::Retryable,
+            // 无可用供应商：所有供应商都试过了，无法重试
            ProxyError::NoAvailableProvider => ErrorCategory::NonRetryable,
+            // 其他错误（数据库/内部错误等）：不是换供应商能解决的问题
            _ => ErrorCategory::NonRetryable,
        }
    }
@@ -0,0 +1,164 @@
+//! Handler 配置模块
+//!
+//! 定义各 API 处理器的配置结构和使用量解析器
+
+use crate::app_config::AppType;
+use crate::proxy::usage::parser::TokenUsage;
+use serde_json::Value;
+
+/// 使用量解析器类型别名
+pub type StreamUsageParser = fn(&[Value]) -> Option<TokenUsage>;
+pub type ResponseUsageParser = fn(&Value) -> Option<TokenUsage>;
+
+/// 模型提取器类型别名
+/// 参数: (流式事件列表, 请求中的模型名称) -> 最终使用的模型名称
+pub type StreamModelExtractor = fn(&[Value], &str) -> String;
+
+/// 各 API 的使用量解析配置
+#[derive(Clone, Copy)]
+pub struct UsageParserConfig {
+    /// 流式响应解析器
+    pub stream_parser: StreamUsageParser,
+    /// 非流式响应解析器
+    pub response_parser: ResponseUsageParser,
+    /// 流式响应中的模型提取器
+    pub model_extractor: StreamModelExtractor,
+    /// 应用类型字符串（用于日志记录）
+    pub app_type_str: &'static str,
+}
+
+// ============================================================================
+// 模型提取器实现
+// ============================================================================
+
+/// Claude 流式响应模型提取（直接使用请求模型）
+fn claude_model_extractor(_events: &[Value], request_model: &str) -> String {
+    request_model.to_string()
+}
+
+/// OpenAI Chat Completions 流式响应模型提取
+fn openai_model_extractor(events: &[Value], request_model: &str) -> String {
+    events
+        .iter()
+        .find_map(|e| e.get("model")?.as_str())
+        .unwrap_or(request_model)
+        .to_string()
+}
+
+/// Codex Responses API 流式响应模型提取
+fn codex_model_extractor(events: &[Value], request_model: &str) -> String {
+    events
+        .iter()
+        .find_map(|e| {
+            if e.get("type")?.as_str()? == "response.completed" {
+                e.get("response")?.get("model")?.as_str()
+            } else {
+                None
+            }
+        })
+        .unwrap_or(request_model)
+        .to_string()
+}
+
+/// Gemini 流式响应模型提取（优先使用 usage.model）
+fn gemini_model_extractor(events: &[Value], request_model: &str) -> String {
+    // 首先尝试从解析的 usage 中获取模型
+    if let Some(usage) = TokenUsage::from_gemini_stream_chunks(events) {
+        if let Some(model) = usage.model {
+            return model;
+        }
+    }
+    request_model.to_string()
+}
+
+// ============================================================================
+// 预定义配置
+// ============================================================================
+
+/// Claude API 解析配置
+pub const CLAUDE_PARSER_CONFIG: UsageParserConfig = UsageParserConfig {
+    stream_parser: TokenUsage::from_claude_stream_events,
+    response_parser: TokenUsage::from_claude_response,
+    model_extractor: claude_model_extractor,
+    app_type_str: "claude",
+};
+
+/// OpenAI Chat Completions API 解析配置（用于 Codex /v1/chat/completions）
+pub const OPENAI_PARSER_CONFIG: UsageParserConfig = UsageParserConfig {
+    stream_parser: TokenUsage::from_openai_stream_events,
+    response_parser: TokenUsage::from_openai_response,
+    model_extractor: openai_model_extractor,
+    app_type_str: "codex",
+};
+
+/// Codex Responses API 解析配置（用于 /v1/responses）
+pub const CODEX_PARSER_CONFIG: UsageParserConfig = UsageParserConfig {
+    stream_parser: TokenUsage::from_codex_stream_events,
+    response_parser: TokenUsage::from_codex_response,
+    model_extractor: codex_model_extractor,
+    app_type_str: "codex",
+};
+
+/// Gemini API 解析配置
+pub const GEMINI_PARSER_CONFIG: UsageParserConfig = UsageParserConfig {
+    stream_parser: TokenUsage::from_gemini_stream_chunks,
+    response_parser: TokenUsage::from_gemini_response,
+    model_extractor: gemini_model_extractor,
+    app_type_str: "gemini",
+};
+
+// ============================================================================
+// Handler 配置（预留，用于进一步简化）
+// ============================================================================
+
+/// Handler 基础配置
+///
+/// 预留结构，可用于进一步统一各 handler 的配置
+#[allow(dead_code)]
+#[derive(Clone)]
+pub struct HandlerConfig {
+    /// 应用类型
+    pub app_type: AppType,
+    /// 日志标签
+    pub tag: &'static str,
+    /// 应用类型字符串
+    pub app_type_str: &'static str,
+    /// 使用量解析配置
+    pub parser_config: &'static UsageParserConfig,
+}
+
+/// Claude Handler 配置
+#[allow(dead_code)]
+pub const CLAUDE_HANDLER_CONFIG: HandlerConfig = HandlerConfig {
+    app_type: AppType::Claude,
+    tag: "Claude",
+    app_type_str: "claude",
+    parser_config: &CLAUDE_PARSER_CONFIG,
+};
+
+/// Codex Chat Completions Handler 配置
+#[allow(dead_code)]
+pub const CODEX_CHAT_HANDLER_CONFIG: HandlerConfig = HandlerConfig {
+    app_type: AppType::Codex,
+    tag: "Codex",
+    app_type_str: "codex",
+    parser_config: &OPENAI_PARSER_CONFIG,
+};
+
+/// Codex Responses Handler 配置
+#[allow(dead_code)]
+pub const CODEX_RESPONSES_HANDLER_CONFIG: HandlerConfig = HandlerConfig {
+    app_type: AppType::Codex,
+    tag: "Codex",
+    app_type_str: "codex",
+    parser_config: &CODEX_PARSER_CONFIG,
+};
+
+/// Gemini Handler 配置
+#[allow(dead_code)]
+pub const GEMINI_HANDLER_CONFIG: HandlerConfig = HandlerConfig {
+    app_type: AppType::Gemini,
+    tag: "Gemini",
+    app_type_str: "gemini",
+    parser_config: &GEMINI_PARSER_CONFIG,
+};
@@ -0,0 +1,160 @@
+//! 请求上下文模块
+//!
+//! 提供请求生命周期的上下文管理，封装通用初始化逻辑
+
+use crate::app_config::AppType;
+use crate::provider::Provider;
+use crate::proxy::{
+    forwarder::RequestForwarder, server::ProxyState, types::ProxyConfig, ProxyError,
+};
+use std::time::Instant;
+
+/// 请求上下文
+///
+/// 贯穿整个请求生命周期，包含：
+/// - 计时信息
+/// - 代理配置
+/// - 选中的 Provider 列表（用于故障转移）
+/// - 请求模型名称
+/// - 日志标签
+pub struct RequestContext {
+    /// 请求开始时间
+    pub start_time: Instant,
+    /// 代理配置快照
+    pub config: ProxyConfig,
+    /// 选中的 Provider（故障转移链的第一个）
+    pub provider: Provider,
+    /// 完整的 Provider 列表（用于故障转移）
+    providers: Vec<Provider>,
+    /// 请求开始时的“当前供应商”（用于判断是否需要同步 UI/托盘）
+    ///
+    /// 这里使用本地 settings 的设备级 current provider。
+    /// 代理模式下如果实际使用的 provider 与此不一致，会触发切换以确保 UI 始终准确。
+    pub current_provider_id: String,
+    /// 请求中的模型名称
+    pub request_model: String,
+    /// 日志标签（如 "Claude"、"Codex"、"Gemini"）
+    pub tag: &'static str,
+    /// 应用类型字符串（如 "claude"、"codex"、"gemini"）
+    pub app_type_str: &'static str,
+    /// 应用类型（预留，目前通过 app_type_str 使用）
+    #[allow(dead_code)]
+    pub app_type: AppType,
+}
+
+impl RequestContext {
+    /// 创建请求上下文
+    ///
+    /// # Arguments
+    /// * `state` - 代理服务器状态
+    /// * `body` - 请求体 JSON
+    /// * `app_type` - 应用类型
+    /// * `tag` - 日志标签
+    /// * `app_type_str` - 应用类型字符串
+    ///
+    /// # Errors
+    /// 返回 `ProxyError` 如果 Provider 选择失败
+    pub async fn new(
+        state: &ProxyState,
+        body: &serde_json::Value,
+        app_type: AppType,
+        tag: &'static str,
+        app_type_str: &'static str,
+    ) -> Result<Self, ProxyError> {
+        let start_time = Instant::now();
+        let config = state.config.read().await.clone();
+        let current_provider_id =
+            crate::settings::get_current_provider(&app_type).unwrap_or_default();
+
+        // 从请求体提取模型名称
+        let request_model = body
+            .get("model")
+            .and_then(|m| m.as_str())
+            .unwrap_or("unknown")
+            .to_string();
+
+        // 使用共享的 ProviderRouter 选择 Provider（熔断器状态跨请求保持）
+        // 注意：只在这里调用一次，结果传递给 forwarder，避免重复消耗 HalfOpen 名额
+        let providers = state
+            .provider_router
+            .select_providers(app_type_str)
+            .await
+            .map_err(|e| ProxyError::DatabaseError(e.to_string()))?;
+
+        let provider = providers
+            .first()
+            .cloned()
+            .ok_or(ProxyError::NoAvailableProvider)?;
+
+        log::info!(
+            "[{}] Provider: {}, model: {}, failover chain: {} providers",
+            tag,
+            provider.name,
+            request_model,
+            providers.len()
+        );
+
+        Ok(Self {
+            start_time,
+            config,
+            provider,
+            providers,
+            current_provider_id,
+            request_model,
+            tag,
+            app_type_str,
+            app_type,
+        })
+    }
+
+    /// 从 URI 提取模型名称（Gemini 专用）
+    ///
+    /// Gemini API 的模型名称在 URI 中，格式如：
+    /// `/v1beta/models/gemini-pro:generateContent`
+    pub fn with_model_from_uri(mut self, uri: &axum::http::Uri) -> Self {
+        let endpoint = uri
+            .path_and_query()
+            .map(|pq| pq.as_str())
+            .unwrap_or(uri.path());
+
+        self.request_model = endpoint
+            .split('/')
+            .find(|s| s.starts_with("models/"))
+            .and_then(|s| s.strip_prefix("models/"))
+            .map(|s| s.split(':').next().unwrap_or(s))
+            .unwrap_or("unknown")
+            .to_string();
+
+        log::info!("[{}] 从 URI 提取模型: {}", self.tag, self.request_model);
+        self
+    }
+
+    /// 创建 RequestForwarder
+    ///
+    /// 使用共享的 ProviderRouter，确保熔断器状态跨请求保持
+    pub fn create_forwarder(&self, state: &ProxyState) -> RequestForwarder {
+        RequestForwarder::new(
+            state.provider_router.clone(),
+            self.config.request_timeout,
+            self.config.max_retries,
+            state.status.clone(),
+            state.current_providers.clone(),
+            state.failover_manager.clone(),
+            state.app_handle.clone(),
+            self.current_provider_id.clone(),
+        )
+    }
+
+    /// 获取 Provider 列表（用于故障转移）
+    ///
+    /// 返回在创建上下文时已选择的 providers，避免重复调用 select_providers()
+    pub fn get_providers(&self) -> Vec<Provider> {
+        self.providers.clone()
+    }
+
+    /// 计算请求延迟（毫秒）
+    #[inline]
+    pub fn latency_ms(&self) -> u64 {
+        self.start_time.elapsed().as_millis() as u64
+    }
+}
@@ -2,13 +2,19 @@
 //!
 //! 提供本地HTTP代理服务，支持多Provider故障转移和请求透传

+pub mod circuit_breaker;
 pub mod error;
+pub mod error_mapper;
+pub(crate) mod failover_switch;
 mod forwarder;
+pub mod handler_config;
+pub mod handler_context;
 mod handlers;
 mod health;
+pub mod provider_router;
 pub mod providers;
 pub mod response_handler;
-mod router;
+pub mod response_processor;
 pub(crate) mod server;
 pub mod session;
 pub(crate) mod types;
@@ -16,8 +22,14 @@ pub mod usage;

 // 公开导出给外部使用（commands, services等模块需要）
 #[allow(unused_imports)]
+pub use circuit_breaker::{
+    CircuitBreaker, CircuitBreakerConfig, CircuitBreakerStats, CircuitState,
+};
+#[allow(unused_imports)]
 pub use error::ProxyError;
 #[allow(unused_imports)]
+pub use provider_router::ProviderRouter;
+#[allow(unused_imports)]
 pub use response_handler::{NonStreamHandler, ResponseType, StreamHandler};
 #[allow(unused_imports)]
 pub use session::{ClientFormat, ProxySession};
@@ -0,0 +1,377 @@
+//! 供应商路由器模块
+//!
+//! 负责选择和管理代理目标供应商，实现智能故障转移
+
+use crate::database::Database;
+use crate::error::AppError;
+use crate::provider::Provider;
+use crate::proxy::circuit_breaker::{AllowResult, CircuitBreaker, CircuitBreakerConfig};
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+/// 供应商路由器
+pub struct ProviderRouter {
+    /// 数据库连接
+    db: Arc<Database>,
+    /// 熔断器管理器 - key 格式: "app_type:provider_id"
+    circuit_breakers: Arc<RwLock<HashMap<String, Arc<CircuitBreaker>>>>,
+}
+
+impl ProviderRouter {
+    /// 创建新的供应商路由器
+    pub fn new(db: Arc<Database>) -> Self {
+        Self {
+            db,
+            circuit_breakers: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    /// 选择可用的供应商（支持故障转移）
+    ///
+    /// 返回按优先级排序的可用供应商列表：
+    /// - 故障转移关闭时：仅返回当前供应商
+    /// - 故障转移开启时：完全按照故障转移队列顺序返回，忽略当前供应商设置
+    pub async fn select_providers(&self, app_type: &str) -> Result<Vec<Provider>, AppError> {
+        let mut result = Vec::new();
+
+        // 检查该应用的自动故障转移开关是否开启
+        let failover_key = format!("auto_failover_enabled_{app_type}");
+        let auto_failover_enabled = match self.db.get_setting(&failover_key) {
+            Ok(Some(value)) => {
+                let enabled = value == "true";
+                log::info!(
+                    "[{app_type}] Failover setting '{failover_key}' = '{value}', enabled: {enabled}"
+                );
+                enabled
+            }
+            Ok(None) => {
+                log::warn!(
+                    "[{app_type}] Failover setting '{failover_key}' not found in database, defaulting to disabled"
+                );
+                false
+            }
+            Err(e) => {
+                log::error!(
+                    "[{app_type}] Failed to read failover setting '{failover_key}': {e}, defaulting to disabled"
+                );
+                false
+            }
+        };
+
+        if auto_failover_enabled {
+            // 故障转移开启：使用 in_failover_queue 标记的供应商，按 sort_index 排序
+            let failover_providers = self.db.get_failover_providers(app_type)?;
+            log::info!(
+                "[{}] Failover enabled, using queue order ({} items)",
+                app_type,
+                failover_providers.len()
+            );
+
+            for provider in failover_providers {
+                // 检查熔断器状态
+                let circuit_key = format!("{}:{}", app_type, provider.id);
+                let breaker = self.get_or_create_circuit_breaker(&circuit_key).await;
+
+                if breaker.is_available().await {
+                    log::info!(
+                        "[{}] Queue provider available: {} ({}) at sort_index {:?}",
+                        app_type,
+                        provider.name,
+                        provider.id,
+                        provider.sort_index
+                    );
+                    result.push(provider);
+                } else {
+                    log::debug!(
+                        "[{}] Queue provider {} circuit breaker open, skipping",
+                        app_type,
+                        provider.name
+                    );
+                }
+            }
+        } else {
+            // 故障转移关闭：仅使用当前供应商
+            log::info!("[{app_type}] Failover disabled, using current provider only");
+
+            if let Some(current_id) = self.db.get_current_provider(app_type)? {
+                if let Some(current) = self.db.get_provider_by_id(&current_id, app_type)? {
+                    let circuit_key = format!("{}:{}", app_type, current.id);
+                    let breaker = self.get_or_create_circuit_breaker(&circuit_key).await;
+
+                    if breaker.is_available().await {
+                        log::info!(
+                            "[{}] Current provider available: {} ({})",
+                            app_type,
+                            current.name,
+                            current.id
+                        );
+                        result.push(current);
+                    } else {
+                        log::warn!(
+                            "[{}] Current provider {} circuit breaker open",
+                            app_type,
+                            current.name
+                        );
+                    }
+                }
+            }
+        }
+
+        if result.is_empty() {
+            return Err(AppError::Config(format!(
+                "No available provider for {app_type} (all circuit breakers open or no providers configured)"
+            )));
+        }
+
+        log::info!(
+            "[{}] Provider chain: {} provider(s) available",
+            app_type,
+            result.len()
+        );
+
+        Ok(result)
+    }
+
+    /// 请求执行前获取熔断器“放行许可”
+    ///
+    /// - Closed：直接放行
+    /// - Open：超时到达后切到 HalfOpen 并放行一次探测
+    /// - HalfOpen：按限流规则放行探测
+    ///
+    /// 注意：调用方必须在请求结束后通过 `record_result()` 释放 HalfOpen 名额，
+    /// 否则会导致该 Provider 长时间无法进入探测状态。
+    pub async fn allow_provider_request(&self, provider_id: &str, app_type: &str) -> AllowResult {
+        let circuit_key = format!("{app_type}:{provider_id}");
+        let breaker = self.get_or_create_circuit_breaker(&circuit_key).await;
+        breaker.allow_request().await
+    }
+
+    /// 记录供应商请求结果
+    pub async fn record_result(
+        &self,
+        provider_id: &str,
+        app_type: &str,
+        used_half_open_permit: bool,
+        success: bool,
+        error_msg: Option<String>,
+    ) -> Result<(), AppError> {
+        // 1. 获取熔断器配置（用于更新健康状态和判断是否禁用）
+        let config = self.db.get_circuit_breaker_config().await.ok();
+        let failure_threshold = config.map(|c| c.failure_threshold).unwrap_or(5);
+
+        // 2. 更新熔断器状态
+        let circuit_key = format!("{app_type}:{provider_id}");
+        let breaker = self.get_or_create_circuit_breaker(&circuit_key).await;
+
+        if success {
+            breaker.record_success(used_half_open_permit).await;
+            log::debug!("Provider {provider_id} request succeeded");
+        } else {
+            breaker.record_failure(used_half_open_permit).await;
+            log::warn!(
+                "Provider {} request failed: {}",
+                provider_id,
+                error_msg.as_deref().unwrap_or("Unknown error")
+            );
+        }
+
+        // 3. 更新数据库健康状态（使用配置的阈值）
+        self.db
+            .update_provider_health_with_threshold(
+                provider_id,
+                app_type,
+                success,
+                error_msg.clone(),
+                failure_threshold,
+            )
+            .await?;
+
+        Ok(())
+    }
+
+    /// 重置熔断器（手动恢复）
+    pub async fn reset_circuit_breaker(&self, circuit_key: &str) {
+        let breakers = self.circuit_breakers.read().await;
+        if let Some(breaker) = breakers.get(circuit_key) {
+            log::info!("Manually resetting circuit breaker for {circuit_key}");
+            breaker.reset().await;
+        }
+    }
+
+    /// 重置指定供应商的熔断器
+    pub async fn reset_provider_breaker(&self, provider_id: &str, app_type: &str) {
+        let circuit_key = format!("{app_type}:{provider_id}");
+        self.reset_circuit_breaker(&circuit_key).await;
+    }
+
+    /// 更新所有熔断器的配置（热更新）
+    ///
+    /// 当用户在 UI 中修改熔断器配置后调用此方法，
+    /// 所有现有的熔断器会立即使用新配置
+    pub async fn update_all_configs(&self, config: CircuitBreakerConfig) {
+        let breakers = self.circuit_breakers.read().await;
+        let count = breakers.len();
+
+        for breaker in breakers.values() {
+            breaker.update_config(config.clone()).await;
+        }
+
+        log::info!("已更新 {count} 个熔断器的配置");
+    }
+
+    /// 获取熔断器状态
+    #[allow(dead_code)]
+    pub async fn get_circuit_breaker_stats(
+        &self,
+        provider_id: &str,
+        app_type: &str,
+    ) -> Option<crate::proxy::circuit_breaker::CircuitBreakerStats> {
+        let circuit_key = format!("{app_type}:{provider_id}");
+        let breakers = self.circuit_breakers.read().await;
+
+        if let Some(breaker) = breakers.get(&circuit_key) {
+            Some(breaker.get_stats().await)
+        } else {
+            None
+        }
+    }
+
+    /// 获取或创建熔断器
+    async fn get_or_create_circuit_breaker(&self, key: &str) -> Arc<CircuitBreaker> {
+        // 先尝试读锁获取
+        {
+            let breakers = self.circuit_breakers.read().await;
+            if let Some(breaker) = breakers.get(key) {
+                return breaker.clone();
+            }
+        }
+
+        // 如果不存在，获取写锁创建
+        let mut breakers = self.circuit_breakers.write().await;
+
+        // 双重检查，防止竞争条件
+        if let Some(breaker) = breakers.get(key) {
+            return breaker.clone();
+        }
+
+        // 从数据库加载配置
+        let config = self
+            .db
+            .get_circuit_breaker_config()
+            .await
+            .unwrap_or_default();
+
+        log::debug!("Creating new circuit breaker for {key} with config: {config:?}");
+
+        let breaker = Arc::new(CircuitBreaker::new(config));
+        breakers.insert(key.to_string(), breaker.clone());
+
+        breaker
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::database::Database;
+    use serde_json::json;
+
+    #[tokio::test]
+    async fn test_provider_router_creation() {
+        let db = Arc::new(Database::memory().unwrap());
+        let router = ProviderRouter::new(db);
+
+        let breaker = router.get_or_create_circuit_breaker("claude:test").await;
+        assert!(breaker.allow_request().await.allowed);
+    }
+
+    #[tokio::test]
+    async fn test_failover_disabled_uses_current_provider() {
+        let db = Arc::new(Database::memory().unwrap());
+
+        let provider_a =
+            Provider::with_id("a".to_string(), "Provider A".to_string(), json!({}), None);
+        let provider_b =
+            Provider::with_id("b".to_string(), "Provider B".to_string(), json!({}), None);
+
+        db.save_provider("claude", &provider_a).unwrap();
+        db.save_provider("claude", &provider_b).unwrap();
+        db.set_current_provider("claude", "a").unwrap();
+        db.add_to_failover_queue("claude", "b").unwrap();
+
+        let router = ProviderRouter::new(db.clone());
+        let providers = router.select_providers("claude").await.unwrap();
+
+        assert_eq!(providers.len(), 1);
+        assert_eq!(providers[0].id, "a");
+    }
+
+    #[tokio::test]
+    async fn test_failover_enabled_uses_queue_order() {
+        let db = Arc::new(Database::memory().unwrap());
+
+        // 设置 sort_index 来控制顺序：b=1, a=2
+        let mut provider_a =
+            Provider::with_id("a".to_string(), "Provider A".to_string(), json!({}), None);
+        provider_a.sort_index = Some(2);
+        let mut provider_b =
+            Provider::with_id("b".to_string(), "Provider B".to_string(), json!({}), None);
+        provider_b.sort_index = Some(1);
+
+        db.save_provider("claude", &provider_a).unwrap();
+        db.save_provider("claude", &provider_b).unwrap();
+        db.set_current_provider("claude", "a").unwrap();
+
+        db.add_to_failover_queue("claude", "b").unwrap();
+        db.add_to_failover_queue("claude", "a").unwrap();
+        db.set_setting("auto_failover_enabled_claude", "true")
+            .unwrap();
+
+        let router = ProviderRouter::new(db.clone());
+        let providers = router.select_providers("claude").await.unwrap();
+
+        assert_eq!(providers.len(), 2);
+        // 按 sort_index 排序：b(1) 在前，a(2) 在后
+        assert_eq!(providers[0].id, "b");
+        assert_eq!(providers[1].id, "a");
+    }
+
+    #[tokio::test]
+    async fn test_select_providers_does_not_consume_half_open_permit() {
+        let db = Arc::new(Database::memory().unwrap());
+
+        db.update_circuit_breaker_config(&CircuitBreakerConfig {
+            failure_threshold: 1,
+            timeout_seconds: 0,
+            ..Default::default()
+        })
+        .await
+        .unwrap();
+
+        let provider_a =
+            Provider::with_id("a".to_string(), "Provider A".to_string(), json!({}), None);
+        let provider_b =
+            Provider::with_id("b".to_string(), "Provider B".to_string(), json!({}), None);
+
+        db.save_provider("claude", &provider_a).unwrap();
+        db.save_provider("claude", &provider_b).unwrap();
+
+        db.add_to_failover_queue("claude", "a").unwrap();
+        db.add_to_failover_queue("claude", "b").unwrap();
+        db.set_setting("auto_failover_enabled_claude", "true")
+            .unwrap();
+
+        let router = ProviderRouter::new(db.clone());
+
+        router
+            .record_result("b", "claude", false, false, Some("fail".to_string()))
+            .await
+            .unwrap();
+
+        let providers = router.select_providers("claude").await.unwrap();
+        assert_eq!(providers.len(), 2);
+
+        assert!(router.allow_provider_request("b", "claude").await.allowed);
+    }
+}
@@ -87,7 +87,7 @@ pub trait ProviderAdapter: Send + Sync {
    /// 是否需要格式转换
    ///
    /// 默认返回 `false`（透传模式）。
-    /// 仅当供应商需要格式转换时（如 Claude + OpenRouter）才返回 `true`。
+    /// 仅当供应商需要格式转换时（如 Claude + OpenRouter 旧 OpenAI 兼容接口）才返回 `true`。
    ///
    /// # Arguments
    /// * `provider` - Provider 配置
@@ -5,7 +5,7 @@
 //! ## 认证模式
 //! - **Claude**: Anthropic 官方 API (x-api-key + anthropic-version)
 //! - **ClaudeAuth**: 中转服务 (仅 Bearer 认证，无 x-api-key)
-//! - **OpenRouter**: 需要 Anthropic ↔ OpenAI 格式转换
+//! - **OpenRouter**: 已支持 Claude Code 兼容接口，默认透传（保留旧转换逻辑备用）

 use super::{AuthInfo, AuthStrategy, ProviderAdapter, ProviderType};
 use crate::provider::Provider;
@@ -28,10 +28,8 @@ impl ClaudeAdapter {
    /// - Claude: 默认 Anthropic 官方
    pub fn provider_type(&self, provider: &Provider) -> ProviderType {
        // 检测 OpenRouter
-        if let Ok(base_url) = self.extract_base_url(provider) {
-            if base_url.contains("openrouter.ai") {
-                return ProviderType::OpenRouter;
-            }
+        if self.is_openrouter(provider) {
+            return ProviderType::OpenRouter;
        }

        // 检测 ClaudeAuth (仅 Bearer 认证)
@@ -87,6 +85,14 @@ impl ClaudeAdapter {
                log::debug!("[Claude] 使用 ANTHROPIC_AUTH_TOKEN");
                return Some(key.to_string());
            }
+            if let Some(key) = env
+                .get("ANTHROPIC_API_KEY")
+                .and_then(|v| v.as_str())
+                .filter(|s| !s.is_empty())
+            {
+                log::debug!("[Claude] 使用 ANTHROPIC_API_KEY");
+                return Some(key.to_string());
+            }
            // OpenRouter key
            if let Some(key) = env
                .get("OPENROUTER_API_KEY")
@@ -186,12 +192,17 @@ impl ProviderAdapter for ClaudeAdapter {
    }

    fn build_url(&self, base_url: &str, endpoint: &str) -> String {
-        // OpenRouter 使用 /v1/chat/completions
-        if base_url.contains("openrouter.ai") {
-            return format!("{}/v1/chat/completions", base_url.trim_end_matches('/'));
-        }
+        // NOTE:
+        // 过去 OpenRouter 只有 OpenAI Chat Completions 兼容接口，需要把 Claude 的 `/v1/messages`
+        // 映射到 `/v1/chat/completions`，并做 Anthropic ↔ OpenAI 的格式转换。
+        //
+        // 现在 OpenRouter 已推出 Claude Code 兼容接口，因此默认直接透传 endpoint。
+        // 如需回退旧逻辑，可恢复下面这段分支：
+        //
+        // if base_url.contains("openrouter.ai") {
+        //     return format!("{}/v1/chat/completions", base_url.trim_end_matches('/'));
+        // }

-        // Anthropic 直连
        format!(
            "{}/{}",
            base_url.trim_end_matches('/'),
@@ -207,19 +218,25 @@ impl ProviderAdapter for ClaudeAdapter {
                .header("x-api-key", &auth.api_key)
                .header("anthropic-version", "2023-06-01"),
            // ClaudeAuth 中转服务: 仅 Bearer，无 x-api-key
-            AuthStrategy::ClaudeAuth => {
-                request.header("Authorization", format!("Bearer {}", auth.api_key))
-            }
+            AuthStrategy::ClaudeAuth => request
+                .header("Authorization", format!("Bearer {}", auth.api_key))
+                .header("anthropic-version", "2023-06-01"),
            // OpenRouter: Bearer
-            AuthStrategy::Bearer => {
-                request.header("Authorization", format!("Bearer {}", auth.api_key))
-            }
+            AuthStrategy::Bearer => request
+                .header("Authorization", format!("Bearer {}", auth.api_key))
+                .header("anthropic-version", "2023-06-01"),
            _ => request,
        }
    }

-    fn needs_transform(&self, provider: &Provider) -> bool {
-        self.is_openrouter(provider)
+    fn needs_transform(&self, _provider: &Provider) -> bool {
+        // NOTE:
+        // OpenRouter 已推出 Claude Code 兼容接口（可直接处理 `/v1/messages`），默认不再启用
+        // Anthropic ↔ OpenAI 的格式转换。
+        //
+        // 如果未来需要回退到旧的 OpenAI Chat Completions 方案，可恢复下面这行：
+        // self.is_openrouter(_provider)
+        false
    }

    fn transform_request(
@@ -253,7 +270,7 @@ mod tests {
            meta: None,
            icon: None,
            icon_color: None,
-            is_proxy_target: None,
+            in_failover_queue: false,
        }
    }

@@ -285,6 +302,21 @@ mod tests {
        assert_eq!(auth.strategy, AuthStrategy::Anthropic);
    }

+    #[test]
+    fn test_extract_auth_anthropic_api_key() {
+        let adapter = ClaudeAdapter::new();
+        let provider = create_provider(json!({
+            "env": {
+                "ANTHROPIC_BASE_URL": "https://api.anthropic.com",
+                "ANTHROPIC_API_KEY": "sk-ant-test-key"
+            }
+        }));
+
+        let auth = adapter.extract_auth(&provider).unwrap();
+        assert_eq!(auth.api_key, "sk-ant-test-key");
+        assert_eq!(auth.strategy, AuthStrategy::Anthropic);
+    }
+
    #[test]
    fn test_extract_auth_openrouter() {
        let adapter = ClaudeAdapter::new();
@@ -379,7 +411,7 @@ mod tests {
    fn test_build_url_openrouter() {
        let adapter = ClaudeAdapter::new();
        let url = adapter.build_url("https://openrouter.ai/api", "/v1/messages");
-        assert_eq!(url, "https://openrouter.ai/api/v1/chat/completions");
+        assert_eq!(url, "https://openrouter.ai/api/v1/messages");
    }

    #[test]
@@ -398,6 +430,6 @@ mod tests {
                "ANTHROPIC_BASE_URL": "https://openrouter.ai/api"
            }
        }));
-        assert!(adapter.needs_transform(&openrouter_provider));
+        assert!(!adapter.needs_transform(&openrouter_provider));
    }
 }
@@ -174,7 +174,7 @@ mod tests {
            meta: None,
            icon: None,
            icon_color: None,
-            is_proxy_target: None,
+            in_failover_queue: false,
        }
    }

@@ -120,11 +120,7 @@ impl GeminiAdapter {
    /// 从 Provider 配置中提取原始 API Key
    fn extract_key_raw(&self, provider: &Provider) -> Option<String> {
        if let Some(env) = provider.settings_config.get("env") {
-            // 优先使用 GOOGLE_GEMINI_API_KEY
-            if let Some(key) = env.get("GOOGLE_GEMINI_API_KEY").and_then(|v| v.as_str()) {
-                return Some(key.to_string());
-            }
-            // 备选 GEMINI_API_KEY
+            // 使用 GEMINI_API_KEY
            if let Some(key) = env.get("GEMINI_API_KEY").and_then(|v| v.as_str()) {
                return Some(key.to_string());
            }
@@ -254,7 +250,7 @@ mod tests {
            meta: None,
            icon: None,
            icon_color: None,
-            is_proxy_target: None,
+            in_failover_queue: false,
        }
    }

@@ -276,7 +272,7 @@ mod tests {
        let adapter = GeminiAdapter::new();
        let provider = create_provider(json!({
            "env": {
-                "GOOGLE_GEMINI_API_KEY": "AIza-test-key-12345678"
+                "GEMINI_API_KEY": "AIza-test-key-12345678"
            }
        }));

@@ -291,7 +287,7 @@ mod tests {
        let adapter = GeminiAdapter::new();
        let provider = create_provider(json!({
            "env": {
-                "GOOGLE_GEMINI_API_KEY": "ya29.test-access-token-12345"
+                "GEMINI_API_KEY": "ya29.test-access-token-12345"
            }
        }));

@@ -308,7 +304,7 @@ mod tests {
        let adapter = GeminiAdapter::new();
        let provider = create_provider(json!({
            "env": {
-                "GOOGLE_GEMINI_API_KEY": "{\"access_token\":\"ya29.test-token\",\"refresh_token\":\"1//refresh\"}"
+                "GEMINI_API_KEY": "{\"access_token\":\"ya29.test-token\",\"refresh_token\":\"1//refresh\"}"
            }
        }));

@@ -324,7 +320,7 @@ mod tests {
        // API Key
        let api_key_provider = create_provider(json!({
            "env": {
-                "GOOGLE_GEMINI_API_KEY": "AIza-test-key"
+                "GEMINI_API_KEY": "AIza-test-key"
            }
        }));
        assert_eq!(
@@ -335,7 +331,7 @@ mod tests {
        // OAuth access_token
        let oauth_provider = create_provider(json!({
            "env": {
-                "GOOGLE_GEMINI_API_KEY": "ya29.test-token"
+                "GEMINI_API_KEY": "ya29.test-token"
            }
        }));
        assert_eq!(
@@ -346,7 +342,7 @@ mod tests {
        // OAuth JSON
        let oauth_json_provider = create_provider(json!({
            "env": {
-                "GOOGLE_GEMINI_API_KEY": "{\"access_token\":\"ya29.test\"}"
+                "GEMINI_API_KEY": "{\"access_token\":\"ya29.test\"}"
            }
        }));
        assert_eq!(
@@ -48,17 +48,21 @@ pub enum ProviderType {
    Gemini,
    /// Google Gemini CLI (OAuth Bearer)
    GeminiCli,
-    /// OpenRouter (需要 Anthropic ↔ OpenAI 格式转换)
+    /// OpenRouter（已支持 Claude Code 兼容接口，默认透传；保留旧转换逻辑备用）
    OpenRouter,
 }

 impl ProviderType {
    /// 是否需要格式转换
    ///
-    /// OpenRouter 需要将 Anthropic 格式转换为 OpenAI 格式
+    /// 过去 OpenRouter 需要将 Anthropic 格式转换为 OpenAI 格式；
+    /// 现在默认关闭转换（因为 OpenRouter 已支持 Claude Code 兼容接口）。
    #[allow(dead_code)]
    pub fn needs_transform(&self) -> bool {
-        matches!(self, ProviderType::OpenRouter)
+        match self {
+            ProviderType::OpenRouter => false,
+            _ => false,
+        }
    }

    /// 获取默认端点
@@ -205,7 +209,7 @@ mod tests {
            meta: None,
            icon: None,
            icon_color: None,
-            is_proxy_target: None,
+            in_failover_queue: false,
        }
    }

@@ -216,7 +220,7 @@ mod tests {
        assert!(!ProviderType::Codex.needs_transform());
        assert!(!ProviderType::Gemini.needs_transform());
        assert!(!ProviderType::GeminiCli.needs_transform());
-        assert!(ProviderType::OpenRouter.needs_transform());
+        assert!(!ProviderType::OpenRouter.needs_transform());
    }

    #[test]
@@ -369,7 +373,7 @@ mod tests {
    fn test_from_app_type_gemini_api_key() {
        let provider = create_provider(json!({
            "env": {
-                "GOOGLE_GEMINI_API_KEY": "AIza-test-key"
+                "GEMINI_API_KEY": "AIza-test-key"
            }
        }));

@@ -381,7 +385,7 @@ mod tests {
    fn test_from_app_type_gemini_cli_oauth() {
        let provider = create_provider(json!({
            "env": {
-                "GOOGLE_GEMINI_API_KEY": "ya29.test-access-token"
+                "GEMINI_API_KEY": "ya29.test-access-token"
            }
        }));

@@ -393,7 +397,7 @@ mod tests {
    fn test_from_app_type_gemini_cli_json() {
        let provider = create_provider(json!({
            "env": {
-                "GOOGLE_GEMINI_API_KEY": "{\"access_token\":\"ya29.test\",\"refresh_token\":\"1//test\"}"
+                "GEMINI_API_KEY": "{\"access_token\":\"ya29.test\",\"refresh_token\":\"1//test\"}"
            }
        }));

@@ -394,7 +394,7 @@ mod tests {
            meta: None,
            icon: None,
            icon_color: None,
-            is_proxy_target: None,
+            in_failover_queue: false,
        }
    }

@@ -0,0 +1,411 @@
+//! 响应处理器模块
+//!
+//! 统一处理流式和非流式 API 响应
+
+use super::{
+    handler_config::UsageParserConfig, handler_context::RequestContext, server::ProxyState,
+    usage::parser::TokenUsage, ProxyError,
+};
+use axum::response::Response;
+use bytes::Bytes;
+use futures::stream::{Stream, StreamExt};
+use rust_decimal::Decimal;
+use serde_json::Value;
+use std::{
+    str::FromStr,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+};
+use tokio::sync::Mutex;
+
+// ============================================================================
+// 公共接口
+// ============================================================================
+
+/// 检测响应是否为 SSE 流式响应
+#[inline]
+pub fn is_sse_response(response: &reqwest::Response) -> bool {
+    response
+        .headers()
+        .get("content-type")
+        .and_then(|v| v.to_str().ok())
+        .map(|ct| ct.contains("text/event-stream"))
+        .unwrap_or(false)
+}
+
+/// 处理流式响应
+pub async fn handle_streaming(
+    response: reqwest::Response,
+    ctx: &RequestContext,
+    state: &ProxyState,
+    parser_config: &UsageParserConfig,
+) -> Response {
+    log::info!("[{}] 流式透传响应 (SSE)", ctx.tag);
+
+    let status = response.status();
+    let mut builder = axum::response::Response::builder().status(status);
+
+    // 复制响应头
+    for (key, value) in response.headers() {
+        builder = builder.header(key, value);
+    }
+
+    // 创建字节流
+    let stream = response
+        .bytes_stream()
+        .map(|chunk| chunk.map_err(|e| std::io::Error::other(e.to_string())));
+
+    // 创建使用量收集器
+    let usage_collector = create_usage_collector(ctx, state, status.as_u16(), parser_config);
+
+    // 创建带日志的透传流
+    let logged_stream = create_logged_passthrough_stream(stream, ctx.tag, Some(usage_collector));
+
+    let body = axum::body::Body::from_stream(logged_stream);
+    builder.body(body).unwrap()
+}
+
+/// 处理非流式响应
+pub async fn handle_non_streaming(
+    response: reqwest::Response,
+    ctx: &RequestContext,
+    state: &ProxyState,
+    parser_config: &UsageParserConfig,
+) -> Result<Response, ProxyError> {
+    let response_headers = response.headers().clone();
+    let status = response.status();
+
+    // 读取响应体
+    let body_bytes = response.bytes().await.map_err(|e| {
+        log::error!("[{}] 读取响应失败: {e}", ctx.tag);
+        ProxyError::ForwardFailed(format!("Failed to read response body: {e}"))
+    })?;
+
+    // 解析并记录使用量
+    if let Ok(json_value) = serde_json::from_slice::<Value>(&body_bytes) {
+        log::info!(
+            "[{}] <<< 响应 JSON:\n{}",
+            ctx.tag,
+            serde_json::to_string_pretty(&json_value).unwrap_or_default()
+        );
+
+        // 解析使用量
+        if let Some(usage) = (parser_config.response_parser)(&json_value) {
+            let model = json_value
+                .get("model")
+                .and_then(|m| m.as_str())
+                .unwrap_or(&ctx.request_model);
+
+            spawn_log_usage(state, ctx, usage, model, status.as_u16(), false);
+        } else {
+            log::debug!(
+                "[{}] 未能解析 usage 信息，跳过记录",
+                parser_config.app_type_str
+            );
+        }
+    } else {
+        log::info!(
+            "[{}] <<< 响应 (非 JSON): {} bytes",
+            ctx.tag,
+            body_bytes.len()
+        );
+    }
+
+    log::info!("[{}] ====== 请求结束 ======", ctx.tag);
+
+    // 构建响应
+    let mut builder = axum::response::Response::builder().status(status);
+    for (key, value) in response_headers.iter() {
+        builder = builder.header(key, value);
+    }
+
+    let body = axum::body::Body::from(body_bytes);
+    Ok(builder.body(body).unwrap())
+}
+
+/// 通用响应处理入口
+///
+/// 根据响应类型自动选择流式或非流式处理
+pub async fn process_response(
+    response: reqwest::Response,
+    ctx: &RequestContext,
+    state: &ProxyState,
+    parser_config: &UsageParserConfig,
+) -> Result<Response, ProxyError> {
+    if is_sse_response(&response) {
+        Ok(handle_streaming(response, ctx, state, parser_config).await)
+    } else {
+        handle_non_streaming(response, ctx, state, parser_config).await
+    }
+}
+
+// ============================================================================
+// SSE 使用量收集器
+// ============================================================================
+
+type UsageCallbackWithTiming = Arc<dyn Fn(Vec<Value>, Option<u64>) + Send + Sync + 'static>;
+
+/// SSE 使用量收集器
+#[derive(Clone)]
+pub struct SseUsageCollector {
+    inner: Arc<SseUsageCollectorInner>,
+}
+
+struct SseUsageCollectorInner {
+    events: Mutex<Vec<Value>>,
+    first_event_time: Mutex<Option<std::time::Instant>>,
+    start_time: std::time::Instant,
+    on_complete: UsageCallbackWithTiming,
+    finished: AtomicBool,
+}
+
+impl SseUsageCollector {
+    /// 创建新的使用量收集器
+    pub fn new(
+        start_time: std::time::Instant,
+        callback: impl Fn(Vec<Value>, Option<u64>) + Send + Sync + 'static,
+    ) -> Self {
+        let on_complete: UsageCallbackWithTiming = Arc::new(callback);
+        Self {
+            inner: Arc::new(SseUsageCollectorInner {
+                events: Mutex::new(Vec::new()),
+                first_event_time: Mutex::new(None),
+                start_time,
+                on_complete,
+                finished: AtomicBool::new(false),
+            }),
+        }
+    }
+
+    /// 推送 SSE 事件
+    pub async fn push(&self, event: Value) {
+        // 记录首个事件时间
+        {
+            let mut first_time = self.inner.first_event_time.lock().await;
+            if first_time.is_none() {
+                *first_time = Some(std::time::Instant::now());
+            }
+        }
+        let mut events = self.inner.events.lock().await;
+        events.push(event);
+    }
+
+    /// 完成收集并触发回调
+    pub async fn finish(&self) {
+        if self.inner.finished.swap(true, Ordering::SeqCst) {
+            return;
+        }
+
+        let events = {
+            let mut guard = self.inner.events.lock().await;
+            std::mem::take(&mut *guard)
+        };
+
+        let first_token_ms = {
+            let first_time = self.inner.first_event_time.lock().await;
+            first_time.map(|t| (t - self.inner.start_time).as_millis() as u64)
+        };
+
+        (self.inner.on_complete)(events, first_token_ms);
+    }
+}
+
+// ============================================================================
+// 内部辅助函数
+// ============================================================================
+
+/// 创建使用量收集器
+fn create_usage_collector(
+    ctx: &RequestContext,
+    state: &ProxyState,
+    status_code: u16,
+    parser_config: &UsageParserConfig,
+) -> SseUsageCollector {
+    let state = state.clone();
+    let provider_id = ctx.provider.id.clone();
+    let request_model = ctx.request_model.clone();
+    let app_type_str = parser_config.app_type_str;
+    let tag = ctx.tag;
+    let start_time = ctx.start_time;
+    let stream_parser = parser_config.stream_parser;
+    let model_extractor = parser_config.model_extractor;
+
+    SseUsageCollector::new(start_time, move |events, first_token_ms| {
+        if let Some(usage) = stream_parser(&events) {
+            let model = model_extractor(&events, &request_model);
+            let latency_ms = start_time.elapsed().as_millis() as u64;
+
+            let state = state.clone();
+            let provider_id = provider_id.clone();
+
+            tokio::spawn(async move {
+                log_usage_internal(
+                    &state,
+                    &provider_id,
+                    app_type_str,
+                    &model,
+                    usage,
+                    latency_ms,
+                    first_token_ms,
+                    true, // is_streaming
+                    status_code,
+                )
+                .await;
+            });
+        } else {
+            log::debug!("[{tag}] 流式响应缺少 usage 统计，跳过消费记录");
+        }
+    })
+}
+
+/// 异步记录使用量
+fn spawn_log_usage(
+    state: &ProxyState,
+    ctx: &RequestContext,
+    usage: TokenUsage,
+    model: &str,
+    status_code: u16,
+    is_streaming: bool,
+) {
+    let state = state.clone();
+    let provider_id = ctx.provider.id.clone();
+    let app_type_str = ctx.app_type_str.to_string();
+    let model = model.to_string();
+    let latency_ms = ctx.latency_ms();
+
+    tokio::spawn(async move {
+        log_usage_internal(
+            &state,
+            &provider_id,
+            &app_type_str,
+            &model,
+            usage,
+            latency_ms,
+            None,
+            is_streaming,
+            status_code,
+        )
+        .await;
+    });
+}
+
+/// 内部使用量记录函数
+#[allow(clippy::too_many_arguments)]
+async fn log_usage_internal(
+    state: &ProxyState,
+    provider_id: &str,
+    app_type: &str,
+    model: &str,
+    usage: TokenUsage,
+    latency_ms: u64,
+    first_token_ms: Option<u64>,
+    is_streaming: bool,
+    status_code: u16,
+) {
+    use super::usage::logger::UsageLogger;
+
+    let logger = UsageLogger::new(&state.db);
+
+    // 获取 provider 的 cost_multiplier
+    let multiplier = match state.db.get_provider_by_id(provider_id, app_type) {
+        Ok(Some(p)) => {
+            if let Some(meta) = p.meta {
+                if let Some(cm) = meta.cost_multiplier {
+                    Decimal::from_str(&cm).unwrap_or(Decimal::from(1))
+                } else {
+                    Decimal::from(1)
+                }
+            } else {
+                Decimal::from(1)
+            }
+        }
+        _ => Decimal::from(1),
+    };
+
+    let request_id = uuid::Uuid::new_v4().to_string();
+
+    if let Err(e) = logger.log_with_calculation(
+        request_id,
+        provider_id.to_string(),
+        app_type.to_string(),
+        model.to_string(),
+        usage,
+        multiplier,
+        latency_ms,
+        first_token_ms,
+        status_code,
+        None,
+        None, // provider_type
+        is_streaming,
+    ) {
+        log::warn!("记录使用量失败: {e}");
+    }
+}
+
+/// 创建带日志记录的透传流
+pub fn create_logged_passthrough_stream(
+    stream: impl Stream<Item = Result<Bytes, std::io::Error>> + Send + 'static,
+    tag: &'static str,
+    usage_collector: Option<SseUsageCollector>,
+) -> impl Stream<Item = Result<Bytes, std::io::Error>> + Send {
+    async_stream::stream! {
+        let mut buffer = String::new();
+        let mut collector = usage_collector;
+
+        tokio::pin!(stream);
+
+        while let Some(chunk) = stream.next().await {
+            match chunk {
+                Ok(bytes) => {
+                    let text = String::from_utf8_lossy(&bytes);
+                    buffer.push_str(&text);
+
+                    // 尝试解析并记录完整的 SSE 事件
+                    while let Some(pos) = buffer.find("\n\n") {
+                        let event_text = buffer[..pos].to_string();
+                        buffer = buffer[pos + 2..].to_string();
+
+                        if !event_text.trim().is_empty() {
+                            // 提取 data 部分并尝试解析为 JSON
+                            for line in event_text.lines() {
+                                if let Some(data) = line.strip_prefix("data: ") {
+                                    if data.trim() != "[DONE]" {
+                                        if let Ok(json_value) = serde_json::from_str::<Value>(data) {
+                                            if let Some(c) = &collector {
+                                                c.push(json_value.clone()).await;
+                                            }
+                                            log::info!(
+                                                "[{}] <<< SSE 事件:\n{}",
+                                                tag,
+                                                serde_json::to_string_pretty(&json_value).unwrap_or_else(|_| data.to_string())
+                                            );
+                                        } else {
+                                            log::info!("[{tag}] <<< SSE 数据: {data}");
+                                        }
+                                    } else {
+                                        log::info!("[{tag}] <<< SSE: [DONE]");
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    yield Ok(bytes);
+                }
+                Err(e) => {
+                    log::error!("[{tag}] 流错误: {e}");
+                    yield Err(std::io::Error::other(e.to_string()));
+                    break;
+                }
+            }
+        }
+
+        log::info!("[{}] ====== 流结束 ======", tag);
+
+        if let Some(c) = collector.take() {
+            c.finish().await;
+        }
+    }
+}
@@ -1,69 +0,0 @@
-//! Provider路由器
-//!
-//! 负责选择合适的Provider进行请求转发
-
-use super::ProxyError;
-use crate::{app_config::AppType, database::Database, provider::Provider};
-use std::sync::Arc;
-
-pub struct ProviderRouter {
-    db: Arc<Database>,
-}
-
-impl ProviderRouter {
-    pub fn new(db: Arc<Database>) -> Self {
-        Self { db }
-    }
-
-    /// 选择Provider（只使用标记为代理目标的 Provider）
-    pub async fn select_provider(
-        &self,
-        app_type: &AppType,
-        _failed_ids: &[String],
-    ) -> Result<Provider, ProxyError> {
-        // 1. 获取 Proxy Target Provider ID
-        let proxy_target_id = self
-            .db
-            .get_proxy_target_provider(app_type.as_str())
-            .map_err(|e| ProxyError::DatabaseError(e.to_string()))?;
-
-        let target_id = proxy_target_id.ok_or_else(|| {
-            log::warn!("[{}] 未设置代理目标 Provider", app_type.as_str());
-            ProxyError::NoAvailableProvider
-        })?;
-
-        // 2. 获取所有 Provider
-        let providers = self
-            .db
-            .get_all_providers(app_type.as_str())
-            .map_err(|e| ProxyError::DatabaseError(e.to_string()))?;
-
-        // 3. 找到目标 Provider
-        let target = providers.get(&target_id).ok_or_else(|| {
-            log::warn!(
-                "[{}] 代理目标 Provider 不存在: {}",
-                app_type.as_str(),
-                target_id
-            );
-            ProxyError::NoAvailableProvider
-        })?;
-
-        log::info!(
-            "[{}] 使用代理目标 Provider: {}",
-            app_type.as_str(),
-            target.name
-        );
-        Ok(target.clone())
-    }
-
-    /// 更新Provider健康状态（保留接口但不影响选择）
-    pub async fn update_health(
-        &self,
-        _provider: &Provider,
-        _app_type: &AppType,
-        _success: bool,
-        _error_msg: Option<String>,
-    ) {
-        // 不再记录健康状态
-    }
-}
@@ -2,7 +2,10 @@
 //!
 //! 基于Axum的HTTP服务器，处理代理请求

-use super::{handlers, types::*, ProxyError};
+use super::{
+    failover_switch::FailoverSwitchManager, handlers, provider_router::ProviderRouter, types::*,
+    ProxyError,
+};
 use crate::database::Database;
 use axum::{
    routing::{get, post},
@@ -11,6 +14,7 @@ use axum::{
 use std::net::SocketAddr;
 use std::sync::Arc;
 use tokio::sync::{oneshot, RwLock};
+use tokio::task::JoinHandle;
 use tower_http::cors::{Any, CorsLayer};

 /// 代理服务器状态（共享）
@@ -20,6 +24,14 @@ pub struct ProxyState {
    pub config: Arc<RwLock<ProxyConfig>>,
    pub status: Arc<RwLock<ProxyStatus>>,
    pub start_time: Arc<RwLock<Option<std::time::Instant>>>,
+    /// 每个应用类型当前使用的 provider (app_type -> (provider_id, provider_name))
+    pub current_providers: Arc<RwLock<std::collections::HashMap<String, (String, String)>>>,
+    /// 共享的 ProviderRouter（持有熔断器状态，跨请求保持）
+    pub provider_router: Arc<ProviderRouter>,
+    /// AppHandle，用于发射事件和更新托盘菜单
+    pub app_handle: Option<tauri::AppHandle>,
+    /// 故障转移切换管理器
+    pub failover_manager: Arc<FailoverSwitchManager>,
 }

 /// 代理HTTP服务器
@@ -27,21 +39,37 @@ pub struct ProxyServer {
    config: ProxyConfig,
    state: ProxyState,
    shutdown_tx: Arc<RwLock<Option<oneshot::Sender<()>>>>,
+    /// 服务器任务句柄，用于等待服务器实际关闭
+    server_handle: Arc<RwLock<Option<JoinHandle<()>>>>,
 }

 impl ProxyServer {
-    pub fn new(config: ProxyConfig, db: Arc<Database>) -> Self {
+    pub fn new(
+        config: ProxyConfig,
+        db: Arc<Database>,
+        app_handle: Option<tauri::AppHandle>,
+    ) -> Self {
+        // 创建共享的 ProviderRouter（熔断器状态将跨所有请求保持）
+        let provider_router = Arc::new(ProviderRouter::new(db.clone()));
+        // 创建故障转移切换管理器
+        let failover_manager = Arc::new(FailoverSwitchManager::new(db.clone()));
+
        let state = ProxyState {
            db,
            config: Arc::new(RwLock::new(config.clone())),
            status: Arc::new(RwLock::new(ProxyStatus::default())),
            start_time: Arc::new(RwLock::new(None)),
+            current_providers: Arc::new(RwLock::new(std::collections::HashMap::new())),
+            provider_router,
+            app_handle,
+            failover_manager,
        };

        Self {
            config,
            state,
            shutdown_tx: Arc::new(RwLock::new(None)),
+            server_handle: Arc::new(RwLock::new(None)),
        }
    }

@@ -84,7 +112,7 @@ impl ProxyServer {

        // 启动服务器
        let state = self.state.clone();
-        tokio::spawn(async move {
+        let handle = tokio::spawn(async move {
            axum::serve(listener, app)
                .with_graceful_shutdown(async {
                    shutdown_rx.await.ok();
@@ -97,6 +125,9 @@ impl ProxyServer {
            *state.start_time.write().await = None;
        });

+        // 保存服务器任务句柄
+        *self.server_handle.write().await = Some(handle);
+
        Ok(ProxyServerInfo {
            address: self.config.listen_address.clone(),
            port: self.config.listen_port,
@@ -105,12 +136,23 @@ impl ProxyServer {
    }

    pub async fn stop(&self) -> Result<(), ProxyError> {
+        // 1. 发送关闭信号
        if let Some(tx) = self.shutdown_tx.write().await.take() {
            let _ = tx.send(());
-            Ok(())
        } else {
-            Err(ProxyError::NotRunning)
+            return Err(ProxyError::NotRunning);
        }
+
+        // 2. 等待服务器任务结束（带 5 秒超时保护）
+        if let Some(handle) = self.server_handle.write().await.take() {
+            match tokio::time::timeout(std::time::Duration::from_secs(5), handle).await {
+                Ok(Ok(())) => log::info!("代理服务器已完全停止"),
+                Ok(Err(e)) => log::warn!("代理服务器任务异常终止: {e}"),
+                Err(_) => log::warn!("代理服务器停止超时（5秒），强制继续"),
+            }
+        }
+
+        Ok(())
    }

    pub async fn get_status(&self) -> ProxyStatus {
@@ -121,17 +163,16 @@ impl ProxyServer {
            status.uptime_seconds = start.elapsed().as_secs();
        }

-        // 获取所有活跃的代理目标
-        if let Ok(targets) = self.state.db.get_all_proxy_targets() {
-            status.active_targets = targets
-                .into_iter()
-                .map(|(app_type, name, id)| ActiveTarget {
-                    app_type,
-                    provider_name: name,
-                    provider_id: id,
-                })
-                .collect();
-        }
+        // 从 current_providers HashMap 获取每个应用类型当前正在使用的 provider
+        let current_providers = self.state.current_providers.read().await;
+        status.active_targets = current_providers
+            .iter()
+            .map(|(app_type, (provider_id, provider_name))| ActiveTarget {
+                app_type: app_type.clone(),
+                provider_id: provider_id.clone(),
+                provider_name: provider_name.clone(),
+            })
+            .collect();

        status
    }
@@ -146,17 +187,31 @@ impl ProxyServer {
            // 健康检查
            .route("/health", get(handlers::health_check))
            .route("/status", get(handlers::get_status))
-            // Claude API
+            // Claude API (支持带前缀和不带前缀两种格式)
            .route("/v1/messages", post(handlers::handle_messages))
-            // OpenAI Chat Completions API (Codex CLI)
+            .route("/claude/v1/messages", post(handlers::handle_messages))
+            // OpenAI Chat Completions API (Codex CLI，支持带前缀和不带前缀)
+            .route("/chat/completions", post(handlers::handle_chat_completions))
            .route(
                "/v1/chat/completions",
                post(handlers::handle_chat_completions),
            )
-            // OpenAI Responses API (Codex CLI)
+            .route(
+                "/v1/v1/chat/completions",
+                post(handlers::handle_chat_completions),
+            )
+            .route(
+                "/codex/v1/chat/completions",
+                post(handlers::handle_chat_completions),
+            )
+            // OpenAI Responses API (Codex CLI，支持带前缀和不带前缀)
+            .route("/responses", post(handlers::handle_responses))
            .route("/v1/responses", post(handlers::handle_responses))
-            // Gemini API
+            .route("/v1/v1/responses", post(handlers::handle_responses))
+            .route("/codex/v1/responses", post(handlers::handle_responses))
+            // Gemini API (支持带前缀和不带前缀)
            .route("/v1beta/*path", post(handlers::handle_gemini))
+            .route("/gemini/v1beta/*path", post(handlers::handle_gemini))
            .layer(cors)
            .with_state(self.state.clone())
    }
@@ -165,4 +220,22 @@ impl ProxyServer {
    pub async fn apply_runtime_config(&self, config: &ProxyConfig) {
        *self.state.config.write().await = config.clone();
    }
+
+    /// 热更新熔断器配置
+    ///
+    /// 将新配置应用到所有已创建的熔断器实例
+    pub async fn update_circuit_breaker_configs(
+        &self,
+        config: super::circuit_breaker::CircuitBreakerConfig,
+    ) {
+        self.state.provider_router.update_all_configs(config).await;
+    }
+
+    /// 重置指定 Provider 的熔断器
+    pub async fn reset_provider_circuit_breaker(&self, provider_id: &str, app_type: &str) {
+        self.state
+            .provider_router
+            .reset_provider_breaker(provider_id, app_type)
+            .await;
+    }
 }
@@ -3,8 +3,6 @@ use serde::{Deserialize, Serialize};
 /// 代理服务器配置
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ProxyConfig {
-    /// 是否启用代理服务
-    pub enabled: bool,
    /// 监听地址
    pub listen_address: String,
    /// 监听端口
@@ -15,17 +13,20 @@ pub struct ProxyConfig {
    pub request_timeout: u64,
    /// 是否启用日志
    pub enable_logging: bool,
+    /// 是否正在接管 Live 配置
+    #[serde(default)]
+    pub live_takeover_active: bool,
 }

 impl Default for ProxyConfig {
    fn default() -> Self {
        Self {
-            enabled: false,
            listen_address: "127.0.0.1".to_string(),
            listen_port: 15721, // 使用较少占用的高位端口
            max_retries: 3,
            request_timeout: 300,
            enable_logging: true,
+            live_takeover_active: false,
        }
    }
 }
@@ -82,6 +83,14 @@ pub struct ProxyServerInfo {
    pub started_at: String,
 }

+/// 各应用的接管状态（是否改写该应用的 Live 配置指向本地代理）
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ProxyTakeoverStatus {
+    pub claude: bool,
+    pub codex: bool,
+    pub gemini: bool,
+}
+
 /// API 格式类型（预留，当前不需要格式转换）
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[allow(dead_code)]
@@ -104,16 +113,13 @@ pub struct ProviderHealth {
    pub updated_at: String,
 }

-/// 使用统计记录
+/// Live 配置备份记录
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ProxyUsageRecord {
-    pub provider_id: String,
+pub struct LiveBackup {
+    /// 应用类型 (claude/codex/gemini)
    pub app_type: String,
-    pub endpoint: String,
-    pub request_tokens: Option<i32>,
-    pub response_tokens: Option<i32>,
-    pub status_code: u16,
-    pub latency_ms: u64,
-    pub error: Option<String>,
-    pub timestamp: String,
+    /// 原始配置 JSON
+    pub original_config: String,
+    /// 备份时间
+    pub backed_up_at: String,
 }
@@ -107,6 +107,8 @@ impl<'a> UsageLogger<'a> {
    }

    /// 记录失败的请求
+    ///
+    /// 用于记录无法从上游获取 usage 信息的失败请求
    #[allow(dead_code, clippy::too_many_arguments)]
    pub fn log_error(
        &self,
@@ -138,6 +140,43 @@ impl<'a> UsageLogger<'a> {
        self.log_request(&log)
    }

+    /// 记录失败的请求（带更多上下文信息）
+    ///
+    /// 相比 log_error，这个方法接受更多参数以提供完整的请求上下文
+    #[allow(clippy::too_many_arguments)]
+    pub fn log_error_with_context(
+        &self,
+        request_id: String,
+        provider_id: String,
+        app_type: String,
+        model: String,
+        status_code: u16,
+        error_message: String,
+        latency_ms: u64,
+        is_streaming: bool,
+        session_id: Option<String>,
+        provider_type: Option<String>,
+    ) -> Result<(), AppError> {
+        let log = RequestLog {
+            request_id,
+            provider_id,
+            app_type,
+            model,
+            usage: TokenUsage::default(),
+            cost: None,
+            latency_ms,
+            first_token_ms: None,
+            status_code,
+            error_message: Some(error_message),
+            session_id,
+            provider_type,
+            is_streaming,
+            cost_multiplier: "1.0".to_string(),
+        };
+
+        self.log_request(&log)
+    }
+
    /// 获取模型定价
    pub fn get_model_pricing(&self, model_id: &str) -> Result<Option<ModelPricing>, AppError> {
        let conn = crate::database::lock_conn!(self.db.conn);
@@ -17,8 +17,27 @@ impl McpService {

    /// 添加或更新 MCP 服务器
    pub fn upsert_server(state: &AppState, server: McpServer) -> Result<(), AppError> {
+        // 读取旧状态：用于处理“编辑时取消勾选某个应用”的场景（需要从对应 live 配置中移除）
+        let prev_apps = state
+            .db
+            .get_all_mcp_servers()?
+            .get(&server.id)
+            .map(|s| s.apps.clone())
+            .unwrap_or_default();
+
        state.db.save_mcp_server(&server)?;

+        // 处理禁用：若旧版本启用但新版本取消，则需要从该应用的 live 配置移除
+        if prev_apps.claude && !server.apps.claude {
+            Self::remove_server_from_app(state, &server.id, &AppType::Claude)?;
+        }
+        if prev_apps.codex && !server.apps.codex {
+            Self::remove_server_from_app(state, &server.id, &AppType::Codex)?;
+        }
+        if prev_apps.gemini && !server.apps.gemini {
+            Self::remove_server_from_app(state, &server.id, &AppType::Gemini)?;
+        }
+
        // 同步到各个启用的应用
        Self::sync_server_to_apps(state, &server)?;

@@ -190,10 +209,22 @@ impl McpService {
        // 如果有导入的服务器，保存到数据库
        if count > 0 {
            if let Some(servers) = &temp_config.mcp.servers {
+                let mut existing = state.db.get_all_mcp_servers()?;
                for server in servers.values() {
-                    state.db.save_mcp_server(server)?;
-                    // 同步到 Claude live 配置
-                    Self::sync_server_to_apps(state, server)?;
+                    // 已存在：仅启用 Claude，不覆盖其他字段（与导入模块语义保持一致）
+                    let to_save = if let Some(existing_server) = existing.get(&server.id) {
+                        let mut merged = existing_server.clone();
+                        merged.apps.claude = true;
+                        merged
+                    } else {
+                        server.clone()
+                    };
+
+                    state.db.save_mcp_server(&to_save)?;
+                    existing.insert(to_save.id.clone(), to_save.clone());
+
+                    // 同步到对应应用 live 配置
+                    Self::sync_server_to_apps(state, &to_save)?;
                }
            }
        }
@@ -212,10 +243,22 @@ impl McpService {
        // 如果有导入的服务器，保存到数据库
        if count > 0 {
            if let Some(servers) = &temp_config.mcp.servers {
+                let mut existing = state.db.get_all_mcp_servers()?;
                for server in servers.values() {
-                    state.db.save_mcp_server(server)?;
-                    // 同步到 Codex live 配置
-                    Self::sync_server_to_apps(state, server)?;
+                    // 已存在：仅启用 Codex，不覆盖其他字段（与导入模块语义保持一致）
+                    let to_save = if let Some(existing_server) = existing.get(&server.id) {
+                        let mut merged = existing_server.clone();
+                        merged.apps.codex = true;
+                        merged
+                    } else {
+                        server.clone()
+                    };
+
+                    state.db.save_mcp_server(&to_save)?;
+                    existing.insert(to_save.id.clone(), to_save.clone());
+
+                    // 同步到对应应用 live 配置
+                    Self::sync_server_to_apps(state, &to_save)?;
                }
            }
        }
@@ -234,10 +277,22 @@ impl McpService {
        // 如果有导入的服务器，保存到数据库
        if count > 0 {
            if let Some(servers) = &temp_config.mcp.servers {
+                let mut existing = state.db.get_all_mcp_servers()?;
                for server in servers.values() {
-                    state.db.save_mcp_server(server)?;
-                    // 同步到 Gemini live 配置
-                    Self::sync_server_to_apps(state, server)?;
+                    // 已存在：仅启用 Gemini，不覆盖其他字段（与导入模块语义保持一致）
+                    let to_save = if let Some(existing_server) = existing.get(&server.id) {
+                        let mut merged = existing_server.clone();
+                        merged.apps.gemini = true;
+                        merged
+                    } else {
+                        server.clone()
+                    };
+
+                    state.db.save_mcp_server(&to_save)?;
+                    existing.insert(to_save.id.clone(), to_save.clone());
+
+                    // 同步到对应应用 live 配置
+                    Self::sync_server_to_apps(state, &to_save)?;
                }
            }
        }
@@ -2,18 +2,16 @@ pub mod config;
 pub mod env_checker;
 pub mod env_manager;
 pub mod mcp;
-pub mod model_test;
 pub mod prompt;
 pub mod provider;
 pub mod proxy;
 pub mod skill;
 pub mod speedtest;
+pub mod stream_check;
 pub mod usage_stats;

 pub use config::ConfigService;
 pub use mcp::McpService;
-#[allow(unused_imports)]
-pub use model_test::{ModelTestConfig, ModelTestLog, ModelTestResult, ModelTestService};
 pub use prompt::PromptService;
 pub use provider::{ProviderService, ProviderSortUpdate};
 pub use proxy::ProxyService;
@@ -1,510 +0,0 @@
-//! 模型测试服务
-//!
-//! 提供独立的模型可用性测试功能，复用现有 Provider 适配器逻辑，
-//! 但不影响正常代理数据流程。测试结果记录到独立的日志表。
-
-use crate::app_config::AppType;
-use crate::database::Database;
-use crate::error::AppError;
-use crate::provider::Provider;
-use crate::proxy::providers::{get_adapter, AuthInfo, ProviderAdapter};
-use reqwest::Client;
-use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
-use std::time::{Duration, Instant};
-
-/// 模型测试配置
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ModelTestConfig {
-    /// 默认测试模型（Claude）
-    pub claude_model: String,
-    /// 默认测试模型（Codex/OpenAI）
-    pub codex_model: String,
-    /// 默认测试模型（Gemini）
-    pub gemini_model: String,
-    /// 测试提示词
-    pub test_prompt: String,
-    /// 超时时间（秒）
-    pub timeout_secs: u64,
-}
-
-impl Default for ModelTestConfig {
-    fn default() -> Self {
-        Self {
-            claude_model: "claude-haiku-4-5-20251001".to_string(),
-            codex_model: "gpt-5.1-low".to_string(),
-            gemini_model: "gemini-3-pro-low".to_string(),
-            test_prompt: "ping".to_string(),
-            timeout_secs: 15,
-        }
-    }
-}
-
-/// 模型测试结果
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ModelTestResult {
-    pub success: bool,
-    pub message: String,
-    pub response_time_ms: Option<u64>,
-    pub http_status: Option<u16>,
-    pub model_used: String,
-    pub tested_at: i64,
-}
-
-/// 模型测试日志记录
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ModelTestLog {
-    pub id: i64,
-    pub provider_id: String,
-    pub provider_name: String,
-    pub app_type: String,
-    pub model: String,
-    pub prompt: String,
-    pub success: bool,
-    pub message: String,
-    pub response_time_ms: Option<i64>,
-    pub http_status: Option<i64>,
-    pub tested_at: i64,
-}
-
-/// 模型测试服务
-pub struct ModelTestService;
-
-impl ModelTestService {
-    /// 测试单个供应商的模型可用性
-    pub async fn test_provider(
-        app_type: &AppType,
-        provider: &Provider,
-        config: &ModelTestConfig,
-    ) -> Result<ModelTestResult, AppError> {
-        let start = Instant::now();
-        let adapter = get_adapter(app_type);
-
-        // 构建 HTTP 客户端（独立于代理服务）
-        let client = Client::builder()
-            .timeout(Duration::from_secs(config.timeout_secs))
-            .build()
-            .map_err(|e| AppError::Message(format!("创建 HTTP 客户端失败: {e}")))?;
-
-        // 根据 AppType 选择测试模型
-        let model = match app_type {
-            AppType::Claude => &config.claude_model,
-            AppType::Codex => &config.codex_model,
-            AppType::Gemini => &config.gemini_model,
-        };
-
-        let result = match app_type {
-            AppType::Claude => {
-                Self::test_claude(
-                    &client,
-                    provider,
-                    adapter.as_ref(),
-                    model,
-                    &config.test_prompt,
-                )
-                .await
-            }
-            AppType::Codex => {
-                Self::test_codex(
-                    &client,
-                    provider,
-                    adapter.as_ref(),
-                    model,
-                    &config.test_prompt,
-                )
-                .await
-            }
-            AppType::Gemini => {
-                Self::test_gemini(
-                    &client,
-                    provider,
-                    adapter.as_ref(),
-                    model,
-                    &config.test_prompt,
-                )
-                .await
-            }
-        };
-
-        let response_time = start.elapsed().as_millis() as u64;
-        let tested_at = chrono::Utc::now().timestamp();
-
-        match result {
-            Ok((status, msg)) => Ok(ModelTestResult {
-                success: true,
-                message: msg,
-                response_time_ms: Some(response_time),
-                http_status: Some(status),
-                model_used: model.clone(),
-                tested_at,
-            }),
-            Err(e) => Ok(ModelTestResult {
-                success: false,
-                message: e.to_string(),
-                response_time_ms: Some(response_time),
-                http_status: None,
-                model_used: model.clone(),
-                tested_at,
-            }),
-        }
-    }
-
-    /// 测试 Claude (Anthropic Messages API)
-    async fn test_claude(
-        client: &Client,
-        provider: &Provider,
-        adapter: &dyn ProviderAdapter,
-        model: &str,
-        prompt: &str,
-    ) -> Result<(u16, String), AppError> {
-        let base_url = adapter
-            .extract_base_url(provider)
-            .map_err(|e| AppError::Message(format!("提取 base_url 失败: {e}")))?;
-
-        let auth = adapter
-            .extract_auth(provider)
-            .ok_or_else(|| AppError::Message("未找到 API Key".to_string()))?;
-
-        // 智能拼接 URL，避免重复 /v1
-        let base = base_url.trim_end_matches('/');
-        let url = if base.ends_with("/v1") {
-            format!("{base}/messages")
-        } else {
-            format!("{base}/v1/messages")
-        };
-
-        let body = json!({
-            "model": model,
-            "max_tokens": 1,
-            "messages": [{
-                "role": "user",
-                "content": prompt
-            }]
-        });
-
-        let mut request = client.post(&url).json(&body);
-        request = Self::add_claude_auth(request, &auth);
-
-        let response = request.send().await.map_err(|e| {
-            if e.is_timeout() {
-                AppError::Message("请求超时".to_string())
-            } else if e.is_connect() {
-                AppError::Message(format!("连接失败: {e}"))
-            } else {
-                AppError::Message(e.to_string())
-            }
-        })?;
-
-        let status = response.status().as_u16();
-
-        if response.status().is_success() {
-            // 先获取文本，再尝试解析 JSON（兼容流式响应）
-            let text = response.text().await.unwrap_or_default();
-
-            // 尝试解析 JSON
-            if let Ok(data) = serde_json::from_str::<Value>(&text) {
-                if data.get("type").is_some()
-                    || data.get("content").is_some()
-                    || data.get("id").is_some()
-                {
-                    return Ok((status, "模型测试成功".to_string()));
-                }
-            }
-
-            // 即使无法解析 JSON，只要状态码是 200 就认为成功
-            Ok((status, "模型测试成功".to_string()))
-        } else {
-            let error_text = response.text().await.unwrap_or_default();
-            Err(AppError::Message(format!("HTTP {status}: {error_text}")))
-        }
-    }
-
-    /// 测试 Codex (OpenAI Chat Completions API)
-    async fn test_codex(
-        client: &Client,
-        provider: &Provider,
-        adapter: &dyn ProviderAdapter,
-        model: &str,
-        prompt: &str,
-    ) -> Result<(u16, String), AppError> {
-        let base_url = adapter
-            .extract_base_url(provider)
-            .map_err(|e| AppError::Message(format!("提取 base_url 失败: {e}")))?;
-
-        let auth = adapter
-            .extract_auth(provider)
-            .ok_or_else(|| AppError::Message("未找到 API Key".to_string()))?;
-
-        // 智能拼接 URL，避免重复 /v1
-        let base = base_url.trim_end_matches('/');
-        let url = if base.ends_with("/v1") {
-            format!("{base}/chat/completions")
-        } else {
-            format!("{base}/v1/chat/completions")
-        };
-
-        let body = json!({
-            "model": model,
-            "messages": [{
-                "role": "user",
-                "content": prompt
-            }],
-            "max_tokens": 1,
-            "stream": false
-        });
-
-        let request = client
-            .post(&url)
-            .header("Authorization", format!("Bearer {}", auth.api_key))
-            .header("Content-Type", "application/json")
-            .json(&body);
-
-        let response = request.send().await.map_err(|e| {
-            if e.is_timeout() {
-                AppError::Message("请求超时".to_string())
-            } else if e.is_connect() {
-                AppError::Message(format!("连接失败: {e}"))
-            } else {
-                AppError::Message(e.to_string())
-            }
-        })?;
-
-        let status = response.status().as_u16();
-
-        if response.status().is_success() {
-            // 先获取文本，再尝试解析 JSON
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(data) = serde_json::from_str::<Value>(&text) {
-                if data.get("choices").is_some() || data.get("id").is_some() {
-                    return Ok((status, "模型测试成功".to_string()));
-                }
-            }
-
-            // 即使无法解析 JSON，只要状态码是 200 就认为成功
-            Ok((status, "模型测试成功".to_string()))
-        } else {
-            let error_text = response.text().await.unwrap_or_default();
-            Err(AppError::Message(format!("HTTP {status}: {error_text}")))
-        }
-    }
-
-    /// 测试 Gemini (Google Generative AI API)
-    async fn test_gemini(
-        client: &Client,
-        provider: &Provider,
-        adapter: &dyn ProviderAdapter,
-        model: &str,
-        prompt: &str,
-    ) -> Result<(u16, String), AppError> {
-        let base_url = adapter
-            .extract_base_url(provider)
-            .map_err(|e| AppError::Message(format!("提取 base_url 失败: {e}")))?;
-
-        let auth = adapter
-            .extract_auth(provider)
-            .ok_or_else(|| AppError::Message("未找到 API Key".to_string()))?;
-
-        let url = format!(
-            "{}/v1beta/models/{}:generateContent?key={}",
-            base_url.trim_end_matches('/'),
-            model,
-            auth.api_key
-        );
-
-        let body = json!({
-            "contents": [{
-                "parts": [{
-                    "text": prompt
-                }]
-            }],
-            "generationConfig": {
-                "maxOutputTokens": 1
-            }
-        });
-
-        let request = client
-            .post(&url)
-            .header("Content-Type", "application/json")
-            .json(&body);
-
-        let response = request.send().await.map_err(|e| {
-            if e.is_timeout() {
-                AppError::Message("请求超时".to_string())
-            } else if e.is_connect() {
-                AppError::Message(format!("连接失败: {e}"))
-            } else {
-                AppError::Message(e.to_string())
-            }
-        })?;
-
-        let status = response.status().as_u16();
-
-        if response.status().is_success() {
-            let data: Value = response
-                .json()
-                .await
-                .map_err(|e| AppError::Message(format!("解析响应失败: {e}")))?;
-
-            if data.get("candidates").is_some() {
-                Ok((status, "模型测试成功".to_string()))
-            } else {
-                Err(AppError::Message("响应格式异常".to_string()))
-            }
-        } else {
-            let error_text = response.text().await.unwrap_or_default();
-            Err(AppError::Message(format!("HTTP {status}: {error_text}")))
-        }
-    }
-
-    /// 添加 Claude 认证头
-    fn add_claude_auth(
-        request: reqwest::RequestBuilder,
-        auth: &AuthInfo,
-    ) -> reqwest::RequestBuilder {
-        request
-            .header("x-api-key", &auth.api_key)
-            .header("anthropic-version", "2023-06-01")
-            .header("Content-Type", "application/json")
-    }
-}
-
-// ===== 数据库操作 =====
-
-impl Database {
-    /// 保存模型测试日志
-    pub fn save_model_test_log(
-        &self,
-        provider_id: &str,
-        provider_name: &str,
-        app_type: &str,
-        model: &str,
-        prompt: &str,
-        result: &ModelTestResult,
-    ) -> Result<i64, AppError> {
-        let conn = self
-            .conn
-            .lock()
-            .map_err(|e| AppError::Database(format!("获取数据库连接失败: {e}")))?;
-
-        conn.execute(
-            "INSERT INTO model_test_logs 
-             (provider_id, provider_name, app_type, model, prompt, success, message, response_time_ms, http_status, tested_at)
-             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
-            rusqlite::params![
-                provider_id,
-                provider_name,
-                app_type,
-                model,
-                prompt,
-                result.success,
-                result.message,
-                result.response_time_ms.map(|t| t as i64),
-                result.http_status.map(|s| s as i64),
-                result.tested_at,
-            ],
-        )
-        .map_err(|e| AppError::Database(e.to_string()))?;
-
-        Ok(conn.last_insert_rowid())
-    }
-
-    /// 获取模型测试日志
-    pub fn get_model_test_logs(
-        &self,
-        app_type: Option<&str>,
-        provider_id: Option<&str>,
-        limit: u32,
-    ) -> Result<Vec<ModelTestLog>, AppError> {
-        let conn = self
-            .conn
-            .lock()
-            .map_err(|e| AppError::Database(format!("获取数据库连接失败: {e}")))?;
-
-        let mut sql = String::from(
-            "SELECT id, provider_id, provider_name, app_type, model, prompt, success, message, response_time_ms, http_status, tested_at
-             FROM model_test_logs WHERE 1=1"
-        );
-
-        let mut params: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
-
-        if let Some(at) = app_type {
-            sql.push_str(" AND app_type = ?");
-            params.push(Box::new(at.to_string()));
-        }
-
-        if let Some(pid) = provider_id {
-            sql.push_str(" AND provider_id = ?");
-            params.push(Box::new(pid.to_string()));
-        }
-
-        sql.push_str(" ORDER BY tested_at DESC LIMIT ?");
-        params.push(Box::new(limit as i64));
-
-        let params_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect();
-
-        let mut stmt = conn
-            .prepare(&sql)
-            .map_err(|e| AppError::Database(e.to_string()))?;
-
-        let logs = stmt
-            .query_map(params_refs.as_slice(), |row| {
-                Ok(ModelTestLog {
-                    id: row.get(0)?,
-                    provider_id: row.get(1)?,
-                    provider_name: row.get(2)?,
-                    app_type: row.get(3)?,
-                    model: row.get(4)?,
-                    prompt: row.get(5)?,
-                    success: row.get(6)?,
-                    message: row.get(7)?,
-                    response_time_ms: row.get(8)?,
-                    http_status: row.get(9)?,
-                    tested_at: row.get(10)?,
-                })
-            })
-            .map_err(|e| AppError::Database(e.to_string()))?
-            .collect::<Result<Vec<_>, _>>()
-            .map_err(|e| AppError::Database(e.to_string()))?;
-
-        Ok(logs)
-    }
-
-    /// 获取模型测试配置
-    pub fn get_model_test_config(&self) -> Result<ModelTestConfig, AppError> {
-        match self.get_setting("model_test_config")? {
-            Some(json) => serde_json::from_str(&json)
-                .map_err(|e| AppError::Message(format!("解析模型测试配置失败: {e}"))),
-            None => Ok(ModelTestConfig::default()),
-        }
-    }
-
-    /// 保存模型测试配置
-    pub fn save_model_test_config(&self, config: &ModelTestConfig) -> Result<(), AppError> {
-        let json = serde_json::to_string(config)
-            .map_err(|e| AppError::Message(format!("序列化模型测试配置失败: {e}")))?;
-        self.set_setting("model_test_config", &json)
-    }
-
-    /// 清理旧的测试日志（保留最近 N 条）
-    pub fn cleanup_model_test_logs(&self, keep_count: u32) -> Result<u64, AppError> {
-        let conn = self
-            .conn
-            .lock()
-            .map_err(|e| AppError::Database(format!("获取数据库连接失败: {e}")))?;
-
-        let deleted = conn
-            .execute(
-                "DELETE FROM model_test_logs WHERE id NOT IN (
-                SELECT id FROM model_test_logs ORDER BY tested_at DESC LIMIT ?
-            )",
-                rusqlite::params![keep_count as i64],
-            )
-            .map_err(|e| AppError::Database(e.to_string()))?;
-
-        Ok(deleted as u64)
-    }
-}
@@ -144,9 +144,29 @@ impl ProviderService {
        state.db.save_provider(app_type.as_str(), &provider)?;

        if is_current {
-            write_live_snapshot(&app_type, &provider)?;
-            // Sync MCP
-            McpService::sync_all_enabled(state)?;
+            // 如果代理接管模式处于激活状态，并且代理服务正在运行：
+            // - 不写 Live 配置（否则会破坏接管）
+            // - 仅更新 Live 备份（保证关闭代理时能恢复到最新配置）
+            let is_app_taken_over =
+                futures::executor::block_on(state.db.get_live_backup(app_type.as_str()))
+                    .ok()
+                    .flatten()
+                    .is_some();
+            let is_proxy_running = futures::executor::block_on(state.proxy_service.is_running());
+            let should_skip_live_write = is_app_taken_over && is_proxy_running;
+
+            if should_skip_live_write {
+                futures::executor::block_on(
+                    state
+                        .proxy_service
+                        .update_live_backup_from_provider(app_type.as_str(), &provider),
+                )
+                .map_err(|e| AppError::Message(format!("更新 Live 备份失败: {e}")))?;
+            } else {
+                write_live_snapshot(&app_type, &provider)?;
+                // Sync MCP
+                McpService::sync_all_enabled(state)?;
+            }
        }

        Ok(true)
@@ -173,14 +193,77 @@ impl ProviderService {
    ///
    /// Switch flow:
    /// 1. Validate target provider exists
-    /// 2. **Backfill mechanism**: Backfill current live config to current provider, protect user manual modifications
-    /// 3. Update local settings current_provider_xxx (device-level)
-    /// 4. Update database is_current (as default for new devices)
-    /// 5. Write target provider config to live files
-    /// 6. Sync MCP configuration
+    /// 2. Check if proxy takeover mode is active AND proxy server is running
+    /// 3. If takeover mode active: hot-switch proxy target only (no Live config write)
+    /// 4. If normal mode:
+    ///    a. **Backfill mechanism**: Backfill current live config to current provider
+    ///    b. Update local settings current_provider_xxx (device-level)
+    ///    c. Update database is_current (as default for new devices)
+    ///    d. Write target provider config to live files
+    ///    e. Sync MCP configuration
    pub fn switch(state: &AppState, app_type: AppType, id: &str) -> Result<(), AppError> {
        // Check if provider exists
        let providers = state.db.get_all_providers(app_type.as_str())?;
+        let _provider = providers
+            .get(id)
+            .ok_or_else(|| AppError::Message(format!("供应商 {id} 不存在")))?;
+
+        // Check if proxy takeover mode is active AND proxy server is actually running
+        // Both conditions must be true to use hot-switch mode
+        // Use blocking wait since this is a sync function
+        let is_app_taken_over =
+            futures::executor::block_on(state.db.get_live_backup(app_type.as_str()))
+                .ok()
+                .flatten()
+                .is_some();
+        let is_proxy_running = futures::executor::block_on(state.proxy_service.is_running());
+
+        // Hot-switch only when BOTH: this app is taken over AND proxy server is actually running
+        let should_hot_switch = is_app_taken_over && is_proxy_running;
+
+        if should_hot_switch {
+            // Proxy takeover mode: hot-switch only, don't write Live config
+            log::info!(
+                "代理接管模式：热切换 {} 的目标供应商为 {}",
+                app_type.as_str(),
+                id
+            );
+
+            // 获取新供应商的完整配置（用于更新备份）
+            let provider = providers
+                .get(id)
+                .ok_or_else(|| AppError::Message(format!("供应商 {id} 不存在")))?;
+
+            // Update database is_current
+            state.db.set_current_provider(app_type.as_str(), id)?;
+
+            // Update local settings for consistency
+            crate::settings::set_current_provider(&app_type, Some(id))?;
+
+            // 更新 Live 备份（确保代理关闭时恢复正确的供应商配置）
+            futures::executor::block_on(
+                state
+                    .proxy_service
+                    .update_live_backup_from_provider(app_type.as_str(), provider),
+            )
+            .map_err(|e| AppError::Message(format!("更新 Live 备份失败: {e}")))?;
+
+            // Note: No Live config write, no MCP sync
+            // The proxy server will route requests to the new provider via is_current
+            return Ok(());
+        }
+
+        // Normal mode: full switch with Live config write
+        Self::switch_normal(state, app_type, id, &providers)
+    }
+
+    /// Normal switch flow (non-proxy mode)
+    fn switch_normal(
+        state: &AppState,
+        app_type: AppType,
+        id: &str,
+        providers: &indexmap::IndexMap<String, Provider>,
+    ) -> Result<(), AppError> {
        let provider = providers
            .get(id)
            .ok_or_else(|| AppError::Message(format!("供应商 {id} 不存在")))?;
@@ -217,18 +300,6 @@ impl ProviderService {
        Ok(())
    }

-    /// Set proxy target provider
-    pub fn set_proxy_target(state: &AppState, app_type: AppType, id: &str) -> Result<(), AppError> {
-        // Check if provider exists
-        let providers = state.db.get_all_providers(app_type.as_str())?;
-        if !providers.contains_key(id) {
-            return Err(AppError::Message(format!("供应商 {id} 不存在")));
-        }
-
-        state.db.set_proxy_target_provider(app_type.as_str(), id)?;
-        Ok(())
-    }
-
    /// Sync current provider to live configuration (re-export)
    pub fn sync_current_to_live(state: &AppState) -> Result<(), AppError> {
        sync_current_to_live(state)
@@ -79,6 +79,34 @@ pub(crate) async fn execute_and_format_usage_result(
    }
 }

+/// Extract API key from provider configuration
+fn extract_api_key_from_provider(provider: &crate::provider::Provider) -> Option<String> {
+    if let Some(env) = provider.settings_config.get("env") {
+        // Try multiple possible API key fields
+        env.get("ANTHROPIC_AUTH_TOKEN")
+            .or_else(|| env.get("ANTHROPIC_API_KEY"))
+            .or_else(|| env.get("OPENROUTER_API_KEY"))
+            .or_else(|| env.get("GOOGLE_API_KEY"))
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string())
+    } else {
+        None
+    }
+}
+
+/// Extract base URL from provider configuration
+fn extract_base_url_from_provider(provider: &crate::provider::Provider) -> Option<String> {
+    if let Some(env) = provider.settings_config.get("env") {
+        // Try multiple possible base URL fields
+        env.get("ANTHROPIC_BASE_URL")
+            .or_else(|| env.get("GOOGLE_GEMINI_BASE_URL"))
+            .and_then(|v| v.as_str())
+            .map(|s| s.trim_end_matches('/').to_string())
+    } else {
+        None
+    }
+}
+
 /// Query provider usage (using saved script configuration)
 pub async fn query_usage(
    state: &AppState,
@@ -114,12 +142,26 @@ pub async fn query_usage(
            ));
        }

-        // Get credentials directly from UsageScript, no longer extract from provider config
+        // Get credentials: prioritize UsageScript values, fallback to provider config
+        let api_key = usage_script
+            .api_key
+            .clone()
+            .filter(|k| !k.is_empty())
+            .or_else(|| extract_api_key_from_provider(provider))
+            .unwrap_or_default();
+
+        let base_url = usage_script
+            .base_url
+            .clone()
+            .filter(|u| !u.is_empty())
+            .or_else(|| extract_base_url_from_provider(provider))
+            .unwrap_or_default();
+
        (
            usage_script.code.clone(),
            usage_script.timeout.unwrap_or(10),
-            usage_script.api_key.clone().unwrap_or_default(),
-            usage_script.base_url.clone().unwrap_or_default(),
+            api_key,
+            base_url,
            usage_script.access_token.clone(),
            usage_script.user_id.clone(),
        )
@@ -7,6 +7,7 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use tokio::time::timeout;

+use crate::app_config::AppType;
 use crate::error::format_skill_error;

 /// 技能对象
@@ -106,11 +107,16 @@ pub struct SkillMetadata {
 pub struct SkillService {
    http_client: Client,
    install_dir: PathBuf,
+    app_type: AppType,
 }

 impl SkillService {
    pub fn new() -> Result<Self> {
-        let install_dir = Self::get_install_dir()?;
+        Self::new_for_app(AppType::Claude)
+    }
+
+    pub fn new_for_app(app_type: AppType) -> Result<Self> {
+        let install_dir = Self::get_install_dir_for_app(&app_type)?;

        // 确保目录存在
        fs::create_dir_all(&install_dir)?;
@@ -122,16 +128,38 @@ impl SkillService {
                .timeout(std::time::Duration::from_secs(10))
                .build()?,
            install_dir,
+            app_type,
        })
    }

-    fn get_install_dir() -> Result<PathBuf> {
+    fn get_install_dir_for_app(app_type: &AppType) -> Result<PathBuf> {
        let home = dirs::home_dir().context(format_skill_error(
            "GET_HOME_DIR_FAILED",
            &[],
            Some("checkPermission"),
        ))?;
-        Ok(home.join(".claude").join("skills"))
+
+        let dir = match app_type {
+            AppType::Claude => home.join(".claude").join("skills"),
+            AppType::Codex => {
+                // 检查是否有自定义 Codex 配置目录
+                if let Some(custom) = crate::settings::get_codex_override_dir() {
+                    custom.join("skills")
+                } else {
+                    home.join(".codex").join("skills")
+                }
+            }
+            AppType::Gemini => {
+                // 为 Gemini 预留，暂时使用默认路径
+                home.join(".gemini").join("skills")
+            }
+        };
+
+        Ok(dir)
+    }
+
+    pub fn app_type(&self) -> &AppType {
+        &self.app_type
    }
 }

@@ -316,9 +344,20 @@ impl SkillService {
            let directory = &local_skill.directory;

            // 更新已安装状态（匹配远程技能）
+            // 使用目录最后一段进行比较，因为安装时只使用最后一段作为目录名
            let mut found = false;
+            let local_install_name = Path::new(directory)
+                .file_name()
+                .map(|s| s.to_string_lossy().to_string())
+                .unwrap_or_else(|| directory.clone());
+
            for skill in skills.iter_mut() {
-                if skill.directory.eq_ignore_ascii_case(directory) {
+                let remote_install_name = Path::new(&skill.directory)
+                    .file_name()
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or_else(|| skill.directory.clone());
+
+                if remote_install_name.eq_ignore_ascii_case(&local_install_name) {
                    skill.installed = true;
                    found = true;
                    break;
@@ -517,7 +556,14 @@ impl SkillService {

    /// 安装技能（仅负责下载和文件操作，状态更新由上层负责）
    pub async fn install_skill(&self, directory: String, repo: SkillRepo) -> Result<()> {
-        let dest = self.install_dir.join(&directory);
+        // 使用技能目录的最后一段作为安装目录名，避免嵌套路径问题
+        // 例如: "skills/codex" -> "codex"
+        let install_name = Path::new(&directory)
+            .file_name()
+            .map(|s| s.to_string_lossy().to_string())
+            .unwrap_or_else(|| directory.clone());
+
+        let dest = self.install_dir.join(&install_name);

        // 若目标目录已存在，则视为已安装，避免重复下载
        if dest.exists() {
@@ -589,7 +635,13 @@ impl SkillService {

    /// 卸载技能（仅负责文件操作，状态更新由上层负责）
    pub fn uninstall_skill(&self, directory: String) -> Result<()> {
-        let dest = self.install_dir.join(&directory);
+        // 使用技能目录的最后一段作为安装目录名，与 install_skill 保持一致
+        let install_name = Path::new(&directory)
+            .file_name()
+            .map(|s| s.to_string_lossy().to_string())
+            .unwrap_or_else(|| directory.clone());
+
+        let dest = self.install_dir.join(&install_name);

        if dest.exists() {
            fs::remove_dir_all(&dest)?;
@@ -31,40 +31,51 @@ impl SpeedtestService {
            return Ok(vec![]);
        }

+        let mut results: Vec<Option<EndpointLatency>> = vec![None; urls.len()];
+        let mut valid_targets = Vec::new();
+
+        for (idx, raw_url) in urls.into_iter().enumerate() {
+            let trimmed = raw_url.trim().to_string();
+
+            if trimmed.is_empty() {
+                results[idx] = Some(EndpointLatency {
+                    url: raw_url,
+                    latency: None,
+                    status: None,
+                    error: Some("URL 不能为空".to_string()),
+                });
+                continue;
+            }
+
+            match Url::parse(&trimmed) {
+                Ok(parsed_url) => valid_targets.push((idx, trimmed, parsed_url)),
+                Err(err) => {
+                    results[idx] = Some(EndpointLatency {
+                        url: trimmed,
+                        latency: None,
+                        status: None,
+                        error: Some(format!("URL 无效: {err}")),
+                    });
+                }
+            }
+        }
+
+        if valid_targets.is_empty() {
+            return Ok(results.into_iter().flatten().collect::<Vec<_>>());
+        }
+
        let timeout = Self::sanitize_timeout(timeout_secs);
        let client = Self::build_client(timeout)?;

-        let tasks = urls.into_iter().map(|raw_url| {
+        let tasks = valid_targets.into_iter().map(|(idx, trimmed, parsed_url)| {
            let client = client.clone();
            async move {
-                let trimmed = raw_url.trim().to_string();
-                if trimmed.is_empty() {
-                    return EndpointLatency {
-                        url: raw_url,
-                        latency: None,
-                        status: None,
-                        error: Some("URL 不能为空".to_string()),
-                    };
-                }
-
-                let parsed_url = match Url::parse(&trimmed) {
-                    Ok(url) => url,
-                    Err(err) => {
-                        return EndpointLatency {
-                            url: trimmed,
-                            latency: None,
-                            status: None,
-                            error: Some(format!("URL 无效: {err}")),
-                        };
-                    }
-                };
-
                // 先进行一次热身请求，忽略结果，仅用于复用连接/绕过首包惩罚。
                let _ = client.get(parsed_url.clone()).send().await;

                // 第二次请求开始计时，并将其作为结果返回。
                let start = Instant::now();
-                match client.get(parsed_url).send().await {
+                let latency = match client.get(parsed_url).send().await {
                    Ok(resp) => EndpointLatency {
                        url: trimmed,
                        latency: Some(start.elapsed().as_millis()),
@@ -88,11 +99,17 @@ impl SpeedtestService {
                            error: Some(error_message),
                        }
                    }
-                }
+                };
+
+                (idx, latency)
            }
        });

-        Ok(join_all(tasks).await)
+        for (idx, latency) in join_all(tasks).await {
+            results[idx] = Some(latency);
+        }
+
+        Ok(results.into_iter().flatten().collect::<Vec<_>>())
    }

    fn build_client(timeout_secs: u64) -> Result<Client, AppError> {
@@ -0,0 +1,436 @@
+//! 流式健康检查服务
+//!
+//! 使用流式 API 进行快速健康检查，只需接收首个 chunk 即判定成功。
+
+use futures::StreamExt;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use std::time::{Duration, Instant};
+
+use crate::app_config::AppType;
+use crate::error::AppError;
+use crate::provider::Provider;
+use crate::proxy::providers::{get_adapter, AuthInfo};
+
+/// 健康状态枚举
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum HealthStatus {
+    Operational,
+    Degraded,
+    Failed,
+}
+
+/// 流式检查配置
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StreamCheckConfig {
+    pub timeout_secs: u64,
+    pub max_retries: u32,
+    pub degraded_threshold_ms: u64,
+    /// Claude 测试模型
+    pub claude_model: String,
+    /// Codex 测试模型
+    pub codex_model: String,
+    /// Gemini 测试模型
+    pub gemini_model: String,
+}
+
+impl Default for StreamCheckConfig {
+    fn default() -> Self {
+        Self {
+            timeout_secs: 45,
+            max_retries: 2,
+            degraded_threshold_ms: 6000,
+            claude_model: "claude-haiku-4-5-20251001".to_string(),
+            codex_model: "gpt-5.1-codex@low".to_string(),
+            gemini_model: "gemini-3-pro-preview".to_string(),
+        }
+    }
+}
+
+/// 流式检查结果
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StreamCheckResult {
+    pub status: HealthStatus,
+    pub success: bool,
+    pub message: String,
+    pub response_time_ms: Option<u64>,
+    pub http_status: Option<u16>,
+    pub model_used: String,
+    pub tested_at: i64,
+    pub retry_count: u32,
+}
+
+/// 流式健康检查服务
+pub struct StreamCheckService;
+
+impl StreamCheckService {
+    /// 执行流式健康检查（带重试）
+    pub async fn check_with_retry(
+        app_type: &AppType,
+        provider: &Provider,
+        config: &StreamCheckConfig,
+    ) -> Result<StreamCheckResult, AppError> {
+        let mut last_result = None;
+
+        for attempt in 0..=config.max_retries {
+            let result = Self::check_once(app_type, provider, config).await;
+
+            match &result {
+                Ok(r) if r.success => {
+                    return Ok(StreamCheckResult {
+                        retry_count: attempt,
+                        ..r.clone()
+                    });
+                }
+                Ok(r) => {
+                    // 失败但非异常，判断是否重试
+                    if Self::should_retry(&r.message) && attempt < config.max_retries {
+                        last_result = Some(r.clone());
+                        continue;
+                    }
+                    return Ok(StreamCheckResult {
+                        retry_count: attempt,
+                        ..r.clone()
+                    });
+                }
+                Err(e) => {
+                    if Self::should_retry(&e.to_string()) && attempt < config.max_retries {
+                        continue;
+                    }
+                    return Err(AppError::Message(e.to_string()));
+                }
+            }
+        }
+
+        Ok(last_result.unwrap_or_else(|| StreamCheckResult {
+            status: HealthStatus::Failed,
+            success: false,
+            message: "检查失败".to_string(),
+            response_time_ms: None,
+            http_status: None,
+            model_used: String::new(),
+            tested_at: chrono::Utc::now().timestamp(),
+            retry_count: config.max_retries,
+        }))
+    }
+
+    /// 单次流式检查
+    async fn check_once(
+        app_type: &AppType,
+        provider: &Provider,
+        config: &StreamCheckConfig,
+    ) -> Result<StreamCheckResult, AppError> {
+        let start = Instant::now();
+        let adapter = get_adapter(app_type);
+
+        let base_url = adapter
+            .extract_base_url(provider)
+            .map_err(|e| AppError::Message(format!("提取 base_url 失败: {e}")))?;
+
+        let auth = adapter
+            .extract_auth(provider)
+            .ok_or_else(|| AppError::Message("未找到 API Key".to_string()))?;
+
+        let client = Client::builder()
+            .timeout(Duration::from_secs(config.timeout_secs))
+            .user_agent("cc-switch/1.0")
+            .build()
+            .map_err(|e| AppError::Message(format!("创建客户端失败: {e}")))?;
+
+        let result = match app_type {
+            AppType::Claude => {
+                Self::check_claude_stream(&client, &base_url, &auth, &config.claude_model).await
+            }
+            AppType::Codex => {
+                Self::check_codex_stream(&client, &base_url, &auth, &config.codex_model).await
+            }
+            AppType::Gemini => {
+                Self::check_gemini_stream(&client, &base_url, &auth, &config.gemini_model).await
+            }
+        };
+
+        let response_time = start.elapsed().as_millis() as u64;
+        let tested_at = chrono::Utc::now().timestamp();
+
+        match result {
+            Ok((status_code, model)) => {
+                let health_status =
+                    Self::determine_status(response_time, config.degraded_threshold_ms);
+                Ok(StreamCheckResult {
+                    status: health_status,
+                    success: true,
+                    message: "检查成功".to_string(),
+                    response_time_ms: Some(response_time),
+                    http_status: Some(status_code),
+                    model_used: model,
+                    tested_at,
+                    retry_count: 0,
+                })
+            }
+            Err(e) => Ok(StreamCheckResult {
+                status: HealthStatus::Failed,
+                success: false,
+                message: e.to_string(),
+                response_time_ms: Some(response_time),
+                http_status: None,
+                model_used: String::new(),
+                tested_at,
+                retry_count: 0,
+            }),
+        }
+    }
+
+    /// Claude 流式检查
+    async fn check_claude_stream(
+        client: &Client,
+        base_url: &str,
+        auth: &AuthInfo,
+        model: &str,
+    ) -> Result<(u16, String), AppError> {
+        let base = base_url.trim_end_matches('/');
+        let url = if base.ends_with("/v1") {
+            format!("{base}/messages")
+        } else {
+            format!("{base}/v1/messages")
+        };
+
+        let body = json!({
+            "model": model,
+            "max_tokens": 1,
+            "messages": [{ "role": "user", "content": "hi" }],
+            "stream": true
+        });
+
+        let response = client
+            .post(&url)
+            .header("x-api-key", &auth.api_key)
+            .header("anthropic-version", "2023-06-01")
+            .header("Content-Type", "application/json")
+            .json(&body)
+            .send()
+            .await
+            .map_err(Self::map_request_error)?;
+
+        let status = response.status().as_u16();
+
+        if !response.status().is_success() {
+            let error_text = response.text().await.unwrap_or_default();
+            return Err(AppError::Message(format!("HTTP {status}: {error_text}")));
+        }
+
+        // 流式读取：只需首个 chunk
+        let mut stream = response.bytes_stream();
+        if let Some(chunk) = stream.next().await {
+            match chunk {
+                Ok(_) => Ok((status, model.to_string())),
+                Err(e) => Err(AppError::Message(format!("读取流失败: {e}"))),
+            }
+        } else {
+            Err(AppError::Message("未收到响应数据".to_string()))
+        }
+    }
+
+    /// Codex 流式检查
+    async fn check_codex_stream(
+        client: &Client,
+        base_url: &str,
+        auth: &AuthInfo,
+        model: &str,
+    ) -> Result<(u16, String), AppError> {
+        let base = base_url.trim_end_matches('/');
+        let url = if base.ends_with("/v1") {
+            format!("{base}/chat/completions")
+        } else {
+            format!("{base}/v1/chat/completions")
+        };
+
+        // 解析模型名和推理等级 (支持 model@level 或 model#level 格式)
+        let (actual_model, reasoning_effort) = Self::parse_model_with_effort(model);
+
+        let mut body = json!({
+            "model": actual_model,
+            "messages": [
+                { "role": "system", "content": "" },
+                { "role": "assistant", "content": "" },
+                { "role": "user", "content": "hi" }
+            ],
+            "max_tokens": 1,
+            "temperature": 0,
+            "stream": true
+        });
+
+        // 如果是推理模型，添加 reasoning_effort
+        if let Some(effort) = reasoning_effort {
+            body["reasoning_effort"] = json!(effort);
+        }
+
+        let response = client
+            .post(&url)
+            .header("Authorization", format!("Bearer {}", auth.api_key))
+            .header("Content-Type", "application/json")
+            .json(&body)
+            .send()
+            .await
+            .map_err(Self::map_request_error)?;
+
+        let status = response.status().as_u16();
+
+        if !response.status().is_success() {
+            let error_text = response.text().await.unwrap_or_default();
+            return Err(AppError::Message(format!("HTTP {status}: {error_text}")));
+        }
+
+        let mut stream = response.bytes_stream();
+        if let Some(chunk) = stream.next().await {
+            match chunk {
+                Ok(_) => Ok((status, model.to_string())),
+                Err(e) => Err(AppError::Message(format!("读取流失败: {e}"))),
+            }
+        } else {
+            Err(AppError::Message("未收到响应数据".to_string()))
+        }
+    }
+
+    /// Gemini 流式检查
+    async fn check_gemini_stream(
+        client: &Client,
+        base_url: &str,
+        auth: &AuthInfo,
+        model: &str,
+    ) -> Result<(u16, String), AppError> {
+        let base = base_url.trim_end_matches('/');
+        let url = format!("{base}/v1/chat/completions");
+
+        let body = json!({
+            "model": model,
+            "messages": [{ "role": "user", "content": "hi" }],
+            "max_tokens": 1,
+            "temperature": 0,
+            "stream": true
+        });
+
+        let response = client
+            .post(&url)
+            .header("Authorization", format!("Bearer {}", auth.api_key))
+            .header("Content-Type", "application/json")
+            .json(&body)
+            .send()
+            .await
+            .map_err(Self::map_request_error)?;
+
+        let status = response.status().as_u16();
+
+        if !response.status().is_success() {
+            let error_text = response.text().await.unwrap_or_default();
+            return Err(AppError::Message(format!("HTTP {status}: {error_text}")));
+        }
+
+        let mut stream = response.bytes_stream();
+        if let Some(chunk) = stream.next().await {
+            match chunk {
+                Ok(_) => Ok((status, model.to_string())),
+                Err(e) => Err(AppError::Message(format!("读取流失败: {e}"))),
+            }
+        } else {
+            Err(AppError::Message("未收到响应数据".to_string()))
+        }
+    }
+
+    fn determine_status(latency_ms: u64, threshold: u64) -> HealthStatus {
+        if latency_ms <= threshold {
+            HealthStatus::Operational
+        } else {
+            HealthStatus::Degraded
+        }
+    }
+
+    /// 解析模型名和推理等级 (支持 model@level 或 model#level 格式)
+    /// 返回 (实际模型名, Option<推理等级>)
+    fn parse_model_with_effort(model: &str) -> (String, Option<String>) {
+        // 查找 @ 或 # 分隔符
+        if let Some(pos) = model.find('@').or_else(|| model.find('#')) {
+            let actual_model = model[..pos].to_string();
+            let effort = model[pos + 1..].to_string();
+            if !effort.is_empty() {
+                return (actual_model, Some(effort));
+            }
+        }
+        (model.to_string(), None)
+    }
+
+    fn should_retry(msg: &str) -> bool {
+        let lower = msg.to_lowercase();
+        lower.contains("timeout")
+            || lower.contains("abort")
+            || lower.contains("中断")
+            || lower.contains("超时")
+    }
+
+    fn map_request_error(e: reqwest::Error) -> AppError {
+        if e.is_timeout() {
+            AppError::Message("请求超时".to_string())
+        } else if e.is_connect() {
+            AppError::Message(format!("连接失败: {e}"))
+        } else {
+            AppError::Message(e.to_string())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_determine_status() {
+        assert_eq!(
+            StreamCheckService::determine_status(3000, 6000),
+            HealthStatus::Operational
+        );
+        assert_eq!(
+            StreamCheckService::determine_status(6000, 6000),
+            HealthStatus::Operational
+        );
+        assert_eq!(
+            StreamCheckService::determine_status(6001, 6000),
+            HealthStatus::Degraded
+        );
+    }
+
+    #[test]
+    fn test_should_retry() {
+        assert!(StreamCheckService::should_retry("请求超时"));
+        assert!(StreamCheckService::should_retry("request timeout"));
+        assert!(!StreamCheckService::should_retry("API Key 无效"));
+    }
+
+    #[test]
+    fn test_default_config() {
+        let config = StreamCheckConfig::default();
+        assert_eq!(config.timeout_secs, 45);
+        assert_eq!(config.max_retries, 2);
+        assert_eq!(config.degraded_threshold_ms, 6000);
+    }
+
+    #[test]
+    fn test_parse_model_with_effort() {
+        // 带 @ 分隔符
+        let (model, effort) = StreamCheckService::parse_model_with_effort("gpt-5.1-codex@low");
+        assert_eq!(model, "gpt-5.1-codex");
+        assert_eq!(effort, Some("low".to_string()));
+
+        // 带 # 分隔符
+        let (model, effort) = StreamCheckService::parse_model_with_effort("o1-preview#high");
+        assert_eq!(model, "o1-preview");
+        assert_eq!(effort, Some("high".to_string()));
+
+        // 无分隔符
+        let (model, effort) = StreamCheckService::parse_model_with_effort("gpt-4o-mini");
+        assert_eq!(model, "gpt-4o-mini");
+        assert_eq!(effort, None);
+    }
+}
@@ -652,56 +652,6 @@ impl Database {
            monthly_exceeded,
        })
    }
-
-    /// 更新每日统计聚合
-    ///
-    /// 在请求完成后调用，更新 usage_daily_stats 表
-    #[allow(clippy::too_many_arguments)]
-    pub fn update_daily_stats(
-        &self,
-        provider_id: &str,
-        app_type: &str,
-        model: &str,
-        input_tokens: u32,
-        output_tokens: u32,
-        total_cost: &str,
-        is_success: bool,
-    ) -> Result<(), AppError> {
-        let conn = lock_conn!(self.conn);
-        let date = Utc::now().format("%Y-%m-%d").to_string();
-
-        // 使用 UPSERT 更新或插入统计
-        conn.execute(
-            "INSERT INTO usage_daily_stats (
-                date, provider_id, app_type, model,
-                request_count, total_input_tokens, total_output_tokens,
-                total_cost_usd, success_count, error_count
-            ) VALUES (?1, ?2, ?3, ?4, 1, ?5, ?6, ?7, ?8, ?9)
-            ON CONFLICT(date, provider_id, app_type, model) DO UPDATE SET
-                request_count = request_count + 1,
-                total_input_tokens = total_input_tokens + ?5,
-                total_output_tokens = total_output_tokens + ?6,
-                total_cost_usd = CAST(
-                    CAST(total_cost_usd AS REAL) + CAST(?7 AS REAL) AS TEXT
-                ),
-                success_count = success_count + ?8,
-                error_count = error_count + ?9",
-            params![
-                date,
-                provider_id,
-                app_type,
-                model,
-                input_tokens,
-                output_tokens,
-                total_cost,
-                if is_success { 1 } else { 0 },
-                if is_success { 0 } else { 1 },
-            ],
-        )
-        .map_err(|e| AppError::Database(format!("更新每日统计失败: {e}")))?;
-
-        Ok(())
-    }
 }

 /// Provider 限额状态
@@ -31,6 +31,9 @@ pub struct AppSettings {
    /// 是否启用 Claude 插件联动
    #[serde(default)]
    pub enable_claude_plugin_integration: bool,
+    /// 是否跳过 Claude Code 初次安装确认
+    #[serde(default = "default_true")]
+    pub skip_claude_onboarding: bool,
    /// 是否开机自启
    #[serde(default)]
    pub launch_on_startup: bool,
@@ -65,12 +68,17 @@ fn default_minimize_to_tray_on_close() -> bool {
    true
 }

+fn default_true() -> bool {
+    true
+}
+
 impl Default for AppSettings {
    fn default() -> Self {
        Self {
            show_in_tray: true,
            minimize_to_tray_on_close: true,
            enable_claude_plugin_integration: false,
+            skip_claude_onboarding: true,
            launch_on_startup: false,
            language: None,
            claude_config_dir: None,
@@ -3,6 +3,7 @@ use rquickjs::{Context, Function, Runtime};
 use serde_json::Value;
 use std::collections::HashMap;
 use std::time::Duration;
+use url::{Host, Url};

 use crate::error::AppError;

@@ -15,20 +16,14 @@ pub async fn execute_usage_script(
    access_token: Option<&str>,
    user_id: Option<&str>,
 ) -> Result<Value, AppError> {
-    // 1. 替换变量
-    let mut replaced = script_code
-        .replace("{{apiKey}}", api_key)
-        .replace("{{baseUrl}}", base_url);
+    // 1. 替换模板变量，避免泄露敏感信息
+    let script_with_vars =
+        build_script_with_vars(script_code, api_key, base_url, access_token, user_id);

-    // 替换 accessToken 和 userId
-    if let Some(token) = access_token {
-        replaced = replaced.replace("{{accessToken}}", token);
-    }
-    if let Some(uid) = user_id {
-        replaced = replaced.replace("{{userId}}", uid);
-    }
+    // 2. 验证 base_url 的安全性
+    validate_base_url(base_url)?;

-    // 2. 在独立作用域中提取 request 配置（确保 Runtime/Context 在 await 前释放）
+    // 3. 在独立作用域中提取 request 配置（确保 Runtime/Context 在 await 前释放）
    let request_config = {
        let runtime = Runtime::new().map_err(|e| {
            AppError::localized(
@@ -47,7 +42,7 @@ pub async fn execute_usage_script(

        context.with(|ctx| {
            // 执行用户代码，获取配置对象
-            let config: rquickjs::Object = ctx.eval(replaced.clone()).map_err(|e| {
+            let config: rquickjs::Object = ctx.eval(script_with_vars.clone()).map_err(|e| {
                AppError::localized(
                    "usage_script.config_parse_failed",
                    format!("解析配置失败: {e}"),
@@ -94,7 +89,7 @@ pub async fn execute_usage_script(
        })?
    }; // Runtime 和 Context 在这里被 drop

-    // 3. 解析 request 配置
+    // 4. 解析 request 配置
    let request: RequestConfig = serde_json::from_str(&request_config).map_err(|e| {
        AppError::localized(
            "usage_script.request_format_invalid",
@@ -103,10 +98,13 @@ pub async fn execute_usage_script(
        )
    })?;

-    // 4. 发送 HTTP 请求
+    // 5. 验证请求 URL 是否安全（防止 SSRF）
+    validate_request_url(&request.url, base_url)?;
+
+    // 6. 发送 HTTP 请求
    let response_data = send_http_request(&request, timeout_secs).await?;

-    // 5. 在独立作用域中执行 extractor（确保 Runtime/Context 在函数结束前释放）
+    // 7. 在独立作用域中执行 extractor（确保 Runtime/Context 在函数结束前释放）
    let result: Value = {
        let runtime = Runtime::new().map_err(|e| {
            AppError::localized(
@@ -125,7 +123,7 @@ pub async fn execute_usage_script(

        context.with(|ctx| {
            // 重新 eval 获取配置对象
-            let config: rquickjs::Object = ctx.eval(replaced.clone()).map_err(|e| {
+            let config: rquickjs::Object = ctx.eval(script_with_vars.clone()).map_err(|e| {
                AppError::localized(
                    "usage_script.config_reparse_failed",
                    format!("重新解析配置失败: {e}"),
@@ -198,7 +196,7 @@ pub async fn execute_usage_script(
        })?
    }; // Runtime 和 Context 在这里被 drop

-    // 6. 验证返回值格式
+    // 8. 验证返回值格式
    validate_result(&result)?;

    Ok(result)
@@ -394,3 +392,479 @@ fn validate_single_usage(result: &Value) -> Result<(), AppError> {

    Ok(())
 }
+
+/// 构建替换变量后的脚本，保持与旧版脚本的兼容性
+fn build_script_with_vars(
+    script_code: &str,
+    api_key: &str,
+    base_url: &str,
+    access_token: Option<&str>,
+    user_id: Option<&str>,
+) -> String {
+    let mut replaced = script_code
+        .replace("{{apiKey}}", api_key)
+        .replace("{{baseUrl}}", base_url);
+
+    if let Some(token) = access_token {
+        replaced = replaced.replace("{{accessToken}}", token);
+    }
+    if let Some(uid) = user_id {
+        replaced = replaced.replace("{{userId}}", uid);
+    }
+
+    replaced
+}
+
+/// 验证 base_url 的基本安全性
+fn validate_base_url(base_url: &str) -> Result<(), AppError> {
+    if base_url.is_empty() {
+        return Err(AppError::localized(
+            "usage_script.base_url_empty",
+            "base_url 不能为空",
+            "base_url cannot be empty",
+        ));
+    }
+
+    // 解析 URL
+    let parsed_url = Url::parse(base_url).map_err(|e| {
+        AppError::localized(
+            "usage_script.base_url_invalid",
+            format!("无效的 base_url: {e}"),
+            format!("Invalid base_url: {e}"),
+        )
+    })?;
+
+    let is_loopback = is_loopback_host(&parsed_url);
+
+    // 必须是 HTTPS（允许 localhost 用于开发）
+    if parsed_url.scheme() != "https" && !is_loopback {
+        return Err(AppError::localized(
+            "usage_script.base_url_https_required",
+            "base_url 必须使用 HTTPS 协议（localhost 除外）",
+            "base_url must use HTTPS (localhost allowed)",
+        ));
+    }
+
+    // 检查主机名格式有效性
+    let hostname = parsed_url.host_str().ok_or_else(|| {
+        AppError::localized(
+            "usage_script.base_url_hostname_missing",
+            "base_url 必须包含有效的主机名",
+            "base_url must include a valid hostname",
+        )
+    })?;
+
+    // 基本的主机名格式检查
+    if hostname.is_empty() {
+        return Err(AppError::localized(
+            "usage_script.base_url_hostname_empty",
+            "base_url 主机名不能为空",
+            "base_url hostname cannot be empty",
+        ));
+    }
+
+    // 检查是否为明显的私有IP（但在 base_url 阶段不过于严格，主要在 request_url 阶段检查）
+    if is_suspicious_hostname(hostname) {
+        return Err(AppError::localized(
+            "usage_script.base_url_suspicious",
+            "base_url 包含可疑的主机名",
+            "base_url contains a suspicious hostname",
+        ));
+    }
+
+    Ok(())
+}
+
+/// 验证请求 URL 是否安全（防止 SSRF）
+fn validate_request_url(request_url: &str, base_url: &str) -> Result<(), AppError> {
+    // 解析请求 URL
+    let parsed_request = Url::parse(request_url).map_err(|e| {
+        AppError::localized(
+            "usage_script.request_url_invalid",
+            format!("无效的请求 URL: {e}"),
+            format!("Invalid request URL: {e}"),
+        )
+    })?;
+
+    // 解析 base URL
+    let parsed_base = Url::parse(base_url).map_err(|e| {
+        AppError::localized(
+            "usage_script.base_url_invalid",
+            format!("无效的 base_url: {e}"),
+            format!("Invalid base_url: {e}"),
+        )
+    })?;
+
+    let is_request_loopback = is_loopback_host(&parsed_request);
+
+    // 必须使用 HTTPS（允许 localhost 用于开发）
+    if parsed_request.scheme() != "https" && !is_request_loopback {
+        return Err(AppError::localized(
+            "usage_script.request_https_required",
+            "请求 URL 必须使用 HTTPS 协议（localhost 除外）",
+            "Request URL must use HTTPS (localhost allowed)",
+        ));
+    }
+
+    // 核心安全检查：必须与 base_url 同源（相同域名和端口）
+    if parsed_request.host_str() != parsed_base.host_str() {
+        return Err(AppError::localized(
+            "usage_script.request_host_mismatch",
+            format!(
+                "请求域名 {} 与 base_url 域名 {} 不匹配（必须是同源请求）",
+                parsed_request.host_str().unwrap_or("unknown"),
+                parsed_base.host_str().unwrap_or("unknown")
+            ),
+            format!(
+                "Request host {} must match base_url host {} (same-origin required)",
+                parsed_request.host_str().unwrap_or("unknown"),
+                parsed_base.host_str().unwrap_or("unknown")
+            ),
+        ));
+    }
+
+    // 检查端口是否匹配（考虑默认端口）
+    // 使用 port_or_known_default() 会自动处理默认端口（http->80, https->443）
+    match (
+        parsed_request.port_or_known_default(),
+        parsed_base.port_or_known_default(),
+    ) {
+        (Some(request_port), Some(base_port)) if request_port == base_port => {
+            // 端口匹配，继续执行
+        }
+        (Some(request_port), Some(base_port)) => {
+            return Err(AppError::localized(
+                "usage_script.request_port_mismatch",
+                format!("请求端口 {request_port} 必须与 base_url 端口 {base_port} 匹配"),
+                format!("Request port {request_port} must match base_url port {base_port}"),
+            ));
+        }
+        _ => {
+            // 理论上不会发生，因为 port_or_known_default() 应该总是返回 Some
+            return Err(AppError::localized(
+                "usage_script.request_port_unknown",
+                "无法确定端口号",
+                "Unable to determine port number",
+            ));
+        }
+    }
+
+    // 禁止私有 IP 地址访问（除非 base_url 本身就是私有地址，用于开发环境）
+    if let Some(host) = parsed_request.host_str() {
+        let base_host = parsed_base.host_str().unwrap_or("");
+
+        // 如果 base_url 不是私有地址，则禁止访问私有IP
+        if !is_private_ip(base_host) && is_private_ip(host) {
+            return Err(AppError::localized(
+                "usage_script.private_ip_blocked",
+                "禁止访问私有 IP 地址",
+                "Access to private IP addresses is blocked",
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+/// 检查是否为私有 IP 地址
+fn is_private_ip(host: &str) -> bool {
+    // localhost 检查
+    if host.eq_ignore_ascii_case("localhost") {
+        return true;
+    }
+
+    // 尝试解析为IP地址
+    if let Ok(ip_addr) = host.parse::<std::net::IpAddr>() {
+        return is_private_ip_addr(ip_addr);
+    }
+
+    // 如果不是IP地址，不是私有IP
+    false
+}
+
+/// 使用标准库API检查IP地址是否为私有地址
+fn is_private_ip_addr(ip: std::net::IpAddr) -> bool {
+    match ip {
+        std::net::IpAddr::V4(ipv4) => {
+            let octets = ipv4.octets();
+
+            // 0.0.0.0/8 (包括未指定地址)
+            if octets[0] == 0 {
+                return true;
+            }
+
+            // RFC1918 私有地址范围
+            // 10.0.0.0/8
+            if octets[0] == 10 {
+                return true;
+            }
+
+            // 172.16.0.0/12 (172.16.0.0 - 172.31.255.255)
+            if octets[0] == 172 && octets[1] >= 16 && octets[1] <= 31 {
+                return true;
+            }
+
+            // 192.168.0.0/16
+            if octets[0] == 192 && octets[1] == 168 {
+                return true;
+            }
+
+            // 其他特殊地址
+            // 169.254.0.0/16 (链路本地地址)
+            if octets[0] == 169 && octets[1] == 254 {
+                return true;
+            }
+
+            // 127.0.0.0/8 (环回地址)
+            if octets[0] == 127 {
+                return true;
+            }
+
+            false
+        }
+        std::net::IpAddr::V6(ipv6) => {
+            // IPv6 私有地址检查 - 使用标准库方法
+
+            // ::1 (环回地址)
+            if ipv6.is_loopback() {
+                return true;
+            }
+
+            // 唯一本地地址 (fc00::/7)
+            // Rust 1.70+ 可以使用 ipv6.is_unique_local()
+            // 但为了兼容性，我们手动检查
+            let first_segment = ipv6.segments()[0];
+            if (first_segment & 0xfe00) == 0xfc00 {
+                return true;
+            }
+
+            // 链路本地地址 (fe80::/10)
+            if (first_segment & 0xffc0) == 0xfe80 {
+                return true;
+            }
+
+            // 未指定地址 ::
+            if ipv6.is_unspecified() {
+                return true;
+            }
+
+            false
+        }
+    }
+}
+
+/// 检查是否为可疑的主机名（只检查明显不安全的模式）
+fn is_suspicious_hostname(hostname: &str) -> bool {
+    // 空主机名
+    if hostname.is_empty() {
+        return true;
+    }
+
+    // 检查明显的主机名格式问题
+    if hostname.contains("..") || hostname.starts_with(".") || hostname.ends_with(".") {
+        return true;
+    }
+
+    // 检查是否为纯IP地址但没有合理格式（过于宽松的检查在这里可能不够，但主要依赖后续的同源检查）
+    if hostname.parse::<std::net::IpAddr>().is_ok() {
+        // IP地址格式的，在这里不直接拒绝，让同源检查来处理
+        return false;
+    }
+
+    // 检查是否包含明显不当的字符
+    let suspicious_chars = ['<', '>', '"', '\'', '\n', '\r', '\t', '\0'];
+    if hostname.chars().any(|c| suspicious_chars.contains(&c)) {
+        return true;
+    }
+
+    false
+}
+
+/// 判断 URL 是否指向本机（localhost / loopback）
+fn is_loopback_host(url: &Url) -> bool {
+    match url.host() {
+        Some(Host::Domain(d)) => d.eq_ignore_ascii_case("localhost"),
+        Some(Host::Ipv4(ip)) => ip.is_loopback(),
+        Some(Host::Ipv6(ip)) => ip.is_loopback(),
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_private_ip_validation() {
+        // 测试IPv4私网地址
+
+        // RFC1918私网地址 - 应该返回true
+        assert!(is_private_ip("10.0.0.1"));
+        assert!(is_private_ip("10.255.255.254"));
+        assert!(is_private_ip("172.16.0.1"));
+        assert!(is_private_ip("172.31.255.255"));
+        assert!(is_private_ip("192.168.0.1"));
+        assert!(is_private_ip("192.168.255.255"));
+
+        // 链路本地地址 - 应该返回true
+        assert!(is_private_ip("169.254.0.1"));
+        assert!(is_private_ip("169.254.255.255"));
+
+        // 环回地址 - 应该返回true
+        assert!(is_private_ip("127.0.0.1"));
+        assert!(is_private_ip("localhost"));
+
+        // 公网172.x.x.x地址 - 应该返回false（这是修复的重点）
+        assert!(!is_private_ip("172.0.0.1"));
+        assert!(!is_private_ip("172.15.255.255"));
+        assert!(!is_private_ip("172.32.0.1"));
+        assert!(!is_private_ip("172.64.0.1"));
+        assert!(!is_private_ip("172.67.0.1")); // Cloudflare CDN
+        assert!(!is_private_ip("172.68.0.1"));
+        assert!(!is_private_ip("172.100.50.25"));
+        assert!(!is_private_ip("172.255.255.255"));
+
+        // 其他公网地址 - 应该返回false
+        assert!(!is_private_ip("8.8.8.8")); // Google DNS
+        assert!(!is_private_ip("1.1.1.1")); // Cloudflare DNS
+        assert!(!is_private_ip("208.67.222.222")); // OpenDNS
+        assert!(!is_private_ip("180.76.76.76")); // Baidu DNS
+
+        // 域名 - 应该返回false
+        assert!(!is_private_ip("api.example.com"));
+        assert!(!is_private_ip("www.google.com"));
+    }
+
+    #[test]
+    fn test_ipv6_private_validation() {
+        // IPv6私网地址
+        assert!(is_private_ip("::1")); // 环回地址
+        assert!(is_private_ip("fc00::1")); // 唯一本地地址
+        assert!(is_private_ip("fd00::1")); // 唯一本地地址
+        assert!(is_private_ip("fe80::1")); // 链路本地地址
+        assert!(is_private_ip("::")); // 未指定地址
+
+        // IPv6公网地址 - 应该返回false（修复的重点）
+        assert!(!is_private_ip("2001:4860:4860::8888")); // Google DNS IPv6
+        assert!(!is_private_ip("2606:4700:4700::1111")); // Cloudflare DNS IPv6
+        assert!(!is_private_ip("2404:6800:4001:c01::67")); // Google DNS IPv6 (其他格式)
+        assert!(!is_private_ip("2001:db8::1")); // 文档地址（非私网）
+
+        // 测试包含 ::1 子串但不是环回地址的公网地址
+        assert!(!is_private_ip("2001:db8::1abc")); // 包含 ::1abc 但不是环回
+        assert!(!is_private_ip("2606:4700::1")); // 包含 ::1 但不是环回
+    }
+
+    #[test]
+    fn test_hostname_bypass_prevention() {
+        // 看起来像本地，但实际是域名
+        assert!(!is_private_ip("127.0.0.1.evil.com"));
+        assert!(!is_private_ip("localhost.evil.com"));
+
+        // 0.0.0.0 应该被视为本地/阻断
+        assert!(is_private_ip("0.0.0.0"));
+    }
+
+    #[test]
+    fn test_https_bypass_prevention() {
+        // 非本地域名的 HTTP 应该被拒绝
+        let result = validate_base_url("http://127.0.0.1.evil.com/api");
+        assert!(
+            result.is_err(),
+            "Should reject HTTP for non-localhost domains"
+        );
+    }
+
+    #[test]
+    fn test_edge_cases() {
+        // 边界情况测试
+        assert!(is_private_ip("172.16.0.0")); // RFC1918起始
+        assert!(is_private_ip("172.31.255.255")); // RFC1918结束
+        assert!(is_private_ip("10.0.0.0")); // 10.0.0.0/8起始
+        assert!(is_private_ip("10.255.255.255")); // 10.0.0.0/8结束
+        assert!(is_private_ip("192.168.0.0")); // 192.168.0.0/16起始
+        assert!(is_private_ip("192.168.255.255")); // 192.168.0.0/16结束
+
+        // 紧邻RFC1918的公网地址 - 应该返回false
+        assert!(!is_private_ip("172.15.255.255")); // 172.16.0.0的前一个
+        assert!(!is_private_ip("172.32.0.0")); // 172.31.255.255的后一个
+    }
+
+    #[test]
+    fn test_ip_addr_parsing() {
+        // 测试IP地址解析功能
+        let ipv4_private = "10.0.0.1".parse::<std::net::IpAddr>().unwrap();
+        assert!(is_private_ip_addr(ipv4_private));
+
+        let ipv4_public = "172.67.0.1".parse::<std::net::IpAddr>().unwrap();
+        assert!(!is_private_ip_addr(ipv4_public));
+
+        let ipv6_private = "fc00::1".parse::<std::net::IpAddr>().unwrap();
+        assert!(is_private_ip_addr(ipv6_private));
+
+        let ipv6_public = "2001:4860:4860::8888".parse::<std::net::IpAddr>().unwrap();
+        assert!(!is_private_ip_addr(ipv6_public));
+    }
+
+    #[test]
+    fn test_port_comparison() {
+        // 测试端口比较逻辑是否正确处理默认端口和显式端口
+
+        // 测试用例：(base_url, request_url, should_match)
+        let test_cases = vec![
+            // HTTPS默认端口测试
+            (
+                "https://api.example.com",
+                "https://api.example.com/v1/test",
+                true,
+            ),
+            (
+                "https://api.example.com",
+                "https://api.example.com:443/v1/test",
+                true,
+            ),
+            (
+                "https://api.example.com:443",
+                "https://api.example.com/v1/test",
+                true,
+            ),
+            (
+                "https://api.example.com:443",
+                "https://api.example.com:443/v1/test",
+                true,
+            ),
+            // 端口不匹配测试
+            (
+                "https://api.example.com",
+                "https://api.example.com:8443/v1/test",
+                false,
+            ),
+            (
+                "https://api.example.com:443",
+                "https://api.example.com:8443/v1/test",
+                false,
+            ),
+        ];
+
+        for (base_url, request_url, should_match) in test_cases {
+            let result = validate_request_url(request_url, base_url);
+
+            if should_match {
+                assert!(
+                    result.is_ok(),
+                    "应该匹配的URL被拒绝: base_url={}, request_url={}, error={}",
+                    base_url,
+                    request_url,
+                    result.unwrap_err()
+                );
+            } else {
+                assert!(
+                    result.is_err(),
+                    "应该不匹配的URL被允许: base_url={}, request_url={}",
+                    base_url,
+                    request_url
+                );
+            }
+        }
+    }
+}
@@ -1,7 +1,7 @@
 {
  "$schema": "https://schema.tauri.app/config/2",
  "productName": "CC Switch",
-  "version": "3.8.2",
+  "version": "3.9.0-2",
  "identifier": "com.ccswitch.desktop",
  "build": {
    "frontendDist": "../dist",
@@ -0,0 +1,13 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "app": {
+    "windows": [
+      {
+        "label": "main",
+        "titleBarStyle": "Visible",
+        "minWidth": 900,
+        "minHeight": 600
+      }
+    ]
+  }
+}
@@ -1,6 +1,8 @@
 use std::sync::Arc;

-use cc_switch_lib::{import_provider_from_deeplink, parse_deeplink_url, AppState, Database};
+use cc_switch_lib::{
+    import_provider_from_deeplink, parse_deeplink_url, AppState, Database, ProxyService,
+};

 #[path = "support.rs"]
 mod support;
@@ -16,8 +18,11 @@ fn deeplink_import_claude_provider_persists_to_db() {
    let request = parse_deeplink_url(url).expect("parse deeplink url");

    let db = Arc::new(Database::memory().expect("create memory db"));
-
-    let state = AppState { db: db.clone() };
+    let proxy_service = ProxyService::new(db.clone());
+    let state = AppState {
+        db: db.clone(),
+        proxy_service,
+    };

    let provider_id = import_provider_from_deeplink(&state, request.clone())
        .expect("import provider from deeplink");
@@ -53,8 +58,11 @@ fn deeplink_import_codex_provider_builds_auth_and_config() {
    let request = parse_deeplink_url(url).expect("parse deeplink url");

    let db = Arc::new(Database::memory().expect("create memory db"));
-
-    let state = AppState { db: db.clone() };
+    let proxy_service = ProxyService::new(db.clone());
+    let state = AppState {
+        db: db.clone(),
+        proxy_service,
+    };

    let provider_id = import_provider_from_deeplink(&state, request.clone())
        .expect("import provider from deeplink");
@@ -154,6 +154,12 @@ fn sync_enabled_to_codex_writes_enabled_servers() {
    let _guard = test_mutex().lock().expect("acquire test mutex");
    reset_test_fs();

+    // 模拟 Codex 已安装/已初始化：存在 ~/.codex 目录
+    let path = cc_switch_lib::get_codex_config_path();
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent).expect("create codex dir");
+    }
+
    let mut config = MultiAppConfig::default();
    config.mcp.codex.servers.insert(
        "stdio-enabled".into(),
@@ -170,7 +176,6 @@ fn sync_enabled_to_codex_writes_enabled_servers() {

    cc_switch_lib::sync_enabled_to_codex(&config).expect("sync codex");

-    let path = cc_switch_lib::get_codex_config_path();
    assert!(path.exists(), "config.toml should be created");
    let text = fs::read_to_string(&path).expect("read config.toml");
    assert!(
@@ -594,6 +599,11 @@ command = "echo"
 fn sync_claude_enabled_mcp_projects_to_user_config() {
    let _guard = test_mutex().lock().expect("acquire test mutex");
    reset_test_fs();
+    let home = ensure_test_home();
+
+    // 模拟 Claude 已安装/已初始化：存在 ~/.claude 目录
+    fs::create_dir_all(home.join(".claude")).expect("create claude dir");
+
    let mut config = MultiAppConfig::default();

    config.mcp.claude.servers.insert(
@@ -993,3 +1003,76 @@ fn export_sql_returns_error_for_invalid_path() {
        other => panic!("expected IoContext or Io error, got {other:?}"),
    }
 }
+
+#[test]
+fn import_sql_rejects_non_cc_switch_backup() {
+    let _guard = test_mutex().lock().expect("acquire test mutex");
+    reset_test_fs();
+    let home = ensure_test_home();
+
+    let state = create_test_state().expect("create test state");
+
+    let import_path = home.join("not-cc-switch.sql");
+    fs::write(&import_path, "CREATE TABLE x (id INTEGER);").expect("write import sql");
+
+    let err = state
+        .db
+        .import_sql(&import_path)
+        .expect_err("non-cc-switch sql should be rejected");
+
+    match err {
+        AppError::Localized { key, .. } => {
+            assert_eq!(key, "backup.sql.invalid_format");
+        }
+        other => panic!("expected Localized error, got {other:?}"),
+    }
+}
+
+#[test]
+fn import_sql_accepts_cc_switch_exported_backup() {
+    let _guard = test_mutex().lock().expect("acquire test mutex");
+    reset_test_fs();
+    let home = ensure_test_home();
+
+    // Create a database with some data and export it.
+    let mut config = MultiAppConfig::default();
+    {
+        let manager = config
+            .get_manager_mut(&AppType::Claude)
+            .expect("claude manager");
+        manager.current = "test-provider".to_string();
+        manager.providers.insert(
+            "test-provider".to_string(),
+            Provider::with_id(
+                "test-provider".to_string(),
+                "Test Provider".to_string(),
+                json!({"env": {"ANTHROPIC_API_KEY": "test-key"}}),
+                None,
+            ),
+        );
+    }
+
+    let state = create_test_state_with_config(&config).expect("create test state");
+    let export_path = home.join("cc-switch-export.sql");
+    state
+        .db
+        .export_sql(&export_path)
+        .expect("export should succeed");
+
+    // Reset database, then import into a fresh one.
+    reset_test_fs();
+    let state = create_test_state().expect("create test state");
+    state
+        .db
+        .import_sql(&export_path)
+        .expect("import should succeed");
+
+    let providers = state
+        .db
+        .get_all_providers(AppType::Claude.as_str())
+        .expect("load providers");
+    assert!(
+        providers.contains_key("test-provider"),
+        "imported providers should contain test-provider"
+    );
+}
@@ -246,3 +246,311 @@ fn set_mcp_enabled_for_codex_writes_live_config() {
        "codex config should include the enabled server definition"
    );
 }
+
+#[test]
+fn enabling_codex_mcp_skips_when_codex_dir_missing() {
+    use support::create_test_state;
+
+    let _guard = test_mutex().lock().expect("acquire test mutex");
+    reset_test_fs();
+    let home = ensure_test_home();
+
+    // 确认 Codex 配置目录不存在（模拟“未安装/未运行过 Codex CLI”）
+    assert!(
+        !home.join(".codex").exists(),
+        "~/.codex should not exist in fresh test environment"
+    );
+
+    let state = create_test_state().expect("create test state");
+
+    // 先插入一个未启用 Codex 的 MCP 服务器（避免 upsert 触发同步）
+    McpService::upsert_server(
+        &state,
+        McpServer {
+            id: "codex-server".to_string(),
+            name: "Codex Server".to_string(),
+            server: json!({
+                "type": "stdio",
+                "command": "echo"
+            }),
+            apps: McpApps {
+                claude: false,
+                codex: false,
+                gemini: false,
+            },
+            description: None,
+            homepage: None,
+            docs: None,
+            tags: Vec::new(),
+        },
+    )
+    .expect("insert server without syncing");
+
+    // 启用 Codex：目录缺失时应跳过写入（不创建 ~/.codex/config.toml）
+    McpService::toggle_app(&state, "codex-server", AppType::Codex, true)
+        .expect("toggle codex should succeed even when ~/.codex is missing");
+
+    assert!(
+        !home.join(".codex").exists(),
+        "~/.codex should still not exist after skipped sync"
+    );
+}
+
+#[test]
+fn upsert_mcp_server_disabling_app_removes_from_claude_live_config() {
+    let _guard = test_mutex().lock().expect("acquire test mutex");
+    reset_test_fs();
+    let home = ensure_test_home();
+
+    // 模拟 Claude 已安装/已初始化：存在 ~/.claude 目录
+    fs::create_dir_all(home.join(".claude")).expect("create ~/.claude dir");
+
+    // 先创建一个启用 Claude 的 MCP 服务器
+    let state = support::create_test_state().expect("create test state");
+    McpService::upsert_server(
+        &state,
+        McpServer {
+            id: "echo".to_string(),
+            name: "echo".to_string(),
+            server: json!({
+                "type": "stdio",
+                "command": "echo"
+            }),
+            apps: McpApps {
+                claude: true,
+                codex: false,
+                gemini: false,
+            },
+            description: None,
+            homepage: None,
+            docs: None,
+            tags: Vec::new(),
+        },
+    )
+    .expect("upsert should sync to Claude live config");
+
+    // 确认已写入 ~/.claude.json
+    let mcp_path = get_claude_mcp_path();
+    let text = fs::read_to_string(&mcp_path).expect("read ~/.claude.json");
+    let v: serde_json::Value = serde_json::from_str(&text).expect("parse ~/.claude.json");
+    assert!(
+        v.pointer("/mcpServers/echo").is_some(),
+        "echo should exist in Claude live config after enabling"
+    );
+
+    // 再次 upsert：取消勾选 Claude（apps.claude=false），应从 Claude live 配置中移除
+    McpService::upsert_server(
+        &state,
+        McpServer {
+            id: "echo".to_string(),
+            name: "echo".to_string(),
+            server: json!({
+                "type": "stdio",
+                "command": "echo"
+            }),
+            apps: McpApps {
+                claude: false,
+                codex: false,
+                gemini: false,
+            },
+            description: None,
+            homepage: None,
+            docs: None,
+            tags: Vec::new(),
+        },
+    )
+    .expect("upsert disabling app should remove from Claude live config");
+
+    let text = fs::read_to_string(&mcp_path).expect("read ~/.claude.json after disable");
+    let v: serde_json::Value = serde_json::from_str(&text).expect("parse ~/.claude.json");
+    assert!(
+        v.pointer("/mcpServers/echo").is_none(),
+        "echo should be removed from Claude live config after disabling"
+    );
+}
+
+#[test]
+fn import_mcp_from_multiple_apps_merges_enabled_flags() {
+    let _guard = test_mutex().lock().expect("acquire test mutex");
+    reset_test_fs();
+    let home = ensure_test_home();
+
+    // 1) Claude: ~/.claude.json
+    let mcp_path = get_claude_mcp_path();
+    let claude_json = json!({
+        "mcpServers": {
+            "shared": {
+                "type": "stdio",
+                "command": "echo"
+            }
+        }
+    });
+    fs::write(
+        &mcp_path,
+        serde_json::to_string_pretty(&claude_json).expect("serialize claude mcp"),
+    )
+    .expect("seed ~/.claude.json");
+
+    // 2) Codex: ~/.codex/config.toml
+    let codex_dir = home.join(".codex");
+    fs::create_dir_all(&codex_dir).expect("create codex dir");
+    fs::write(
+        codex_dir.join("config.toml"),
+        r#"[mcp_servers.shared]
+type = "stdio"
+command = "echo"
+"#,
+    )
+    .expect("seed ~/.codex/config.toml");
+
+    let state = support::create_test_state().expect("create test state");
+
+    McpService::import_from_claude(&state).expect("import from claude");
+    McpService::import_from_codex(&state).expect("import from codex");
+
+    let servers = state.db.get_all_mcp_servers().expect("get all mcp servers");
+    let entry = servers.get("shared").expect("shared server exists");
+    assert!(entry.apps.claude, "shared should enable Claude");
+    assert!(entry.apps.codex, "shared should enable Codex");
+}
+
+#[test]
+fn import_mcp_from_gemini_sse_url_only_is_valid() {
+    let _guard = test_mutex().lock().expect("acquire test mutex");
+    reset_test_fs();
+    let home = ensure_test_home();
+
+    // Gemini MCP 位于 ~/.gemini/settings.json
+    let gemini_dir = home.join(".gemini");
+    fs::create_dir_all(&gemini_dir).expect("create gemini dir");
+    let settings_path = gemini_dir.join("settings.json");
+
+    // Gemini SSE：只包含 url（Gemini 不使用 type 字段）
+    let gemini_settings = json!({
+        "mcpServers": {
+            "sse-server": {
+                "url": "https://example.com/sse"
+            }
+        }
+    });
+    fs::write(
+        &settings_path,
+        serde_json::to_string_pretty(&gemini_settings).expect("serialize gemini settings"),
+    )
+    .expect("seed ~/.gemini/settings.json");
+
+    let state = support::create_test_state().expect("create test state");
+    let changed = McpService::import_from_gemini(&state).expect("import from gemini");
+    assert!(changed > 0, "should import at least 1 server");
+
+    let servers = state.db.get_all_mcp_servers().expect("get all mcp servers");
+    let entry = servers.get("sse-server").expect("sse-server exists");
+    assert!(entry.apps.gemini, "imported server should enable Gemini");
+    assert_eq!(
+        entry.server.get("type").and_then(|v| v.as_str()),
+        Some("sse"),
+        "Gemini url-only server should be normalized to type=sse in unified structure"
+    );
+}
+
+#[test]
+fn enabling_gemini_mcp_skips_when_gemini_dir_missing() {
+    use support::create_test_state;
+
+    let _guard = test_mutex().lock().expect("acquire test mutex");
+    reset_test_fs();
+    let home = ensure_test_home();
+
+    // 确认 Gemini 配置目录不存在（模拟“未安装/未运行过 Gemini CLI”）
+    assert!(
+        !home.join(".gemini").exists(),
+        "~/.gemini should not exist in fresh test environment"
+    );
+
+    let state = create_test_state().expect("create test state");
+
+    // 先插入一个未启用 Gemini 的 MCP 服务器（避免 upsert 触发同步）
+    McpService::upsert_server(
+        &state,
+        McpServer {
+            id: "gemini-server".to_string(),
+            name: "Gemini Server".to_string(),
+            server: json!({
+                "type": "sse",
+                "url": "https://example.com/sse"
+            }),
+            apps: McpApps {
+                claude: false,
+                codex: false,
+                gemini: false,
+            },
+            description: None,
+            homepage: None,
+            docs: None,
+            tags: Vec::new(),
+        },
+    )
+    .expect("insert server without syncing");
+
+    // 启用 Gemini：目录缺失时应跳过写入（不创建 ~/.gemini/settings.json）
+    McpService::toggle_app(&state, "gemini-server", AppType::Gemini, true)
+        .expect("toggle gemini should succeed even when ~/.gemini is missing");
+
+    assert!(
+        !home.join(".gemini").exists(),
+        "~/.gemini should still not exist after skipped sync"
+    );
+}
+
+#[test]
+fn enabling_claude_mcp_skips_when_claude_config_absent() {
+    use support::create_test_state;
+
+    let _guard = test_mutex().lock().expect("acquire test mutex");
+    reset_test_fs();
+    let home = ensure_test_home();
+
+    // 确认 Claude 相关目录/文件都不存在（模拟“未安装/未运行过 Claude”）
+    assert!(
+        !home.join(".claude").exists(),
+        "~/.claude should not exist in fresh test environment"
+    );
+    assert!(
+        !home.join(".claude.json").exists(),
+        "~/.claude.json should not exist in fresh test environment"
+    );
+
+    let state = create_test_state().expect("create test state");
+
+    // 先插入一个未启用 Claude 的 MCP 服务器（避免 upsert 触发同步）
+    McpService::upsert_server(
+        &state,
+        McpServer {
+            id: "claude-server".to_string(),
+            name: "Claude Server".to_string(),
+            server: json!({
+                "type": "stdio",
+                "command": "echo"
+            }),
+            apps: McpApps {
+                claude: false,
+                codex: false,
+                gemini: false,
+            },
+            description: None,
+            homepage: None,
+            docs: None,
+            tags: Vec::new(),
+        },
+    )
+    .expect("insert server without syncing");
+
+    // 启用 Claude：配置缺失时应跳过写入（不创建 ~/.claude.json）
+    McpService::toggle_app(&state, "claude-server", AppType::Claude, true)
+        .expect("toggle claude should succeed even when ~/.claude is missing");
+
+    assert!(
+        !home.join(".claude.json").exists(),
+        "~/.claude.json should still not exist after skipped sync"
+    );
+}
@@ -1,7 +1,9 @@
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex, OnceLock};

-use cc_switch_lib::{update_settings, AppSettings, AppState, Database, MultiAppConfig};
+use cc_switch_lib::{
+    update_settings, AppSettings, AppState, Database, MultiAppConfig, ProxyService,
+};

 /// 为测试设置隔离的 HOME 目录，避免污染真实用户数据。
 pub fn ensure_test_home() -> &'static Path {
@@ -48,15 +50,17 @@ pub fn test_mutex() -> &'static Mutex<()> {

 /// 创建测试用的 AppState，包含一个空的数据库
 pub fn create_test_state() -> Result<AppState, Box<dyn std::error::Error>> {
-    let db = Database::init()?;
-    Ok(AppState { db: Arc::new(db) })
+    let db = Arc::new(Database::init()?);
+    let proxy_service = ProxyService::new(db.clone());
+    Ok(AppState { db, proxy_service })
 }

 /// 创建测试用的 AppState，并从 MultiAppConfig 迁移数据
 pub fn create_test_state_with_config(
    config: &MultiAppConfig,
 ) -> Result<AppState, Box<dyn std::error::Error>> {
-    let db = Database::init()?;
+    let db = Arc::new(Database::init()?);
    db.migrate_from_json(config)?;
-    Ok(AppState { db: Arc::new(db) })
+    let proxy_service = ProxyService::new(db.clone());
+    Ok(AppState { db, proxy_service })
 }
@@ -1,7 +1,9 @@
 import { useEffect, useMemo, useState, useRef } from "react";
 import { useTranslation } from "react-i18next";
+import { motion, AnimatePresence } from "framer-motion";
 import { toast } from "sonner";
 import { invoke } from "@tauri-apps/api/core";
+import { useQueryClient } from "@tanstack/react-query";
 import {
  Plus,
  Settings,
@@ -23,6 +25,7 @@ import {
 } from "@/lib/api";
 import { checkAllEnvConflicts, checkEnvConflicts } from "@/lib/api/env";
 import { useProviderActions } from "@/hooks/useProviderActions";
+import { useProxyStatus } from "@/hooks/useProxyStatus";
 import { extractErrorMessage } from "@/utils/errorUtils";
 import { cn } from "@/lib/utils";
 import { AppSwitcher } from "@/components/AppSwitcher";
@@ -33,6 +36,7 @@ import { ConfirmDialog } from "@/components/ConfirmDialog";
 import { SettingsPage } from "@/components/settings/SettingsPage";
 import { UpdateBadge } from "@/components/UpdateBadge";
 import { EnvWarningBanner } from "@/components/env/EnvWarningBanner";
+import { ProxyToggle } from "@/components/proxy/ProxyToggle";
 import UsageScriptModal from "@/components/UsageScriptModal";
 import UnifiedMcpPanel from "@/components/mcp/UnifiedMcpPanel";
 import PromptPanel from "@/components/prompts/PromptPanel";
@@ -43,8 +47,13 @@ import { Button } from "@/components/ui/button";

 type View = "providers" | "settings" | "prompts" | "skills" | "mcp" | "agents";

+const DRAG_BAR_HEIGHT = 28; // px
+const HEADER_HEIGHT = 64; // px
+const CONTENT_TOP_OFFSET = DRAG_BAR_HEIGHT + HEADER_HEIGHT;
+
 function App() {
  const { t } = useTranslation();
+  const queryClient = useQueryClient();

  const [activeApp, setActiveApp] = useState<AppId>("claude");
  const [currentView, setCurrentView] = useState<View>("providers");
@@ -62,10 +71,30 @@ function App() {
  const addActionButtonClass =
    "bg-orange-500 hover:bg-orange-600 dark:bg-orange-500 dark:hover:bg-orange-600 text-white shadow-lg shadow-orange-500/30 dark:shadow-orange-500/40 rounded-full w-8 h-8";

-  const { data, isLoading, refetch } = useProvidersQuery(activeApp);
+  // 获取代理服务状态
+  const {
+    isRunning: isProxyRunning,
+    takeoverStatus,
+    status: proxyStatus,
+  } = useProxyStatus();
+  // 当前应用的代理是否开启
+  const isCurrentAppTakeoverActive = takeoverStatus?.[activeApp] || false;
+  // 当前应用代理实际使用的供应商 ID（从 active_targets 中获取）
+  const activeProviderId = useMemo(() => {
+    const target = proxyStatus?.active_targets?.find(
+      (t) => t.app_type === activeApp,
+    );
+    return target?.provider_id;
+  }, [proxyStatus?.active_targets, activeApp]);
+
+  // 获取供应商列表，当代理服务运行时自动刷新
+  const { data, isLoading, refetch } = useProvidersQuery(activeApp, {
+    isProxyRunning,
+  });
  const providers = useMemo(() => data?.providers ?? {}, [data]);
  const currentProviderId = data?.currentProviderId ?? "";
-  const isClaudeApp = activeApp === "claude";
+  // Skills 功能仅支持 Claude 和 Codex
+  const hasSkillsSupport = activeApp === "claude" || activeApp === "codex";

  // 🎯 使用 useProviderActions Hook 统一管理所有 Provider 操作
  const {
@@ -74,7 +103,6 @@ function App() {
    switchProvider,
    deleteProvider,
    saveUsageScript,
-    setProxyTarget,
  } = useProviderActions(activeApp);

  // 监听来自托盘菜单的切换事件
@@ -134,6 +162,7 @@ function App() {
        if (migrated) {
          toast.success(
            t("migration.success", { defaultValue: "配置迁移成功" }),
+            { closeButton: true },
          );
        }
      } catch (error) {
@@ -259,7 +288,20 @@ function App() {

  // 导入配置成功后刷新
  const handleImportSuccess = async () => {
-    await refetch();
+    try {
+      // 导入会影响所有应用的供应商数据：刷新所有 providers 缓存
+      await queryClient.invalidateQueries({
+        queryKey: ["providers"],
+        refetchType: "all",
+      });
+      await queryClient.refetchQueries({
+        queryKey: ["providers"],
+        type: "all",
+      });
+    } catch (error) {
+      console.error("[App] Failed to refresh providers after import", error);
+      await refetch();
+    }
    try {
      await providersApi.updateTrayMenu();
    } catch (error) {
@@ -268,77 +310,109 @@ function App() {
  };

  const renderContent = () => {
-    switch (currentView) {
-      case "settings":
-        return (
-          <SettingsPage
-            open={true}
-            onOpenChange={() => setCurrentView("providers")}
-            onImportSuccess={handleImportSuccess}
-          />
-        );
-      case "prompts":
-        return (
-          <PromptPanel
-            ref={promptPanelRef}
-            open={true}
-            onOpenChange={() => setCurrentView("providers")}
-            appId={activeApp}
-          />
-        );
-      case "skills":
-        return (
-          <SkillsPage
-            ref={skillsPageRef}
-            onClose={() => setCurrentView("providers")}
-          />
-        );
-      case "mcp":
-        return (
-          <UnifiedMcpPanel
-            ref={mcpPanelRef}
-            onOpenChange={() => setCurrentView("providers")}
-          />
-        );
-      case "agents":
-        return <AgentsPanel onOpenChange={() => setCurrentView("providers")} />;
-      default:
-        return (
-          <div className="mx-auto max-w-[56rem] px-5 flex flex-col h-[calc(100vh-8rem)] overflow-hidden">
-            {/* 独立滚动容器 - 解决 Linux/Ubuntu 下 DndContext 与滚轮事件冲突 */}
-            <div className="flex-1 overflow-y-auto overflow-x-hidden pb-12 px-1">
-              <div className="space-y-4">
-                <ProviderList
-                  providers={providers}
-                  currentProviderId={currentProviderId}
-                  appId={activeApp}
-                  isLoading={isLoading}
-                  onSwitch={switchProvider}
-                  onSetProxyTarget={setProxyTarget}
-                  onEdit={setEditingProvider}
-                  onDelete={setConfirmDelete}
-                  onDuplicate={handleDuplicateProvider}
-                  onConfigureUsage={setUsageProvider}
-                  onOpenWebsite={handleOpenWebsite}
-                  onCreate={() => setIsAddOpen(true)}
-                />
+    const content = (() => {
+      switch (currentView) {
+        case "settings":
+          return (
+            <SettingsPage
+              open={true}
+              onOpenChange={() => setCurrentView("providers")}
+              onImportSuccess={handleImportSuccess}
+            />
+          );
+        case "prompts":
+          return (
+            <PromptPanel
+              ref={promptPanelRef}
+              open={true}
+              onOpenChange={() => setCurrentView("providers")}
+              appId={activeApp}
+            />
+          );
+        case "skills":
+          return (
+            <SkillsPage
+              ref={skillsPageRef}
+              onClose={() => setCurrentView("providers")}
+              initialApp={activeApp}
+            />
+          );
+        case "mcp":
+          return (
+            <UnifiedMcpPanel
+              ref={mcpPanelRef}
+              onOpenChange={() => setCurrentView("providers")}
+            />
+          );
+        case "agents":
+          return (
+            <AgentsPanel onOpenChange={() => setCurrentView("providers")} />
+          );
+        default:
+          return (
+            <div className="mx-auto max-w-[56rem] px-5 flex flex-col h-[calc(100vh-8rem)] overflow-hidden">
+              {/* 独立滚动容器 - 解决 Linux/Ubuntu 下 DndContext 与滚轮事件冲突 */}
+              <div className="flex-1 overflow-y-auto overflow-x-hidden pb-12 px-1">
+                <AnimatePresence mode="wait">
+                  <motion.div
+                    key={activeApp}
+                    initial={{ opacity: 0 }}
+                    animate={{ opacity: 1 }}
+                    exit={{ opacity: 0 }}
+                    transition={{ duration: 0.15 }}
+                    className="space-y-4"
+                  >
+                    <ProviderList
+                      providers={providers}
+                      currentProviderId={currentProviderId}
+                      appId={activeApp}
+                      isLoading={isLoading}
+                      isProxyRunning={isProxyRunning}
+                      isProxyTakeover={
+                        isProxyRunning && isCurrentAppTakeoverActive
+                      }
+                      activeProviderId={activeProviderId}
+                      onSwitch={switchProvider}
+                      onEdit={setEditingProvider}
+                      onDelete={setConfirmDelete}
+                      onDuplicate={handleDuplicateProvider}
+                      onConfigureUsage={setUsageProvider}
+                      onOpenWebsite={handleOpenWebsite}
+                      onCreate={() => setIsAddOpen(true)}
+                    />
+                  </motion.div>
+                </AnimatePresence>
              </div>
            </div>
-          </div>
-        );
-    }
+          );
+      }
+    })();
+
+    return (
+      <AnimatePresence mode="wait">
+        <motion.div
+          key={currentView}
+          initial={{ opacity: 0 }}
+          animate={{ opacity: 1 }}
+          exit={{ opacity: 0 }}
+          transition={{ duration: 0.2 }}
+        >
+          {content}
+        </motion.div>
+      </AnimatePresence>
+    );
  };

  return (
    <div
-      className="flex min-h-screen flex-col bg-background text-foreground selection:bg-primary/30"
-      style={{ overflowX: "hidden" }}
+      className="flex flex-col h-screen overflow-hidden bg-background text-foreground selection:bg-primary/30"
+      style={{ overflowX: "hidden", paddingTop: CONTENT_TOP_OFFSET }}
    >
-      {/* 全局拖拽区域（顶部 4px），避免上边框无法拖动 */}
+      {/* 全局拖拽区域（顶部 28px），避免上边框无法拖动 */}
      <div
-        className="fixed top-0 left-0 right-0 h-4 z-[60]"
+        className="fixed top-0 left-0 right-0 z-[60]"
        data-tauri-drag-region
-        style={{ WebkitAppRegion: "drag" } as any}
+        style={{ WebkitAppRegion: "drag", height: DRAG_BAR_HEIGHT } as any}
      />
      {/* 环境变量警告横幅 */}
      {showEnvBanner && envConflicts.length > 0 && (
@@ -368,13 +442,18 @@ function App() {
      )}

      <header
-        className="glass-header fixed top-0 z-50 w-full py-3 transition-all duration-300"
+        className="fixed z-50 w-full transition-all duration-300 bg-background/80 backdrop-blur-md"
        data-tauri-drag-region
-        style={{ WebkitAppRegion: "drag" } as any}
+        style={
+          {
+            WebkitAppRegion: "drag",
+            top: DRAG_BAR_HEIGHT,
+            height: HEADER_HEIGHT,
+          } as any
+        }
      >
-        <div className="h-4 w-full" aria-hidden data-tauri-drag-region />
        <div
-          className="mx-auto max-w-[56rem] px-6 flex flex-wrap items-center justify-between gap-2"
+          className="mx-auto flex h-full max-w-[56rem] flex-wrap items-center justify-between gap-2 px-6"
          data-tauri-drag-region
          style={{ WebkitAppRegion: "drag" } as any}
        >
@@ -390,7 +469,7 @@ function App() {
                  onClick={() => setCurrentView("providers")}
                  className="mr-2 rounded-lg"
                >
-                  <ArrowLeft className="h-4 w-4" />
+                  <ArrowLeft className="w-4 h-4" />
                </Button>
                <h1 className="text-lg font-semibold">
                  {currentView === "settings" && t("settings.title")}
@@ -408,7 +487,12 @@ function App() {
                    href="https://github.com/farion1231/cc-switch"
                    target="_blank"
                    rel="noreferrer"
-                    className="text-xl font-semibold text-blue-500 transition-colors hover:text-blue-600 dark:text-blue-400 dark:hover:text-blue-300"
+                    className={cn(
+                      "text-xl font-semibold transition-colors",
+                      isProxyRunning && isCurrentAppTakeoverActive
+                        ? "text-emerald-500 hover:text-emerald-600 dark:text-emerald-400 dark:hover:text-emerald-300"
+                        : "text-blue-500 hover:text-blue-600 dark:text-blue-400 dark:hover:text-blue-300",
+                    )}
                  >
                    CC Switch
                  </a>
@@ -419,7 +503,7 @@ function App() {
                    title={t("common.settings")}
                    className="hover:bg-black/5 dark:hover:bg-white/5"
                  >
-                    <Settings className="h-4 w-4" />
+                    <Settings className="w-4 h-4" />
                  </Button>
                </div>
                <UpdateBadge onClick={() => setCurrentView("settings")} />
@@ -428,27 +512,27 @@ function App() {
          </div>

          <div
-            className="flex items-center gap-2"
+            className="flex items-center gap-2 min-h-[40px]"
            style={{ WebkitAppRegion: "no-drag" } as any}
          >
            {currentView === "prompts" && (
              <Button
                size="icon"
                onClick={() => promptPanelRef.current?.openAdd()}
-                className={addActionButtonClass}
+                className={`ml-auto ${addActionButtonClass}`}
                title={t("prompts.add")}
              >
-                <Plus className="h-5 w-5" />
+                <Plus className="w-5 h-5" />
              </Button>
            )}
            {currentView === "mcp" && (
              <Button
                size="icon"
                onClick={() => mcpPanelRef.current?.openAdd()}
-                className={addActionButtonClass}
+                className={`ml-auto ${addActionButtonClass}`}
                title={t("mcp.unifiedPanel.addServer")}
              >
-                <Plus className="h-5 w-5" />
+                <Plus className="w-5 h-5" />
              </Button>
            )}
            {currentView === "skills" && (
@@ -459,7 +543,7 @@ function App() {
                  onClick={() => skillsPageRef.current?.refresh()}
                  className="hover:bg-black/5 dark:hover:bg-white/5"
                >
-                  <RefreshCw className="h-4 w-4 mr-2" />
+                  <RefreshCw className="w-4 h-4 mr-2" />
                  {t("skills.refresh")}
                </Button>
                <Button
@@ -468,16 +552,18 @@ function App() {
                  onClick={() => skillsPageRef.current?.openRepoManager()}
                  className="hover:bg-black/5 dark:hover:bg-white/5"
                >
-                  <Settings className="h-4 w-4 mr-2" />
+                  <Settings className="w-4 h-4 mr-2" />
                  {t("skills.repoManager")}
                </Button>
              </>
            )}
            {currentView === "providers" && (
              <>
+                <ProxyToggle activeApp={activeApp} />
+
                <AppSwitcher activeApp={activeApp} onSwitch={setActiveApp} />

-                <div className="glass p-1 rounded-xl flex items-center gap-1">
+                <div className="flex items-center gap-1 p-1 bg-muted rounded-xl">
                  <Button
                    variant="ghost"
                    size="sm"
@@ -485,26 +571,26 @@ function App() {
                    className={cn(
                      "text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5",
                      "transition-all duration-200 ease-in-out overflow-hidden",
-                      isClaudeApp
+                      hasSkillsSupport
                        ? "opacity-100 w-8 scale-100 px-2"
                        : "opacity-0 w-0 scale-75 pointer-events-none px-0 -ml-1",
                    )}
                    title={t("skills.manage")}
                  >
-                    <Wrench className="h-4 w-4 flex-shrink-0" />
+                    <Wrench className="flex-shrink-0 w-4 h-4" />
                  </Button>
                  {/* TODO: Agents 功能开发中，暂时隐藏入口 */}
                  {/* {isClaudeApp && (
-                    <Button
-                      variant="ghost"
-                      size="sm"
-                      onClick={() => setCurrentView("agents")}
-                      className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
-                      title="Agents"
-                    >
-                      <Bot className="h-4 w-4" />
-                    </Button>
-                  )} */}
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        onClick={() => setCurrentView("agents")}
+                        className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
+                        title="Agents"
+                      >
+                        <Bot className="w-4 h-4" />
+                      </Button>
+                    )} */}
                  <Button
                    variant="ghost"
                    size="sm"
@@ -512,7 +598,7 @@ function App() {
                    className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
                    title={t("prompts.manage")}
                  >
-                    <Book className="h-4 w-4" />
+                    <Book className="w-4 h-4" />
                  </Button>
                  <Button
                    variant="ghost"
@@ -521,7 +607,7 @@ function App() {
                    className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
                    title={t("mcp.title")}
                  >
-                    <Server className="h-4 w-4" />
+                    <Server className="w-4 h-4" />
                  </Button>
                </div>

@@ -530,7 +616,7 @@ function App() {
                  size="icon"
                  className={`ml-2 ${addActionButtonClass}`}
                >
-                  <Plus className="h-5 w-5" />
+                  <Plus className="w-5 h-5" />
                </Button>
              </>
            )}
@@ -538,13 +624,12 @@ function App() {
        </div>
      </header>

-      <main
-        className={`flex-1 overflow-y-auto pb-12 animate-fade-in scroll-overlay ${
-          currentView === "providers" ? "pt-24" : "pt-20"
-        }`}
-        style={{ overflowX: "hidden" }}
-      >
-        {renderContent()}
+      <main className="flex-1 pb-12 animate-fade-in ">
+        <div
+          className={cn("pb-12", currentView === "providers" ? "pt-6" : "pt-4")}
+        >
+          {renderContent()}
+        </div>
      </main>

      <AddProviderDialog
@@ -564,6 +649,7 @@ function App() {
        }}
        onSubmit={handleEditProvider}
        appId={activeApp}
+        isProxyTakeover={isProxyRunning && isCurrentAppTakeoverActive}
      />

      {usageProvider && (
@@ -24,14 +24,14 @@ export function AppSwitcher({ activeApp, onSwitch }: AppSwitcherProps) {
  };

  return (
-    <div className="inline-flex bg-gray-100 dark:bg-gray-800 rounded-lg p-1 gap-1">
+    <div className="inline-flex bg-muted rounded-xl p-1 gap-1">
      <button
        type="button"
        onClick={() => handleSwitch("claude")}
-        className={`group inline-flex items-center gap-2 px-3 py-2 rounded-md text-sm font-medium transition-all duration-200 ${
+        className={`group inline-flex items-center gap-2 px-3 h-8 rounded-md text-sm font-medium transition-all duration-200 ${
          activeApp === "claude"
-            ? "bg-white text-gray-900 shadow-sm dark:bg-gray-900 dark:text-gray-100"
-            : "text-gray-500 hover:text-gray-900 hover:bg-white/50 dark:text-gray-400 dark:hover:text-gray-100 dark:hover:bg-gray-800/60"
+            ? "bg-background text-foreground shadow-sm"
+            : "text-muted-foreground hover:text-foreground hover:bg-background/50"
        }`}
      >
        <ProviderIcon
@@ -41,7 +41,7 @@ export function AppSwitcher({ activeApp, onSwitch }: AppSwitcherProps) {
          className={
            activeApp === "claude"
              ? "text-foreground"
-              : "text-gray-500 dark:text-gray-400 group-hover:text-foreground transition-colors"
+              : "text-muted-foreground group-hover:text-foreground transition-colors"
          }
        />
        <span>{appDisplayName.claude}</span>
@@ -50,10 +50,10 @@ export function AppSwitcher({ activeApp, onSwitch }: AppSwitcherProps) {
      <button
        type="button"
        onClick={() => handleSwitch("codex")}
-        className={`inline-flex items-center gap-2 px-3 py-2 rounded-md text-sm font-medium transition-all duration-200 ${
+        className={`group inline-flex items-center gap-2 px-3 h-8 rounded-md text-sm font-medium transition-all duration-200 ${
          activeApp === "codex"
-            ? "bg-white text-gray-900 shadow-sm dark:bg-gray-900 dark:text-gray-100"
-            : "text-gray-500 hover:text-gray-900 hover:bg-white/50 dark:text-gray-400 dark:hover:text-gray-100 dark:hover:bg-gray-800/60"
+            ? "bg-background text-foreground shadow-sm"
+            : "text-muted-foreground hover:text-foreground hover:bg-background/50"
        }`}
      >
        <ProviderIcon
@@ -63,7 +63,7 @@ export function AppSwitcher({ activeApp, onSwitch }: AppSwitcherProps) {
          className={
            activeApp === "codex"
              ? "text-foreground"
-              : "text-gray-500 dark:text-gray-400 group-hover:text-foreground transition-colors"
+              : "text-muted-foreground group-hover:text-foreground transition-colors"
          }
        />
        <span>{appDisplayName.codex}</span>
@@ -72,10 +72,10 @@ export function AppSwitcher({ activeApp, onSwitch }: AppSwitcherProps) {
      <button
        type="button"
        onClick={() => handleSwitch("gemini")}
-        className={`inline-flex items-center gap-2 px-3 py-2 rounded-md text-sm font-medium transition-all duration-200 ${
+        className={`group inline-flex items-center gap-2 px-3 h-8 rounded-md text-sm font-medium transition-all duration-200 ${
          activeApp === "gemini"
-            ? "bg-white text-gray-900 shadow-sm dark:bg-gray-900 dark:text-gray-100"
-            : "text-gray-500 hover:text-gray-900 hover:bg-white/50 dark:text-gray-400 dark:hover:text-gray-100 dark:hover:bg-gray-800/60"
+            ? "bg-background text-foreground shadow-sm"
+            : "text-muted-foreground hover:text-foreground hover:bg-background/50"
        }`}
      >
        <ProviderIcon
@@ -85,7 +85,7 @@ export function AppSwitcher({ activeApp, onSwitch }: AppSwitcherProps) {
          className={
            activeApp === "gemini"
              ? "text-foreground"
-              : "text-gray-500 dark:text-gray-400 group-hover:text-foreground transition-colors"
+              : "text-muted-foreground group-hover:text-foreground transition-colors"
          }
        />
        <span>{appDisplayName.gemini}</span>
@@ -128,6 +128,7 @@ export function DeepLinkImportDialog() {
            description: t("deeplink.mcpImportSuccessDescription", {
              count: summary.importedCount,
            }),
+            closeButton: true,
          });
        }
      };
@@ -142,6 +143,7 @@ export function DeepLinkImportDialog() {
            description: t("deeplink.importSuccessDescription", {
              name: request.name,
            }),
+            closeButton: true,
          });
        } else if (result.type === "prompt") {
          // Prompts don't use React Query, trigger a custom event for refresh
@@ -154,6 +156,7 @@ export function DeepLinkImportDialog() {
            description: t("deeplink.promptImportSuccessDescription", {
              name: request.name,
            }),
+            closeButton: true,
          });
        } else if (result.type === "mcp") {
          await refreshMcp(result);
@@ -171,6 +174,7 @@ export function DeepLinkImportDialog() {
            description: t("deeplink.skillImportSuccessDescription", {
              repo: request.repo,
            }),
+            closeButton: true,
          });
        }
      } else if (isMcpImportResult(result)) {
@@ -185,6 +189,7 @@ export function DeepLinkImportDialog() {
          description: t("deeplink.importSuccessDescription", {
            name: request.name,
          }),
+          closeButton: true,
        });
      }

@@ -605,6 +610,86 @@ export function DeepLinkImportDialog() {
                    </div>
                  )}

+                  {/* Usage Script Configuration (v3.9+) */}
+                  {request.usageScript && (
+                    <div className="space-y-3 pt-2 border-t border-border-default">
+                      <div className="grid grid-cols-3 items-center gap-4">
+                        <div className="font-medium text-sm text-muted-foreground">
+                          {t("deeplink.usageScript", {
+                            defaultValue: "用量查询",
+                          })}
+                        </div>
+                        <div className="col-span-2 text-sm">
+                          <span
+                            className={`inline-flex items-center px-2 py-0.5 rounded-md text-xs font-medium ${
+                              request.usageEnabled !== false
+                                ? "bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-300"
+                                : "bg-gray-100 dark:bg-gray-800 text-gray-600 dark:text-gray-400"
+                            }`}
+                          >
+                            {request.usageEnabled !== false
+                              ? t("deeplink.usageScriptEnabled", {
+                                  defaultValue: "已启用",
+                                })
+                              : t("deeplink.usageScriptDisabled", {
+                                  defaultValue: "未启用",
+                                })}
+                          </span>
+                        </div>
+                      </div>
+
+                      {/* Usage API Key (if different from provider) */}
+                      {request.usageApiKey &&
+                        request.usageApiKey !== request.apiKey && (
+                          <div className="grid grid-cols-3 items-center gap-4">
+                            <div className="font-medium text-sm text-muted-foreground">
+                              {t("deeplink.usageApiKey", {
+                                defaultValue: "用量 API Key",
+                              })}
+                            </div>
+                            <div className="col-span-2 text-sm font-mono text-muted-foreground">
+                              {request.usageApiKey.length > 4
+                                ? `${request.usageApiKey.substring(0, 4)}${"*".repeat(12)}`
+                                : "****"}
+                            </div>
+                          </div>
+                        )}
+
+                      {/* Usage Base URL (if different from provider) */}
+                      {request.usageBaseUrl &&
+                        request.usageBaseUrl !== request.endpoint && (
+                          <div className="grid grid-cols-3 items-center gap-4">
+                            <div className="font-medium text-sm text-muted-foreground">
+                              {t("deeplink.usageBaseUrl", {
+                                defaultValue: "用量查询地址",
+                              })}
+                            </div>
+                            <div className="col-span-2 text-sm break-all">
+                              {request.usageBaseUrl}
+                            </div>
+                          </div>
+                        )}
+
+                      {/* Auto Query Interval */}
+                      {request.usageAutoInterval &&
+                        request.usageAutoInterval > 0 && (
+                          <div className="grid grid-cols-3 items-center gap-4">
+                            <div className="font-medium text-sm text-muted-foreground">
+                              {t("deeplink.usageAutoInterval", {
+                                defaultValue: "自动查询",
+                              })}
+                            </div>
+                            <div className="col-span-2 text-sm">
+                              {t("deeplink.usageAutoIntervalValue", {
+                                defaultValue: "每 {{minutes}} 分钟",
+                                minutes: request.usageAutoInterval,
+                              })}
+                            </div>
+                          </div>
+                        )}
+                    </div>
+                  )}
+
                  {/* Warning */}
                  <div className="rounded-lg bg-yellow-50 dark:bg-yellow-900/20 p-3 text-sm text-yellow-800 dark:text-yellow-200">
                    {t("deeplink.warning")}
@@ -234,7 +234,9 @@ const JsonEditor: React.FC<JsonEditorProps> = ({
    try {
      const formatted = formatJSON(currentValue);
      onChange(formatted);
-      toast.success(t("common.formatSuccess", { defaultValue: "格式化成功" }));
+      toast.success(t("common.formatSuccess", { defaultValue: "格式化成功" }), {
+        closeButton: true,
+      });
    } catch (error) {
      const errorMessage =
        error instanceof Error ? error.message : String(error);
@@ -14,6 +14,7 @@ interface ProviderIconProps {
 export const ProviderIcon: React.FC<ProviderIconProps> = ({
  icon,
  name,
+  color,
  size = 32,
  className,
  showFallback = true,
@@ -46,7 +47,7 @@ export const ProviderIcon: React.FC<ProviderIconProps> = ({
          "inline-flex items-center justify-center flex-shrink-0",
          className,
        )}
-        style={sizeStyle}
+        style={{ ...sizeStyle, color }}
        dangerouslySetInnerHTML={{ __html: iconSvg }}
      />
    );
@@ -56,7 +56,7 @@ export function UpdateBadge({ className = "", onClick }: UpdateBadgeProps) {
        "
        aria-label={t("common.close")}
      >
-        <X className="w-3 h-3 text-gray-400 dark:text-gray-500" />
+        <X className="w-3 h-3 text-muted-foreground" />
      </button>
    </div>
  );
@@ -114,7 +114,7 @@ const UsageFooter: React.FC<UsageFooterProps> = ({
        {/* 第一行：更新时间和刷新按钮 */}
        <div className="flex items-center gap-2 justify-end">
          {/* 上次查询时间 */}
-          <span className="text-[10px] text-gray-400 dark:text-gray-500 flex items-center gap-1">
+          <span className="text-[10px] text-muted-foreground/70 flex items-center gap-1">
            <Clock size={10} />
            {lastQueriedAt
              ? formatRelativeTime(lastQueriedAt, now, t)
@@ -128,7 +128,7 @@ const UsageFooter: React.FC<UsageFooterProps> = ({
              refetch();
            }}
            disabled={loading}
-            className="p-1 rounded hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors disabled:opacity-50 flex-shrink-0 text-gray-400 dark:text-gray-500"
+            className="p-1 rounded hover:bg-muted transition-colors disabled:opacity-50 flex-shrink-0 text-muted-foreground"
            title={t("usage.refreshUsage")}
          >
            <RefreshCw size={12} className={loading ? "animate-spin" : ""} />
@@ -191,7 +191,7 @@ const UsageFooter: React.FC<UsageFooterProps> = ({
        <div className="flex items-center gap-2">
          {/* 自动查询时间提示 */}
          {lastQueriedAt && (
-            <span className="text-[10px] text-gray-400 dark:text-gray-500 flex items-center gap-1">
+            <span className="text-[10px] text-muted-foreground/70 flex items-center gap-1">
              <Clock size={10} />
              {formatRelativeTime(lastQueriedAt, now, t)}
            </span>
@@ -227,6 +227,7 @@ const UsageScriptModal: React.FC<UsageScriptModalProps> = ({
          .join(", ");
        toast.success(`${t("usageScript.testSuccess")}${summary}`, {
          duration: 3000,
+          closeButton: true,
        });
      } else {
        toast.error(
@@ -259,7 +260,10 @@ const UsageScriptModal: React.FC<UsageScriptModalProps> = ({
        printWidth: 80,
      });
      setScript({ ...script, code: formatted.trim() });
-      toast.success(t("usageScript.formatSuccess"), { duration: 1000 });
+      toast.success(t("usageScript.formatSuccess"), {
+        duration: 1000,
+        closeButton: true,
+      });
    } catch (error: any) {
      toast.error(
        `${t("usageScript.formatFailed")}: ${error?.message || t("jsonEditor.invalidJson")}`,
@@ -400,15 +404,25 @@ const UsageScriptModal: React.FC<UsageScriptModalProps> = ({
            {/* 凭证配置 */}
            {shouldShowCredentialsConfig && (
              <div className="space-y-4">
-                <h4 className="text-sm font-medium text-foreground">
-                  {t("usageScript.credentialsConfig")}
-                </h4>
+                <div className="flex items-start justify-between">
+                  <h4 className="text-sm font-medium text-foreground">
+                    {t("usageScript.credentialsConfig")}
+                  </h4>
+                  <p className="text-xs text-muted-foreground">
+                    {t("usageScript.credentialsHint")}
+                  </p>
+                </div>

                <div className="grid gap-4 md:grid-cols-2">
                  {selectedTemplate === TEMPLATE_KEYS.GENERAL && (
                    <>
                      <div className="space-y-2">
-                        <Label htmlFor="usage-api-key">API Key</Label>
+                        <Label htmlFor="usage-api-key">
+                          API Key{" "}
+                          <span className="text-xs text-muted-foreground font-normal">
+                            ({t("usageScript.optional")})
+                          </span>
+                        </Label>
                        <div className="relative">
                          <Input
                            id="usage-api-key"
@@ -417,7 +431,7 @@ const UsageScriptModal: React.FC<UsageScriptModalProps> = ({
                            onChange={(e) =>
                              setScript({ ...script, apiKey: e.target.value })
                            }
-                            placeholder="sk-xxxxx"
+                            placeholder={t("usageScript.apiKeyPlaceholder")}
                            autoComplete="off"
                            className="border-white/10"
                          />
@@ -444,7 +458,10 @@ const UsageScriptModal: React.FC<UsageScriptModalProps> = ({

                      <div className="space-y-2">
                        <Label htmlFor="usage-base-url">
-                          {t("usageScript.baseUrl")}
+                          {t("usageScript.baseUrl")}{" "}
+                          <span className="text-xs text-muted-foreground font-normal">
+                            ({t("usageScript.optional")})
+                          </span>
                        </Label>
                        <Input
                          id="usage-base-url"
@@ -453,7 +470,7 @@ const UsageScriptModal: React.FC<UsageScriptModalProps> = ({
                          onChange={(e) =>
                            setScript({ ...script, baseUrl: e.target.value })
                          }
-                          placeholder="https://api.example.com"
+                          placeholder={t("usageScript.baseUrlPlaceholder")}
                          autoComplete="off"
                          className="border-white/10"
                        />
@@ -1,5 +1,6 @@
 import React from "react";
 import { createPortal } from "react-dom";
+import { motion } from "framer-motion";
 import { ArrowLeft } from "lucide-react";
 import { Button } from "@/components/ui/button";

@@ -35,7 +36,10 @@ export const FullScreenPanel: React.FC<FullScreenPanelProps> = ({
  if (!isOpen) return null;

  return createPortal(
-    <div
+    <motion.div
+      initial={{ opacity: 0 }}
+      animate={{ opacity: 1 }}
+      transition={{ duration: 0.2 }}
      className="fixed inset-0 z-[60] flex flex-col"
      style={{ backgroundColor: "hsl(var(--background))" }}
    >
@@ -71,7 +75,7 @@ export const FullScreenPanel: React.FC<FullScreenPanelProps> = ({
          </div>
        </div>
      )}
-    </div>,
+    </motion.div>,
    document.body,
  );
 };
@@ -79,6 +79,7 @@ export function EnvWarningBanner({
          path: backupInfo.backupPath,
        }),
        duration: 5000,
+        closeButton: true,
      });

      // 清空选择并通知父组件
@@ -197,7 +198,7 @@ export function EnvWarningBanner({
                            <p className="text-xs text-gray-600 dark:text-gray-400 mt-1 break-all">
                              {t("env.field.value")}: {conflict.varValue}
                            </p>
-                            <p className="text-xs text-gray-500 dark:text-gray-500 mt-1">
+                            <p className="text-xs text-muted-foreground mt-1">
                              {t("env.field.source")}:{" "}
                              {getSourceDescription(conflict)}
                            </p>
@@ -391,7 +391,7 @@ const McpFormModal: React.FC<McpFormModalProps> = ({
      }

      await upsertMutation.mutateAsync(entry);
-      toast.success(t("common.success"));
+      toast.success(t("common.success"), { closeButton: true });
      await onSave();
    } catch (error: any) {
      const detail = extractErrorMessage(error);
@@ -99,7 +99,7 @@ const UnifiedMcpPanel = React.forwardRef<
        try {
          await deleteServerMutation.mutateAsync(id);
          setConfirmDialog(null);
-          toast.success(t("common.success"));
+          toast.success(t("common.success"), { closeButton: true });
        } catch (error) {
          toast.error(t("common.error"), {
            description: String(error),
@@ -129,18 +129,18 @@ const UnifiedMcpPanel = React.forwardRef<
      {/* Content - Scrollable */}
      <div className="flex-1 overflow-y-auto overflow-x-hidden pb-24">
        {isLoading ? (
-          <div className="text-center py-12 text-gray-500 dark:text-gray-400">
+          <div className="text-center py-12 text-muted-foreground">
            {t("mcp.loading")}
          </div>
        ) : serverEntries.length === 0 ? (
          <div className="text-center py-12">
-            <div className="w-16 h-16 mx-auto mb-4 bg-gray-100 dark:bg-gray-800 rounded-full flex items-center justify-center">
-              <Server size={24} className="text-gray-400 dark:text-gray-500" />
+            <div className="w-16 h-16 mx-auto mb-4 bg-muted rounded-full flex items-center justify-center">
+              <Server size={24} className="text-muted-foreground" />
            </div>
-            <h3 className="text-lg font-medium text-gray-900 dark:text-gray-100 mb-2">
+            <h3 className="text-lg font-medium text-foreground mb-2">
              {t("mcp.unifiedPanel.noServers")}
            </h3>
-            <p className="text-gray-500 dark:text-gray-400 text-sm">
+            <p className="text-muted-foreground text-sm">
              {t("mcp.emptyDescription")}
            </p>
          </div>
@@ -237,9 +237,7 @@ const UnifiedMcpListItem: React.FC<UnifiedMcpListItemProps> = ({
      {/* 左侧：服务器信息 */}
      <div className="flex-1 min-w-0">
        <div className="flex items-center gap-2 mb-1">
-          <h3 className="font-medium text-gray-900 dark:text-gray-100">
-            {name}
-          </h3>
+          <h3 className="font-medium text-foreground">{name}</h3>
          {docsUrl && (
            <Button
              type="button"
@@ -253,12 +251,12 @@ const UnifiedMcpListItem: React.FC<UnifiedMcpListItemProps> = ({
          )}
        </div>
        {description && (
-          <p className="text-sm text-gray-500 dark:text-gray-400 line-clamp-2">
+          <p className="text-sm text-muted-foreground line-clamp-2">
            {description}
          </p>
        )}
        {!description && tags && tags.length > 0 && (
-          <p className="text-xs text-gray-400 dark:text-gray-500 truncate">
+          <p className="text-xs text-muted-foreground/70 truncate">
            {tags.join(", ")}
          </p>
        )}
@@ -269,7 +267,7 @@ const UnifiedMcpListItem: React.FC<UnifiedMcpListItemProps> = ({
        <div className="flex items-center justify-between gap-3">
          <label
            htmlFor={`${id}-claude`}
-            className="text-sm text-gray-700 dark:text-gray-300 cursor-pointer"
+            className="text-sm text-foreground/80 cursor-pointer"
          >
            {t("mcp.unifiedPanel.apps.claude")}
          </label>
@@ -285,7 +283,7 @@ const UnifiedMcpListItem: React.FC<UnifiedMcpListItemProps> = ({
        <div className="flex items-center justify-between gap-3">
          <label
            htmlFor={`${id}-codex`}
-            className="text-sm text-gray-700 dark:text-gray-300 cursor-pointer"
+            className="text-sm text-foreground/80 cursor-pointer"
          >
            {t("mcp.unifiedPanel.apps.codex")}
          </label>
@@ -301,7 +299,7 @@ const UnifiedMcpListItem: React.FC<UnifiedMcpListItemProps> = ({
        <div className="flex items-center justify-between gap-3">
          <label
            htmlFor={`${id}-gemini`}
-            className="text-sm text-gray-700 dark:text-gray-300 cursor-pointer"
+            className="text-sm text-foreground/80 cursor-pointer"
          >
            {t("mcp.unifiedPanel.apps.gemini")}
          </label>
@@ -36,11 +36,9 @@ const PromptListItem: React.FC<PromptListItemProps> = ({
        </div>

        <div className="flex-1 min-w-0">
-          <h3 className="font-medium text-gray-900 dark:text-gray-100 mb-1">
-            {prompt.name}
-          </h3>
+          <h3 className="font-medium text-foreground mb-1">{prompt.name}</h3>
          {prompt.description && (
-            <p className="text-sm text-gray-500 dark:text-gray-400 truncate">
+            <p className="text-sm text-muted-foreground truncate">
              {prompt.description}
            </p>
          )}
@@ -108,21 +108,18 @@ const PromptPanel = React.forwardRef<PromptPanelHandle, PromptPanelProps>(

        <div className="flex-1 overflow-y-auto pb-16">
          {loading ? (
-            <div className="text-center py-12 text-gray-500 dark:text-gray-400">
+            <div className="text-center py-12 text-muted-foreground">
              {t("prompts.loading")}
            </div>
          ) : promptEntries.length === 0 ? (
            <div className="text-center py-12">
-              <div className="w-16 h-16 mx-auto mb-4 bg-gray-100 dark:bg-gray-800 rounded-full flex items-center justify-center">
-                <FileText
-                  size={24}
-                  className="text-gray-400 dark:text-gray-500"
-                />
+              <div className="w-16 h-16 mx-auto mb-4 bg-muted rounded-full flex items-center justify-center">
+                <FileText size={24} className="text-muted-foreground" />
              </div>
-              <h3 className="text-lg font-medium text-gray-900 dark:text-gray-100 mb-2">
+              <h3 className="text-lg font-medium text-foreground mb-2">
                {t("prompts.empty")}
              </h3>
-              <p className="text-gray-500 dark:text-gray-400 text-sm">
+              <p className="text-muted-foreground text-sm">
                {t("prompts.emptyDescription")}
              </p>
            </div>
@@ -16,6 +16,7 @@ interface EditProviderDialogProps {
  onOpenChange: (open: boolean) => void;
  onSubmit: (provider: Provider) => Promise<void> | void;
  appId: AppId;
+  isProxyTakeover?: boolean; // 代理接管模式下不读取 live（避免显示被接管后的代理配置）
 }

 export function EditProviderDialog({
@@ -24,6 +25,7 @@ export function EditProviderDialog({
  onOpenChange,
  onSubmit,
  appId,
+  isProxyTakeover = false,
 }: EditProviderDialogProps) {
  const { t } = useTranslation();

@@ -33,13 +35,33 @@ export function EditProviderDialog({
    unknown
  > | null>(null);

+  // 使用 ref 标记是否已经加载过，防止重复读取覆盖用户编辑
+  const [hasLoadedLive, setHasLoadedLive] = useState(false);
+
  useEffect(() => {
    let cancelled = false;
    const load = async () => {
      if (!open || !provider) {
        setLiveSettings(null);
+        setHasLoadedLive(false);
        return;
      }
+
+      // 关键修复：只在首次打开时加载一次
+      if (hasLoadedLive) {
+        return;
+      }
+
+      // 代理接管模式：Live 配置已被代理改写，读取 live 会导致编辑界面展示代理地址/占位符等内容
+      // 因此直接回退到 SSOT（数据库）配置，避免用户困惑与误保存
+      if (isProxyTakeover) {
+        if (!cancelled) {
+          setLiveSettings(null);
+          setHasLoadedLive(true);
+        }
+        return;
+      }
+
      try {
        const currentId = await providersApi.getCurrent(appId);
        if (currentId && provider.id === currentId) {
@@ -49,13 +71,20 @@ export function EditProviderDialog({
            )) as Record<string, unknown>;
            if (!cancelled && live && typeof live === "object") {
              setLiveSettings(live);
+              setHasLoadedLive(true);
            }
          } catch {
            // 读取实时配置失败则回退到 SSOT（不打断编辑流程）
-            if (!cancelled) setLiveSettings(null);
+            if (!cancelled) {
+              setLiveSettings(null);
+              setHasLoadedLive(true);
+            }
          }
        } else {
-          if (!cancelled) setLiveSettings(null);
+          if (!cancelled) {
+            setLiveSettings(null);
+            setHasLoadedLive(true);
+          }
        }
      } finally {
        // no-op
@@ -65,14 +94,33 @@ export function EditProviderDialog({
    return () => {
      cancelled = true;
    };
-  }, [open, provider, appId]);
+  }, [open, provider?.id, appId, hasLoadedLive, isProxyTakeover]); // 只依赖 provider.id，不依赖整个 provider 对象

  const initialSettingsConfig = useMemo(() => {
    return (liveSettings ?? provider?.settingsConfig ?? {}) as Record<
      string,
      unknown
    >;
-  }, [liveSettings, provider]);
+  }, [liveSettings, provider?.settingsConfig]); // 只依赖 settingsConfig，不依赖整个 provider
+
+  // 固定 initialData，防止 provider 对象更新时重置表单
+  const initialData = useMemo(() => {
+    if (!provider) return null;
+    return {
+      name: provider.name,
+      notes: provider.notes,
+      websiteUrl: provider.websiteUrl,
+      settingsConfig: initialSettingsConfig,
+      category: provider.category,
+      meta: provider.meta,
+      icon: provider.icon,
+      iconColor: provider.iconColor,
+    };
+  }, [
+    provider?.id, // 只依赖 ID，provider 对象更新不会触发重新计算
+    initialSettingsConfig,
+    // 注意：不依赖 provider 的其他字段，防止表单重置
+  ]);

  const handleSubmit = useCallback(
    async (values: ProviderFormValues) => {
@@ -104,7 +152,7 @@ export function EditProviderDialog({
    [onSubmit, onOpenChange, provider],
  );

-  if (!provider) {
+  if (!provider || !initialData) {
    return null;
  }

@@ -130,17 +178,7 @@ export function EditProviderDialog({
        submitLabel={t("common.save")}
        onSubmit={handleSubmit}
        onCancel={() => onOpenChange(false)}
-        initialData={{
-          name: provider.name,
-          notes: provider.notes,
-          websiteUrl: provider.websiteUrl,
-          // 若读取到实时配置则优先使用
-          settingsConfig: initialSettingsConfig,
-          category: provider.category,
-          meta: provider.meta,
-          icon: provider.icon,
-          iconColor: provider.iconColor,
-        }}
+        initialData={initialData}
        showButtons={false}
      />
    </FullScreenPanel>
@@ -0,0 +1,34 @@
+import { cn } from "@/lib/utils";
+import { useTranslation } from "react-i18next";
+
+interface FailoverPriorityBadgeProps {
+  priority: number; // 1, 2, 3, ...
+  className?: string;
+}
+
+/**
+ * 故障转移优先级徽章
+ * 显示供应商在故障转移队列中的优先级顺序
+ */
+export function FailoverPriorityBadge({
+  priority,
+  className,
+}: FailoverPriorityBadgeProps) {
+  const { t } = useTranslation();
+
+  return (
+    <div
+      className={cn(
+        "inline-flex items-center px-1.5 py-0.5 rounded text-xs font-semibold",
+        "bg-emerald-500/10 text-emerald-600 dark:text-emerald-400",
+        className,
+      )}
+      title={t("failover.priority.tooltip", {
+        priority,
+        defaultValue: `故障转移优先级 ${priority}`,
+      })}
+    >
+      P{priority}
+    </div>
+  );
+}
@@ -0,0 +1,51 @@
+import React from "react";
+import { cn } from "@/lib/utils";
+import type { HealthStatus } from "@/lib/api/model-test";
+import { useTranslation } from "react-i18next";
+
+interface HealthStatusIndicatorProps {
+  status: HealthStatus;
+  responseTimeMs?: number;
+  className?: string;
+}
+
+const statusConfig = {
+  operational: {
+    color: "bg-emerald-500",
+    labelKey: "health.operational",
+    labelFallback: "正常",
+    textColor: "text-emerald-600 dark:text-emerald-400",
+  },
+  degraded: {
+    color: "bg-yellow-500",
+    labelKey: "health.degraded",
+    labelFallback: "降级",
+    textColor: "text-yellow-600 dark:text-yellow-400",
+  },
+  failed: {
+    color: "bg-red-500",
+    labelKey: "health.failed",
+    labelFallback: "失败",
+    textColor: "text-red-600 dark:text-red-400",
+  },
+};
+
+export const HealthStatusIndicator: React.FC<HealthStatusIndicatorProps> = ({
+  status,
+  responseTimeMs,
+  className,
+}) => {
+  const { t } = useTranslation();
+  const config = statusConfig[status];
+  const label = t(config.labelKey, { defaultValue: config.labelFallback });
+
+  return (
+    <div className={cn("flex items-center gap-2", className)}>
+      <div className={cn("w-2 h-2 rounded-full", config.color)} />
+      <span className={cn("text-xs font-medium", config.textColor)}>
+        {label}
+        {responseTimeMs !== undefined && ` (${responseTimeMs}ms)`}
+      </span>
+    </div>
+  );
+};
@@ -5,6 +5,7 @@ import {
  Edit,
  Loader2,
  Play,
+  Plus,
  TestTube2,
  Trash2,
 } from "lucide-react";
@@ -15,51 +16,111 @@ import { cn } from "@/lib/utils";
 interface ProviderActionsProps {
  isCurrent: boolean;
  isTesting?: boolean;
+  isProxyTakeover?: boolean;
  onSwitch: () => void;
  onEdit: () => void;
  onDuplicate: () => void;
  onTest?: () => void;
  onConfigureUsage: () => void;
  onDelete: () => void;
+  // 故障转移相关
+  isAutoFailoverEnabled?: boolean;
+  isInFailoverQueue?: boolean;
+  onToggleFailover?: (enabled: boolean) => void;
 }

 export function ProviderActions({
  isCurrent,
  isTesting,
+  isProxyTakeover = false,
  onSwitch,
  onEdit,
  onDuplicate,
  onTest,
  onConfigureUsage,
  onDelete,
+  // 故障转移相关
+  isAutoFailoverEnabled = false,
+  isInFailoverQueue = false,
+  onToggleFailover,
 }: ProviderActionsProps) {
  const { t } = useTranslation();
  const iconButtonClass = "h-8 w-8 p-1";

+  // 故障转移模式下的按钮逻辑
+  const isFailoverMode = isAutoFailoverEnabled && onToggleFailover;
+
+  // 处理主按钮点击
+  const handleMainButtonClick = () => {
+    if (isFailoverMode) {
+      // 故障转移模式：切换队列状态
+      onToggleFailover(!isInFailoverQueue);
+    } else {
+      // 普通模式：切换供应商
+      onSwitch();
+    }
+  };
+
+  // 主按钮的状态和样式
+  const getMainButtonState = () => {
+    if (isFailoverMode) {
+      // 故障转移模式
+      if (isInFailoverQueue) {
+        return {
+          disabled: false,
+          variant: "secondary" as const,
+          className:
+            "bg-blue-100 text-blue-600 hover:bg-blue-200 dark:bg-blue-900/50 dark:text-blue-400 dark:hover:bg-blue-900/70",
+          icon: <Check className="h-4 w-4" />,
+          text: t("failover.inQueue", { defaultValue: "已加入" }),
+        };
+      }
+      return {
+        disabled: false,
+        variant: "default" as const,
+        className:
+          "bg-blue-500 hover:bg-blue-600 dark:bg-blue-600 dark:hover:bg-blue-700",
+        icon: <Plus className="h-4 w-4" />,
+        text: t("failover.addQueue", { defaultValue: "加入" }),
+      };
+    }
+
+    // 普通模式
+    if (isCurrent) {
+      return {
+        disabled: true,
+        variant: "secondary" as const,
+        className:
+          "bg-gray-200 text-muted-foreground hover:bg-gray-200 hover:text-muted-foreground dark:bg-gray-700 dark:hover:bg-gray-700",
+        icon: <Check className="h-4 w-4" />,
+        text: t("provider.inUse"),
+      };
+    }
+
+    return {
+      disabled: false,
+      variant: "default" as const,
+      className: isProxyTakeover
+        ? "bg-emerald-500 hover:bg-emerald-600 dark:bg-emerald-600 dark:hover:bg-emerald-700"
+        : "",
+      icon: <Play className="h-4 w-4" />,
+      text: t("provider.enable"),
+    };
+  };
+
+  const buttonState = getMainButtonState();
+
  return (
    <div className="flex items-center gap-1.5">
      <Button
        size="sm"
-        variant={isCurrent ? "secondary" : "default"}
-        onClick={onSwitch}
-        disabled={isCurrent}
-        className={cn(
-          "w-[4.5rem] px-2.5",
-          isCurrent &&
-            "bg-gray-200 text-muted-foreground hover:bg-gray-200 hover:text-muted-foreground dark:bg-gray-700 dark:hover:bg-gray-700",
-        )}
+        variant={buttonState.variant}
+        onClick={handleMainButtonClick}
+        disabled={buttonState.disabled}
+        className={cn("w-[4.5rem] px-2.5", buttonState.className)}
      >
-        {isCurrent ? (
-          <>
-            <Check className="h-4 w-4" />
-            {t("provider.inUse")}
-          </>
-        ) : (
-          <>
-            <Play className="h-4 w-4" />
-            {t("provider.enable")}
-          </>
-        )}
+        {buttonState.icon}
+        {buttonState.text}
      </Button>

      <div className="flex items-center gap-1">
@@ -1,5 +1,5 @@
-import { useMemo } from "react";
-import { GripVertical } from "lucide-react";
+import { useMemo, useState, useEffect } from "react";
+import { GripVertical, ChevronDown, ChevronUp } from "lucide-react";
 import { useTranslation } from "react-i18next";
 import type {
  DraggableAttributes,
@@ -11,8 +11,10 @@ import { cn } from "@/lib/utils";
 import { ProviderActions } from "@/components/providers/ProviderActions";
 import { ProviderIcon } from "@/components/ProviderIcon";
 import UsageFooter from "@/components/UsageFooter";
-import { Switch } from "@/components/ui/switch";
-import { Label } from "@/components/ui/label";
+import { ProviderHealthBadge } from "@/components/providers/ProviderHealthBadge";
+import { FailoverPriorityBadge } from "@/components/providers/FailoverPriorityBadge";
+import { useProviderHealth } from "@/lib/query/failover";
+import { useUsageQuery } from "@/lib/query/queries";

 interface DragHandleProps {
  attributes: DraggableAttributes;
@@ -32,9 +34,15 @@ interface ProviderCardProps {
  onDuplicate: (provider: Provider) => void;
  onTest?: (provider: Provider) => void;
  isTesting?: boolean;
-  onSetProxyTarget: (provider: Provider) => void;
  isProxyRunning: boolean;
+  isProxyTakeover?: boolean; // 代理接管模式（Live配置已被接管，切换为热切换）
  dragHandleProps?: DragHandleProps;
+  // 故障转移相关
+  isAutoFailoverEnabled?: boolean; // 是否开启自动故障转移
+  failoverPriority?: number; // 故障转移优先级（1 = P1, 2 = P2, ...）
+  isInFailoverQueue?: boolean; // 是否在故障转移队列中
+  onToggleFailover?: (enabled: boolean) => void; // 切换故障转移队列
+  activeProviderId?: string; // 代理当前实际使用的供应商 ID（用于故障转移模式下标注绿色边框）
 }

 const extractApiUrl = (provider: Provider, fallbackText: string) => {
@@ -84,12 +92,21 @@ export function ProviderCard({
  onDuplicate,
  onTest,
  isTesting,
-  onSetProxyTarget,
  isProxyRunning,
+  isProxyTakeover = false,
  dragHandleProps,
+  // 故障转移相关
+  isAutoFailoverEnabled = false,
+  failoverPriority,
+  isInFailoverQueue = false,
+  onToggleFailover,
+  activeProviderId,
 }: ProviderCardProps) {
  const { t } = useTranslation();

+  // 获取供应商健康状态
+  const { data: health } = useProviderHealth(provider.id, appId);
+
  const fallbackUrlText = t("provider.notConfigured", {
    defaultValue: "未配置接口地址",
  });
@@ -114,6 +131,29 @@ export function ProviderCard({

  const usageEnabled = provider.meta?.usage_script?.enabled ?? false;

+  // 获取用量数据以判断是否有多套餐
+  const autoQueryInterval = isCurrent
+    ? provider.meta?.usage_script?.autoQueryInterval || 0
+    : 0;
+
+  const { data: usage } = useUsageQuery(provider.id, appId, {
+    enabled: usageEnabled,
+    autoQueryInterval,
+  });
+
+  const hasMultiplePlans =
+    usage?.success && usage.data && usage.data.length > 1;
+
+  // 多套餐默认展开
+  const [isExpanded, setIsExpanded] = useState(false);
+
+  // 当检测到多套餐时自动展开
+  useEffect(() => {
+    if (hasMultiplePlans) {
+      setIsExpanded(true);
+    }
+  }, [hasMultiplePlans]);
+
  const handleOpenWebsite = () => {
    if (!isClickableUrl) {
      return;
@@ -121,17 +161,46 @@ export function ProviderCard({
    onOpenWebsite(displayUrl);
  };

+  // 判断是否是"当前使用中"的供应商
+  // - 故障转移模式：代理实际使用的供应商（activeProviderId）
+  // - 代理接管模式（非故障转移）：isCurrent
+  // - 普通模式：isCurrent
+  const isActiveProvider = isAutoFailoverEnabled
+    ? activeProviderId === provider.id
+    : isCurrent;
+
+  // 判断是否使用绿色（代理接管模式）还是蓝色（普通模式）
+  const shouldUseGreen = isProxyTakeover && isActiveProvider;
+  const shouldUseBlue = !isProxyTakeover && isActiveProvider;
+
  return (
    <div
      className={cn(
-        "glass-card relative overflow-hidden rounded-xl p-4 transition-all duration-300",
-        "group hover:bg-black/[0.02] dark:hover:bg-white/[0.02] hover:border-primary/50",
-        isCurrent ? "glass-card-active" : "hover:scale-[1.01]",
+        "relative overflow-hidden rounded-xl border border-border p-4 transition-all duration-300",
+        "bg-card text-card-foreground group",
+        // hover 时的边框效果
+        isAutoFailoverEnabled || isProxyTakeover
+          ? "hover:border-emerald-500/50"
+          : "hover:border-border-active",
+        // 当前激活的供应商边框样式
+        shouldUseGreen &&
+          "border-emerald-500/60 shadow-sm shadow-emerald-500/10",
+        shouldUseBlue && "border-blue-500/60 shadow-sm shadow-blue-500/10",
+        !isActiveProvider && "hover:shadow-sm",
        dragHandleProps?.isDragging &&
          "cursor-grabbing border-primary shadow-lg scale-105 z-10",
      )}
    >
-      <div className="absolute inset-0 bg-gradient-to-r from-primary/10 to-transparent opacity-0 group-hover:opacity-100 transition-opacity duration-500 pointer-events-none" />
+      <div
+        className={cn(
+          "absolute inset-0 bg-gradient-to-r to-transparent transition-opacity duration-500 pointer-events-none",
+          // 代理接管模式使用绿色渐变，普通模式使用蓝色渐变
+          shouldUseGreen && "from-emerald-500/10",
+          shouldUseBlue && "from-blue-500/10",
+          !isActiveProvider && "from-primary/10",
+          isActiveProvider ? "opacity-100" : "opacity-0",
+        )}
+      />
      <div className="relative flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
        <div className="flex flex-1 items-center gap-2">
          <button
@@ -149,7 +218,7 @@ export function ProviderCard({
          </button>

          {/* 供应商图标 */}
-          <div className="h-8 w-8 rounded-lg bg-white/5 flex items-center justify-center border border-gray-200 dark:border-white/10 group-hover:scale-105 transition-transform duration-300">
+          <div className="h-8 w-8 rounded-lg bg-muted flex items-center justify-center border border-border group-hover:scale-105 transition-transform duration-300">
            <ProviderIcon
              icon={provider.icon}
              name={provider.name}
@@ -159,10 +228,25 @@ export function ProviderCard({
          </div>

          <div className="space-y-1">
-            <div className="flex flex-wrap items-center gap-2 min-h-[20px]">
+            <div className="flex flex-wrap items-center gap-2 min-h-7">
              <h3 className="text-base font-semibold leading-none">
                {provider.name}
              </h3>
+
+              {/* 健康状态徽章 */}
+              {isProxyRunning && isInFailoverQueue && health && (
+                <ProviderHealthBadge
+                  consecutiveFailures={health.consecutive_failures}
+                />
+              )}
+
+              {/* 故障转移优先级徽章 */}
+              {isAutoFailoverEnabled &&
+                isInFailoverQueue &&
+                failoverPriority && (
+                  <FailoverPriorityBadge priority={failoverPriority} />
+                )}
+
              {provider.category === "third_party" &&
                provider.meta?.isPartner && (
                  <span
@@ -174,44 +258,6 @@ export function ProviderCard({
                    ⭐
                  </span>
                )}
-
-              {/* 代理目标开关 - 仅在代理服务运行时显示 */}
-              {isProxyRunning && (
-                <div
-                  className="flex items-center gap-2 ml-2"
-                  onClick={(e) => e.stopPropagation()}
-                >
-                  <Switch
-                    id={`proxy-target-switch-${provider.id}`}
-                    checked={provider.isProxyTarget || false}
-                    onCheckedChange={(checked) => {
-                      if (checked && !provider.isProxyTarget) {
-                        onSetProxyTarget(provider);
-                      }
-                    }}
-                    disabled={provider.isProxyTarget}
-                    className="scale-75 data-[state=checked]:bg-purple-500"
-                  />
-                  {provider.isProxyTarget && (
-                    <Label
-                      htmlFor={`proxy-target-switch-${provider.id}`}
-                      className="text-xs font-medium text-purple-500 dark:text-purple-400 cursor-pointer"
-                    >
-                      {t("provider.proxyTarget", { defaultValue: "代理目标" })}
-                    </Label>
-                  )}
-                  {!provider.isProxyTarget && (
-                    <Label
-                      htmlFor={`proxy-target-switch-${provider.id}`}
-                      className="text-xs text-muted-foreground cursor-pointer opacity-0 group-hover:opacity-100 transition-opacity"
-                    >
-                      {t("provider.setAsProxyTarget", {
-                        defaultValue: "设为代理",
-                      })}
-                    </Label>
-                  )}
-                </div>
-              )}
            </div>

            {displayUrl && (
@@ -233,32 +279,88 @@ export function ProviderCard({
          </div>
        </div>

-        <div className="relative flex items-center ml-auto">
-          <div className="ml-auto transition-transform duration-200 group-hover:-translate-x-[12.25rem] group-focus-within:-translate-x-[12.25rem] sm:group-hover:-translate-x-[14.25rem] sm:group-focus-within:-translate-x-[14.25rem]">
-            <UsageFooter
-              provider={provider}
-              providerId={provider.id}
-              appId={appId}
-              usageEnabled={usageEnabled}
-              isCurrent={isCurrent}
-              inline={true}
-            />
+        <div className="relative flex items-center ml-auto min-w-0">
+          {/* 用量信息区域 - hover 时向左移动，为操作按钮腾出空间 */}
+          <div className="ml-auto transition-transform duration-200 group-hover:-translate-x-[14.5rem] group-focus-within:-translate-x-[14.5rem] sm:group-hover:-translate-x-[16rem] sm:group-focus-within:-translate-x-[16rem]">
+            <div className="flex items-center gap-1">
+              {/* 多套餐时显示套餐数量，单套餐时显示详细信息 */}
+              {hasMultiplePlans ? (
+                <div className="flex items-center gap-2 text-xs text-gray-600 dark:text-gray-400">
+                  <span className="font-medium">
+                    {t("usage.multiplePlans", {
+                      count: usage?.data?.length || 0,
+                      defaultValue: `${usage?.data?.length || 0} 个套餐`,
+                    })}
+                  </span>
+                </div>
+              ) : (
+                <UsageFooter
+                  provider={provider}
+                  providerId={provider.id}
+                  appId={appId}
+                  usageEnabled={usageEnabled}
+                  isCurrent={isCurrent}
+                  inline={true}
+                />
+              )}
+              {/* 展开/折叠按钮 - 仅在有多套餐时显示 */}
+              {hasMultiplePlans && (
+                <button
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    setIsExpanded(!isExpanded);
+                  }}
+                  className="p-1 rounded hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors text-gray-500 dark:text-gray-400 flex-shrink-0"
+                  title={
+                    isExpanded
+                      ? t("usage.collapse", { defaultValue: "收起" })
+                      : t("usage.expand", { defaultValue: "展开" })
+                  }
+                >
+                  {isExpanded ? (
+                    <ChevronUp size={14} />
+                  ) : (
+                    <ChevronDown size={14} />
+                  )}
+                </button>
+              )}
+            </div>
          </div>

+          {/* 操作按钮区域 - 绝对定位在右侧，hover 时滑入 */}
          <div className="absolute right-0 top-1/2 -translate-y-1/2 flex items-center gap-1.5 opacity-0 pointer-events-none group-hover:opacity-100 group-focus-within:opacity-100 group-hover:pointer-events-auto group-focus-within:pointer-events-auto transition-all duration-200 translate-x-2 group-hover:translate-x-0 group-focus-within:translate-x-0">
            <ProviderActions
              isCurrent={isCurrent}
              isTesting={isTesting}
+              isProxyTakeover={isProxyTakeover}
              onSwitch={() => onSwitch(provider)}
              onEdit={() => onEdit(provider)}
              onDuplicate={() => onDuplicate(provider)}
              onTest={onTest ? () => onTest(provider) : undefined}
              onConfigureUsage={() => onConfigureUsage(provider)}
              onDelete={() => onDelete(provider)}
+              // 故障转移相关
+              isAutoFailoverEnabled={isAutoFailoverEnabled}
+              isInFailoverQueue={isInFailoverQueue}
+              onToggleFailover={onToggleFailover}
            />
          </div>
        </div>
      </div>
+
+      {/* 展开的完整套餐列表 */}
+      {isExpanded && hasMultiplePlans && (
+        <div className="mt-4 pt-4 border-t border-border-default">
+          <UsageFooter
+            provider={provider}
+            providerId={provider.id}
+            appId={appId}
+            usageEnabled={usageEnabled}
+            isCurrent={isCurrent}
+            inline={false}
+          />
+        </div>
+      )}
    </div>
  );
 }
@@ -10,7 +10,7 @@ export function ProviderEmptyState({ onCreate }: ProviderEmptyStateProps) {
  const { t } = useTranslation();

  return (
-    <div className="flex flex-col items-center justify-center rounded-lg border border-dashed border-muted-foreground/30 p-10 text-center">
+    <div className="flex flex-col items-center justify-center rounded-lg border border-dashed border-border p-10 text-center">
      <div className="mb-4 flex h-16 w-16 items-center justify-center rounded-full bg-muted">
        <Users className="h-7 w-7 text-muted-foreground" />
      </div>
--- a/Show More
+++ b/Show More