refactor: 简化模型管理，移除启用/禁用，优化测试和布局

- 移除供应商/模型启用禁用能力，清理DB schema/migration/API/前端 - 供应商测试改为Base URL连通性+/models探测 - 新增POST /api/models/test模型连接测试 - 新增GET /api/providers/options专用供应商选项接口 - 统一工具栏为ModelsToolbar，参考项目管理布局 - 模型弹窗优化：默认能力、响应式3列标签、并排数值 - 前后端正整数校验、供应商下拉loading/error/empty状态 - 表格列宽统一，操作列/名称列固定宽度
docs: 新增代码审查提示词
2026-05-29 18:03:33 +08:00 · 2026-05-29 14:31:24 +08:00 · 2026-05-29 14:05:01 +08:00
50 changed files with 1455 additions and 1202 deletions
--- a/docs/README.md
+++ b/docs/README.md
@@ -24,6 +24,7 @@ docs/
    prompt-smart-merge.md
    prompt-proposal-review.md
    prompt-apply-review.md
+    prompt-code-review.md
 ```

 `docs/prompts/` 是提示词资产目录，不属于常规开发流程和用户使用文档。代码、配置或部署变更不需要更新该目录，除非任务明确要求维护提示词资产。
--- a/docs/development/README.md
+++ b/docs/development/README.md
@@ -27,6 +27,7 @@
 | `bun run typecheck`              | TypeScript 类型检查                    |
 | `bun run lint`                   | ESLint 和 Prettier 格式检查            |
 | `bun run format`                 | Prettier 自动格式化                    |
+| `bun run format:check`           | Prettier 格式检查                      |
 | `bun test`                       | 运行全部测试                           |
 | `bun run check`                  | schema:check + typecheck + lint + test |
 | `bun run build`                  | 构建生产可执行文件                     |
--- a/docs/development/backend.md
+++ b/docs/development/backend.md
@@ -74,16 +74,25 @@ middleware.ts 提供 API 参数校验函数：

 - `AIProviderConfig` — 供应商配置（name、type、baseUrl、apiKey）
 - `AIModelConfig` — 模型配置（providerId、modelId、capabilities）
- `AIRegistryConfig` — Registry 构建配置（providers、models）
+- `AIRegistryConfig` — Registry 构建配置（providers、models），供后续 AI 调用层组合使用

 ### Registry 构建

 `src/server/ai/registry.ts` 提供：

- `buildProviderRegistry(db)` — 从 DB 查询启用的供应商，构建 Vercel AI SDK Provider Registry
- `testProviderConnection(config)` — 使用 generateText 测试供应商连接
+- `buildProviderRegistry(db)` — 从 DB 查询所有供应商，构建 Vercel AI SDK Provider Registry
+- `testProviderConnection(config)` — 先测试 Base URL 可达性，再请求 `/models` 验证 API Key 和模型列表接口

-每次 AI 调用时从 DB 查询 providers，构建 registry 后通过 `registry.languageModel('providerId:modelId')` 获取模型实例。不使用缓存层。
+每次 AI 调用时从 DB 查询 providers，构建 registry 后通过 `registry.languageModel('providerId:modelId')` 获取模型实例。不使用缓存层。模型是否存在以及业务能力标签由调用方基于 models 表先行校验，registry 只负责将 providerId/modelId 映射到 AI SDK 模型实例。
+
+### 供应商连通性测试
+
+供应商连通性测试返回 `{ providerTestResponse: { ok, message } }`，前端根据 `ok` 展示成功或失败提示。
+
+- `POST /api/providers/test` — 使用表单中尚未保存的供应商配置测试连接
+- `POST /api/models/test` — 使用模型关联供应商配置和 modelId 测试模型连接
+
+测试连接不会写入数据库，也不会阻止保存。Base URL 不可达或 API Key 无效返回 `ok: false`；Base URL 可达但 `/models` 不支持、非标准或返回非鉴权错误时返回 `ok: true` 并在 `message` 中提示用户可检查 URL 或忽略提醒。

 ### 支持的供应商类型

--- a/docs/development/frontend.md
+++ b/docs/development/frontend.md
@@ -131,6 +131,10 @@ Sidebar（`src/web/components/Sidebar/index.tsx`）是纯展示/导航组件，

 Workbench 项目上下文通过 `ProjectContext` 提供，在 `WorkbenchProjectGate` 中从 URL path param 读取 `projectId`，通过 `useProject(projectId)` 加载项目，仅 active 项目渲染工作台布局，不存在或 archived 项目显示"项目不存在或不可访问"。

+模型管理页面（`src/web/pages/models/index.tsx`）属于 Admin 路由 `/models`，通过 antd `Tabs` 在同页组织供应商和模型两个视图。页面使用 `ModelsToolbar`、`ProviderTable`、`ProviderFormModal`、`ModelTable`、`ModelFormModal` 拆分筛选、表格和表单职责；模型表单和模型表格必须使用 `GET /api/providers/options` 获取最小供应商选项，不能复用供应商标签页当前分页或搜索结果作为全量选项。
+
+供应商表单必须支持未保存配置的连通性测试，新建供应商时 type 默认 `openai-compatible`，baseURL 不设默认值。连通性测试返回 `ok: false` 时应展示失败反馈，不得使用成功提示样式；`/models` 不支持或响应格式不兼容属于可忽略提醒，不得阻止保存。
+
 - 生产入口必须启用 `ErrorBoundary`，运行时渲染异常使用 antd `Result status="500"` 或等价组件展示。
 - `ReactQueryDevtools` 仅在 `import.meta.env.DEV` 条件下渲染，不进入生产渲染路径。
 - 主题切换统一通过 `ConfigProvider` 的 antd theme algorithm 控制，不使用硬编码主题色。
--- a/docs/prompts/README.md
+++ b/docs/prompts/README.md
@@ -9,6 +9,7 @@
 | [prompt-smart-merge.md](prompt-smart-merge.md)         | 批量合并 `dev*` 分支到目标分支，含规则探测、依赖分析、冲突处理、安全回退  |
 | [prompt-proposal-review.md](prompt-proposal-review.md) | 审查 fast-drive design/tasks 与讨论、实际状态、OpenSpec workflow 的一致性 |
 | [prompt-apply-review.md](prompt-apply-review.md)       | 审查 apply 后实际产物、验证、design/tasks 的一致性，并补齐遗漏或回写文档  |
+| [prompt-code-review.md](prompt-code-review.md)         | 审查项目代码质量，覆盖架构、实现、复用、测试、依赖、工程与文档闭环        |

 ## 边界说明

@@ -87,7 +88,7 @@
 - 是否默认按某个 workflow 执行
 - 是否以代码、文档、讨论或用户确认为准
 - 何时必须使用提问工具确认
- 删除、重写前是否必须备份
+- 删除、重写前是否必须记录回退依据；存在 git 仓库时不要创建 `.bak` 文件
 - 改动后是否必须同步 README、测试、变更文档

 ### 4. 计划与执行分离
@@ -102,7 +103,7 @@
 - 执行后必须重新读取受影响对象并复核
 - 对代码修改要说明测试或验证方式
 - 对文档修改要检查相关文档之间是否同步一致
- 收尾时要列出修改文件、备份文件、验证结果和残留风险
+- 收尾时要列出修改文件、回退依据、验证结果和残留风险

 ## 各章节写法

@@ -190,14 +191,14 @@

 - 明确顺序执行还是可并行执行
 - 明确每批执行前是否确认
- 明确删除、重写、回退前是否要备份或创建锚点
+- 明确删除、重写、回退前是否要记录 git diff、创建锚点或在代码目录外备份
 - 明确执行后最少要复核哪些点

 推荐写法：

 - “逐批执行”或“逐项执行”
 - “每批执行后重新读取受影响文件并复核”
- “若涉及删除或重写，先创建备份文件 `{file}.bak.{timestamp}`”
+- “若存在 git 仓库，不创建 `.bak` 文件；先记录 `git status` / `git diff` 作为回退依据”

 ### 清理 / 收尾

@@ -206,7 +207,7 @@
 建议包含：

 - 修改文件清单
- 备份文件清单
+- 回退依据；若实际创建了备份，再列出备份文件清单
 - 测试 / 构建 / 验证命令与结果
 - 文档同步摘要
 - 残留问题、未验证项、待确认事项
@@ -238,7 +239,7 @@

 对高风险流程，提示词应提供至少一种回退机制：

- 备份文件
+- git diff / 安全锚点 / 代码目录外备份文件
 - 安全锚点 tag
 - `abort` 路径
 - 终止后的现场说明
@@ -269,24 +270,24 @@
 - 把历史变更文档直接当成稳定规范来源
 - 用抽象表述代替可执行动作
 - 把多个危险动作打包成一次默认授权
- 没有备份、没有锚点、没有终止路径
+- 没有回退依据、没有锚点、没有终止路径
 - 只要求“完成修改”，不要求复核和收尾

 ## 编写检查清单

 编写完一份提示词后，至少自检以下问题：

-| 检查项           | 说明                                              |
-| ---------------- | ------------------------------------------------- |
-| 目标是否单句明确 | 是否能一眼看出任务对象、目标和范围                |
-| 约束是否集中     | 全局规则是否只在 `## 约束` 中声明                 |
-| 数据源是否具体   | 是否明确读哪些文档、代码、测试、命令结果          |
-| 是否先分析再执行 | 是否存在独立的分析和计划阶段                      |
-| 是否有确认节点   | 高风险动作前是否要求提问工具确认                  |
-| 是否有降级路径   | change 不明、规则不明、上下文不足时是否有处理方式 |
-| 是否可操作       | 是否给出命令、工具、路径或结构化动作              |
-| 是否可验证       | 执行后是否定义复核或测试方式                      |
-| 是否能收尾       | 是否要求输出修改清单、备份、验证结果、残留风险    |
+| 检查项           | 说明                                               |
+| ---------------- | -------------------------------------------------- |
+| 目标是否单句明确 | 是否能一眼看出任务对象、目标和范围                 |
+| 约束是否集中     | 全局规则是否只在 `## 约束` 中声明                  |
+| 数据源是否具体   | 是否明确读哪些文档、代码、测试、命令结果           |
+| 是否先分析再执行 | 是否存在独立的分析和计划阶段                       |
+| 是否有确认节点   | 高风险动作前是否要求提问工具确认                   |
+| 是否有降级路径   | change 不明、规则不明、上下文不足时是否有处理方式  |
+| 是否可操作       | 是否给出命令、工具、路径或结构化动作               |
+| 是否可验证       | 执行后是否定义复核或测试方式                       |
+| 是否能收尾       | 是否要求输出修改清单、回退依据、验证结果、残留风险 |

 ## 维护原则

--- a/docs/prompts/prompt-apply-review.md
+++ b/docs/prompts/prompt-apply-review.md
@@ -10,7 +10,7 @@
 - 优先使用当前会话中的执行说明、验证结论、手动修补记录和已生成的变更文档；仅在无法明确 change、`schemaName`、改动范围或修补来源时，再用提问工具或 OpenSpec 命令补充定位
 - 不要因为实际产物已经存在就自动以实际产物为准；先判断差异属于“design 要求未完成”、“验证后新增修补”、“合理落地细化”还是“意外偏离/回归”
 - 每批实际产物或文档修改执行前用提问工具获得用户确认
- 删除/重写前用提问工具获得用户确认，并先备份原文件为 `{file}.bak.{timestamp}`
+- 删除/重写前用提问工具获得用户确认；若存在 git 仓库，不创建 `.bak` 备份文件，改用当前 `git status` / `git diff` 作为回退依据；仅在无版本控制或用户明确要求时，才将备份放到代码目录外的用户确认路径
 - 若修改实际产物涉及新行为、流程、接口、内容、数据、配置、责任边界或用户可见结果，同步更新验证材料、相关变更文档和必要的文档/沟通材料

 ## 1. 收集
@@ -146,8 +146,8 @@ g) 若实际 schema 不是 `fast-drive`，只读取实际存在的 artifacts；

 若涉及删除或重写：

- 先创建备份文件 `{file}.bak.{timestamp}`
- 再执行修改
+- 存在 git 仓库时，先记录当前 `git status` / `git diff`，不要在实际产物、文档或代码目录创建 `.bak` 文件
+- 不存在版本控制，或用户明确要求备份时，先用提问工具确认代码目录外的备份路径，再执行修改

 若修改了实际产物或验证材料：

@@ -174,6 +174,6 @@ g) 若实际 schema 不是 `fast-drive`，只读取实际存在的 artifacts；

 ## 5. 收尾

-列出所有修改的文件、备份文件、验证命令或检查结果、文档同步摘要和剩余风险。
+列出所有修改的文件、回退依据、验证命令或检查结果、文档同步摘要和剩余风险；若实际创建了备份，再列出备份文件。

 若本次因缺少验证结果、修补记录或上下文而降级执行，或有问题因信息不足暂未处理，单独说明。
--- a/docs/prompts/prompt-code-review.md
+++ b/docs/prompts/prompt-code-review.md
@@ -0,0 +1,230 @@
+审查项目代码质量，基于仓库规则、实际代码、测试、配置、依赖和文档证据，识别架构、实现、复用、测试覆盖、三方库使用和工程质量风险。默认只输出审查结论和建议，不修改任何文件；只有当用户明确要求制定修复计划或执行修复时，才进入计划和执行阶段。
+
+## 约束
+
+- 先审查再修复；未经用户确认，不修改代码、测试、配置、依赖或文档
+- 不得虚构已执行的命令、已读取的文件、subagent 结论、测试结果或用户确认；所有结论必须能追溯到实际读取内容、命令输出，或明确标记为假设、观察建议或信息不足
+- 优先遵守仓库已定义的开发规范、质量门禁、架构边界、包管理器规则、测试规则和文档同步规则
+- 不进行全仓库无差别逐文件精读；先建立目录、依赖、脚本、测试和变更范围索引，再定向读取高风险、高复杂度、核心链路和近期改动相关文件
+- 不以代码现状作为唯一真相；代码必须同时对照 README、开发文档、配置、测试、脚本、实际运行入口、近期提交和用户确认过的约束
+- 不因发现问题就自动新增依赖、重写架构、迁移技术栈或扩大功能范围；此类动作必须单独列为候选方案并获得用户确认
+- 质量审查默认不创建提交、不推送、不变更分支、不执行 destructive git 操作
+- 每批修复执行前必须获得用户明确确认；若环境提供提问工具，优先使用提问工具，否则以普通对话确认
+- 删除、重写、批量迁移、大范围格式化、依赖变更、数据库/配置 schema 变更、构建产物变更前必须单独确认；若环境提供提问工具，优先使用提问工具，否则以普通对话确认；若存在 git 仓库，不创建 `.bak` 备份文件，改用当前 `git status` / `git diff` 作为回退依据；仅在无版本控制或用户明确要求时，才将备份放到代码目录外的用户确认路径
+- 若修复影响用户可见行为、配置、部署、运行行为、架构边界、开发流程、测试方式或构建发布流程，必须同步更新对应文档
+- 若环境限制导致验证命令无法执行，记录未执行项、原因和残留风险，不得声称已验证
+- 审查阶段不得运行会格式化、修复、生成、迁移、安装、删除、写入受版本控制路径或修改工作区的命令；如不确定命令是否只读，先询问用户
+- 若环境支持 subagent，可仅用于收集和只读分析；若不支持 subagent，由主 agent 按相同分工顺序串行执行最小必要分析；任何 subagent 都不得修改代码、测试、配置、依赖或文档，不得提交、推送、切换分支、安装依赖或执行 destructive git 操作；所有修复必须由主 agent 在用户确认后执行
+
+## 1. 收集
+
+读取约束：
+
+- 优先使用当前会话信息、仓库文档、配置文件、脚本、测试和版本控制状态
+- 可并行读取互不依赖的文件、命令结果和 subagent 只读分析结果；并行前先划分范围，避免重复读取、结论冲突和上下文膨胀；不支持并行时按同样范围串行执行
+- 不原样输出大段文件内容，仅在审查报告和收尾中输出必要结论
+
+并行或分工分析策略：
+
+- 当审查范围较大、文件类型明显分层、多个分析维度互不依赖，或需要同时核对代码、测试、配置、文档和依赖证据时，优先使用可用的并行能力或 subagent 只读分析
+- 范围较小、问题集中、需要连续推理、需要用户确认、需要修改文件或存在高风险命令时，不使用 subagent，避免额外协调成本；若环境不支持 subagent，则由主 agent 串行执行并说明未使用原因
+- 适合拆分为架构边界、正确性/安全、前端专项、后端专项、测试验证、依赖与包管理、脚本/构建、文档闭环等子任务
+- 先由主 agent 建立共享基线，包括仓库规则、用户指定范围、目录结构、脚本、质量门禁、git 状态和候选高风险区域
+- 每个 subagent 只接收最小必要上下文，明确任务目标、允许读取范围、禁止操作、输出格式和必须引用的证据类型
+- 每个文件或目录默认只分配给一个主责 subagent；确需交叉复核时，明确一个为主责、一个只做抽样或专项核验
+- subagent 不重复读取共享基线文件，除非需要核对具体证据；共享基线由主 agent 统一读取并摘要分发
+- subagent 不输出大段源码，只输出文件路径、行号、问题摘要、证据、影响、建议、风险等级、建议验证方式和不确定项
+- 无 subagent 环境的降级方式：主 agent 先建立共享基线，再按架构边界、正确性/安全、前端、后端、测试验证、依赖与包管理、脚本/构建、文档闭环的顺序串行抽查；每轮只读取当前问题所需的最小文件集合，避免一次性展开全仓库
+
+分步收集：
+
+a) 先读取项目规则和入口，确定审查范围：
+
+- 先读取最小必要规则入口：根 README、文档路由或仓库说明中明确指向的开发规范；只有发现审查对象涉及对应领域时，再读取架构、前端、后端、发布等专题文档
+- 包管理和脚本配置，例如 `package.json`、锁文件、构建配置、测试配置、lint/format/typecheck 配置
+- OpenSpec 或仓库级工程规则，例如存在时读取 `openspec/config.yaml`
+- 若用户指定了审查范围、模块、分支、PR、change 或文件列表，以用户指定范围为主；否则默认采用标准审查：读取仓库规则、目标范围入口、相关测试和配置，并抽查核心链路，不声称覆盖全仓库
+- 若审查对象是 PR、分支、change 或近期改动，先确定审查基线：base 分支、head 提交、变更文件、变更类型和受影响入口；发现问题时区分“本次引入问题”和“既有问题被触发/暴露”
+
+b) 建立项目索引，先确认而不是假设：
+
+- 目录结构、主要入口、前后端边界、共享类型、脚本目录、测试目录和文档目录
+- 运行脚本、质量门禁脚本、构建脚本、测试脚本和生成脚本
+- 依赖清单、直接依赖用途、devDependencies 用途、成熟工具库能力、统一 UI 框架及项目已有组件封装、锁文件状态和是否存在多包管理器痕迹
+- 版本控制状态、当前工作区改动、近期提交或用户指定 diff 范围
+
+c) 定向读取代码和测试：
+
+- 核心业务链路、应用入口、路由/API、状态管理、数据访问、配置加载、错误处理、日志、权限/安全边界、构建集成点
+- 近期改动文件、复杂度明显偏高文件、重复实现、跨层 import、公共工具、共享类型、测试薄弱或失败相关文件
+- 与用户指定问题、模块、PR、change 或质量目标直接相关的代码、测试和文档
+
+d) 收集验证证据：
+
+- 先识别已定义的 typecheck、lint、format check、test、build、schema check、verify 等质量命令；只在命令明确只读、不会安装依赖、不会写入数据库/远端资源/受版本控制路径且预计成本可接受时执行；可能修改文件、生成产物、访问外部服务、耗时较长或副作用不明的命令，必须先说明影响并获得用户确认
+- 当前已执行过的验证结果、失败日志、跳过原因和未验证范围
+- 测试目录结构、测试覆盖的关键行为、边界条件、异常路径和回归场景
+
+e) 若无法确定范围或规则：
+
+- 先确认审查对象、审查深度和是否允许执行验证命令；若环境提供提问工具，优先使用提问工具，否则以普通对话确认
+- 若仍无法确认，降级为“仓库规则 + 代码静态审查 + 可定位测试审查”，并明确不做未读取范围的结论
+
+## 2. 分析
+
+按以下维度检查；维度编号只表示检查顺序，不代表问题严重度，每个发现必须单独按“阻断/高/中/低”评级：
+
+| 检查顺序 | 维度             | 检查点                                                                                                                                                                         |
+| -------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| D0       | 正确性与安全风险 | 是否存在会导致数据丢失、权限绕过、注入、敏感信息泄露、错误配置、不可恢复失败、生产不可用、构建失败或测试误判的问题                                                             |
+| D1       | 架构与边界       | 模块职责是否清晰；前后端、共享类型、脚本、测试和文档边界是否被破坏；是否出现循环依赖、跨层调用、隐式全局状态、启动链路不一致或设计与文档冲突                                   |
+| D2       | 实现质量         | 命名、类型、错误处理、并发/异步、资源释放、数据校验、状态流转、边界条件、异常路径、可读性、复杂度、可维护性是否达标                                                            |
+| D3       | 代码复用         | 是否重复实现已有 helper、组件、schema、类型、测试工具或三方库能力；是否已引入成熟工具库却自行实现等价能力；公共抽象是否过早、过泛、泄漏业务语义或反而增加耦合                  |
+| D4       | 测试覆盖与验证   | 关键路径、边界条件、失败路径、回归场景、配置/schema、前端交互、后端 API、脚本和构建是否有有效测试或可执行验证；测试是否真实断言行为而不是只覆盖实现细节                        |
+| D5       | 三方库与依赖     | 依赖是否必要、用途清晰、导入方式正确、运行时兼容、体积和安全风险可接受；是否存在已引入但未优先使用的成熟库、重复依赖、未使用依赖、错误包管理器痕迹或可用内建能力替代的新增依赖 |
+| D6       | 性能与资源       | 是否存在明显 N+1、重复计算、阻塞主线程、无界缓存、内存泄漏、未关闭资源、过大 bundle、无效重渲染、低效 IO 或可避免的启动成本                                                    |
+| D7       | 前端质量         | 组件边界、数据流、表单/交互状态、可访问性、响应式、样式体系、设计系统和 UI 框架官方实践使用、错误/加载/空状态和用户可见文案是否符合项目规范                                    |
+| D8       | 后端质量         | API 契约、输入输出校验、错误响应、日志、配置加载、数据库访问、迁移、事务、并发控制、外部服务调用和测试隔离是否符合项目规范                                                     |
+| D9       | 工程与文档闭环   | lint/format/typecheck/build/test/schema 等质量门禁是否可运行；脚本与文档是否一致；用户可见行为、配置、开发流程或架构变化是否已同步文档                                         |
+
+风险分级：
+
+| 等级 | 判定规则                                                                          | 处理要求                           |
+| ---- | --------------------------------------------------------------------------------- | ---------------------------------- |
+| 阻断 | 会导致错误结果、数据损坏、安全漏洞、构建/启动失败、核心测试失败或已确认需求不可用 | 必须优先修复或获得用户明确接受风险 |
+| 高   | 影响核心维护性、架构边界、测试可信度、依赖安全、关键异常路径或主要用户场景        | 应纳入近期修复计划                 |
+| 中   | 局部重复、复杂度偏高、命名/类型/边界不清、测试覆盖不足但未直接阻断                | 可批量修复或进入后续优化计划       |
+| 低   | 风格、表达、轻微文档不同步、局部可读性问题                                        | 可顺手修复或记录为建议             |
+
+分析时区分以下情况：
+
+- 明确缺陷：当前实现与需求、文档、测试或运行结果冲突
+- 质量风险：当前未必出错，但复杂度、边界、测试或依赖使用会提高维护成本
+- 合理取舍：实现与理想状态不同，但符合仓库约束、上下文决策或当前阶段目标
+- 信息不足：缺少运行结果、业务规则、覆盖数据或用户决策，无法给出确定结论
+- 观察建议：缺少明确规则或可复现影响，只能说明潜在收益、成本和适用前提，不得列为缺陷
+
+证据与误报控制：
+
+- 每个问题必须包含具体位置、触发条件、实际影响、证据来源、为什么现有实现不满足项目规则或需求，以及建议验证方式
+- 无法定位到具体代码、配置、文档、测试或命令证据的问题，只能列为“观察建议”或“信息不足”
+- 不得把个人偏好、未被项目规范要求的最佳实践、未证实的性能猜测直接列为缺陷
+- 每个问题标记置信度：高表示有代码、测试或命令证据；中表示有代码证据但缺少运行验证；低表示依赖业务假设或上下文不足；低置信度问题不得列为阻断
+- 对 diff、PR 或 change 审查，区分本次变更直接引入、本次变更扩大影响、既有问题但与本次风险相关、完全无关既有问题；无关既有问题只在附录中列出
+
+重点识别：
+
+- 架构边界被破坏、模块职责错位、入口链路和文档描述不一致
+- 同一行为在多个位置重复实现，或公共抽象没有明确复用收益
+- 依赖中已引入成熟工具库，例如 `es-toolkit` 等，但实现时没有优先复用其稳定能力，而是自行实现等价工具函数、集合处理、对象处理、比较、节流防抖、深拷贝或类型判断等逻辑
+- 代码过度复杂、隐式副作用多、错误处理缺失、边界条件未处理
+- 类型定义与运行时校验脱节，配置 schema、共享类型、API 契约和测试不一致
+- 测试只验证 happy path、测试断言过弱、mock 掩盖真实问题、缺少回归验证
+- 三方库用途不明确、引入成本大于收益、替代已有能力、存在包管理器或运行时兼容风险
+- 前端使用统一 UI 框架或设计系统时，没有优先使用官方组件、props、组合模式、表单校验、主题 token、样式扩展点和官方推荐实践
+- 前端通过覆盖内部 class、硬编码样式、`!important`、DOM 结构假设、额外 wrapper hack 或自造组件方式实现 UI 框架已提供的能力，导致行为、可访问性、响应式、主题一致性或维护性下降
+- 前端绕过设计系统、样式规则、可访问性或响应式要求
+- 后端缺少输入校验、错误响应、日志上下文、事务边界、资源释放或测试隔离
+- 质量门禁命令缺失、失败、未纳入文档，或文档中的命令与实际脚本不一致
+- 用户可见行为、配置、部署、架构或开发流程变化未同步文档
+
+主 agent 汇总 subagent 结果时遵循：
+
+- 主 agent 对最终结论负责，不直接转述 subagent 结论；必须去重、校准风险等级、合并同根因问题，并剔除缺少证据或超出范围的判断
+- 对不同 subagent 的冲突结论，优先采用有明确文件路径、行号、测试结果、配置或文档依据的一方；仍无法判断时标记为“信息不足”或列入“待确认清单”
+- 对阻断和高风险问题，主 agent 必须亲自复核关键证据，必要时重新读取最小相关文件或命令结果
+- 对重复问题，按根因合并为一项，在影响范围中列出涉及文件，不按文件机械重复输出
+- 对跨层问题，主 agent 统一判断责任边界，避免前端、后端、测试或文档 subagent 各自给出互相矛盾的修复方向
+- 对 subagent 提出的修改建议，主 agent 只纳入改进计划，不直接执行；执行仍必须经过用户确认
+- 最终“审查范围与证据”中列出 subagent 分工、覆盖范围、未覆盖范围和主 agent 复核过的关键证据
+
+输出审查结果：
+
+1. **审查范围与证据**：已读取的规则、代码区域、测试、配置、依赖、命令结果、未覆盖范围和未执行验证
+2. **关键结论**：按“阻断/高/中/低”汇总问题数量；若无明确问题，说明“在本次审查范围和证据内未发现问题”
+3. **问题清单**：每个问题只在一个主分类完整展开，包含位置、等级、置信度、证据、影响、建议和建议验证方式；其他分类只引用问题 ID 或汇总计数，避免重复描述和等级漂移
+4. **待确认事项**：需要用户判断目标、取舍、范围或授权的问题
+5. **可选改进**：无明确缺陷但有潜在收益的观察建议，说明适用前提和成本
+6. **后续计划**：仅当用户要求修复计划时输出；否则不主动展开执行批次
+
+无问题的分类可合并为“未发现明确问题的维度”，不要为了满足模板输出大量空清单或重复清单。
+
+若在已覆盖范围内未发现问题，输出“在本次审查范围和证据内未发现问题”，并明确列出未覆盖范围、未执行验证和残留风险；不得声称全仓库审查通过。
+
+## 3. 计划（用户确认）
+
+若用户只要求审查，到步骤 5 收尾，不主动请求执行修复。只有用户明确要求继续处理、制定修复计划或执行修复时，才进入本节。
+
+先针对“待确认清单”逐项向用户确认；若环境提供提问工具，优先使用提问工具，否则以普通对话确认。
+
+再整理改进计划，按批次列出：
+
+- 批次目标：阻断修复、高风险修复、测试补强、依赖清理、架构边界整理、文档同步、低风险清理
+- 拟修改文件或对象
+- 动作类型：修复、补测试、重构、拆分、合并、删除、迁移、依赖调整、文档同步、脚本修正
+- 修改原因和证据
+- 预期影响
+- 风险与回退方式
+- 验证命令或人工检查方式
+
+计划规则：
+
+- 优先处理阻断和高风险问题
+- 将纯格式化、命名清理和大范围重构与功能性修复分开
+- 将依赖变更、架构迁移、数据库/配置 schema 变更、删除和重写拆成单独批次
+- 对信息不足的问题，先补验证或补调研，不直接修复
+- 对存在多种方案的问题，列出方案差异和适用前提，由用户确认
+
+展示完整改进计划并等待用户确认；若环境提供提问工具，优先使用提问工具，否则以普通对话确认。确认计划不等于授权执行所有批次；每批执行仍需单独确认，高风险动作仍需按约束单独确认。
+
+## 4. 执行
+
+逐批执行已确认的修复。
+
+执行规则：
+
+- 每批只处理该批明确授权的问题，不顺手扩大范围
+- 优先做最小正确修改，不引入不必要的新抽象、新依赖或兼容层
+- 修复代码时同步补充或调整对应测试
+- 修复测试时确保测试断言真实行为，不通过降低断言、跳过测试或扩大 mock 来制造通过
+- 修复依赖问题时同步检查锁文件、导入位置、构建影响和文档影响
+- 修复文档或脚本时同步检查相关索引、命令和质量门禁描述
+- 修复后验证同样遵守只读优先；有副作用、耗时高、依赖外部服务或会修改工作区的命令需先确认，无法执行则记录原因和风险
+
+若涉及删除或重写：
+
+- 存在 git 仓库时，先记录当前 `git status` / `git diff`，识别并保护既有未提交改动，不要在源码、测试、配置或文档目录创建 `.bak` 文件
+- 回退方案必须说明如何仅回退本批修改；不得执行 `reset`、`checkout`、`clean` 等 destructive git 操作，除非用户单独确认
+- 不存在版本控制，或用户明确要求备份时，先确认代码目录外的备份路径；若环境提供提问工具，优先使用提问工具，否则以普通对话确认
+- 修改后确认回退依据；若实际创建了备份，再列出备份文件清单和恢复方式
+
+执行后重新读取所有被修改的代码、测试、配置、依赖和文档，并复核：
+
+- 原问题是否已解决，是否产生新的架构边界、复用、测试或依赖问题
+- 新增或修改的测试是否覆盖原风险点和关键回归路径
+- 质量门禁命令是否按影响范围执行并记录结果
+- 文档影响分析是否完成，必要文档是否同步
+- 未处理问题是否有明确保留原因、风险等级和后续建议
+
+## 5. 收尾
+
+列出最终结果。
+
+若只执行审查，收尾列出：
+
+- 审查范围与证据
+- 发现问题和风险等级
+- 未覆盖范围、未执行验证和原因
+- 残留风险和建议下一步
+
+若用户授权并执行了修复，收尾列出：
+
+- 修改文件清单
+- 回退依据；若实际创建了备份，再列出备份文件清单
+- 已修复问题清单
+- 未处理问题、保留原因和风险等级
+- 执行的验证命令、结果和未执行原因
+- 文档同步摘要；若无需更新文档，说明原因
+- 残留风险和建议后续批次
+
+若本次因范围不明、验证无法执行、上下文不足或用户未授权而降级执行，单独说明降级范围和不可下结论的内容。最终只能说“在本次范围内已处理/已验证”，不得泛称“审查通过”“全部修复完成”或“全量质量通过”。
--- a/docs/prompts/prompt-proposal-review.md
+++ b/docs/prompts/prompt-proposal-review.md
@@ -8,7 +8,7 @@
 - 在 `fast-drive` workflow 下，`design.md` 是范围、需求、决策、执行约束、执行方向和验证预期的事实来源，`tasks.md` 必须从 `design.md` 派生
 - 优先使用当前会话中的讨论、explore/propose 阶段结论和已生成的变更文档；仅在无法明确 change、`schemaName` 或文档范围时，再用提问工具或 OpenSpec 命令补充定位
 - 每批文档修改建议执行前用提问工具获得用户确认
- 删除/重写前用提问工具获得用户确认，并先备份原文件为 `{file}.bak.{timestamp}`
+- 删除/重写前用提问工具获得用户确认；若存在 git 仓库，不创建 `.bak` 备份文件，改用当前 `git status` / `git diff` 作为回退依据；仅在无版本控制或用户明确要求时，才将备份放到代码目录外的用户确认路径

 ## 1. 收集

@@ -118,8 +118,8 @@ d) 若实际 schema 不是 `fast-drive`，只读取实际存在的 artifacts；

 若涉及删除或重写：

- 先创建备份文件 `{file}.bak.{timestamp}`
- 再执行修改
+- 存在 git 仓库时，先记录当前 `git status` / `git diff`，不要在文档或代码目录创建 `.bak` 文件
+- 不存在版本控制，或用户明确要求备份时，先用提问工具确认代码目录外的备份路径，再执行修改

 执行后重新读取所有被修改的文档，并复核：

@@ -134,6 +134,6 @@ d) 若实际 schema 不是 `fast-drive`，只读取实际存在的 artifacts；

 ## 5. 收尾

-列出所有修改的文件、备份文件和变更摘要。
+列出所有修改的文件、回退依据和变更摘要；若实际创建了备份，再列出备份文件。

 若本次因缺少讨论记录而降级执行，或有问题因信息不足暂未处理，单独说明。
--- a/docs/user/usage.md
+++ b/docs/user/usage.md
@@ -36,6 +36,7 @@ bun run dev config.yaml
 | ---------- | ----------------------- | ---------------------------------------- |
 | 总览       | `/`                     | Admin 管理台总览，展示运行时元信息       |
 | 项目管理   | `/projects`             | 创建、编辑、归档、恢复和永久删除项目     |
+| 模型管理   | `/models`               | 配置 AI 供应商和模型，供后续 AI 功能使用 |
 | 工作台总览 | `/workbench/:projectId` | Workbench 工作台总览，按项目维度查看信息 |
 | 用户管理   | `/users`                | 页面建设中                               |
 | 系统设置   | `/settings`             | 页面建设中                               |
@@ -46,3 +47,12 @@ bun run dev config.yaml
 - **Workbench（工作台）**：项目维度视角，通过 `/workbench/:projectId` 进入指定项目的工作台。URL 可保存为浏览器书签，下次直接进入。仅 active 状态的项目可进入工作台，archived 项目不可访问。

 从项目管理页面的 active 项目行可点击"进入工作台"跳转到对应项目的工作台。
+
+## 模型管理
+
+在 Admin 侧栏进入 `/models` 后，页面通过两个标签页管理 AI 基础配置：
+
+- **供应商**：新增、编辑、删除 OpenAI、Anthropic 或 OpenAI 兼容供应商。新建供应商时类型默认是 `openai-compatible`，baseURL 和 API Key 由用户填写。
+- **模型**：为供应商新增模型，填写模型显示名称、实际调用用的 modelId、能力标签，以及可选的上下文长度和最大输出 token。
+
+供应商表单提供“测试连接”操作：系统先测试 Base URL 是否可达，再尝试请求 `/models` 验证 API Key 和模型列表接口。若服务不支持 `/models`，页面会提示接口可达但可能不支持模型列表；该结果只作为提醒，不会阻止保存供应商或模型。删除供应商前必须先删除或迁移其关联模型，否则系统会拒绝删除以避免误删模型配置。
--- a/drizzle/0002_remove_model_management_enabled.sql
+++ b/drizzle/0002_remove_model_management_enabled.sql
@@ -0,0 +1,3 @@
+ALTER TABLE `providers` DROP COLUMN `enabled`;
+--> statement-breakpoint
+ALTER TABLE `models` DROP COLUMN `enabled`;
--- a/openspec/changes/add-model-management/.openspec.yaml
+++ b/openspec/changes/add-model-management/.openspec.yaml
@@ -1,2 +0,0 @@
-schema: fast-drive
-created: 2026-05-29
--- a/openspec/changes/add-model-management/design.md
+++ b/openspec/changes/add-model-management/design.md
@@ -1,225 +0,0 @@
-## 背景
-
-Alfred·阿福定位为"基于 AI 的信息综合处理平台"，但当前项目（v0.1.0）没有任何 AI/LLM 集成。项目已完成基础架构（Bun 全栈、SQLite + Drizzle ORM、React 19 + Ant Design 6 + React Router 7、TanStack React Query），并拥有管理控制台（Dashboard + 项目管理）和工作台控制台。
-
-本次变更在管理控制台中新增"模型管理"功能，让用户能够配置 AI 供应商和模型，为后续所有 AI 功能提供基础设施。这是项目 AI 能力的第一个里程碑。
-
-**当前状态：**
- 后端：`src/server/` 使用 Bun.serve()，路由在 `routes/` 目录按功能拆分，DB schema 在 `src/server/db/schema.ts`，数据访问层在 `src/server/db/projects.ts`
- 前端：`src/web/` 使用 console 模式，admin 菜单在 `consoles/admin/menu.tsx`，页面在 `pages/` 目录
- 零 AI/LLM 相关代码
-
-## 讨论记录
-
- 已确认结论：
-  - 使用 Vercel AI SDK（`ai` + `@ai-sdk/openai` + `@ai-sdk/anthropic` + `@ai-sdk/openai-compatible`）作为统一 AI 调用层
-  - 三种供应商类型：`openai`、`anthropic`、`openai-compatible`（覆盖 DeepSeek、Qwen、Ollama 等）
-  - API Key 明文存储于 SQLite，可接受（本地/自部署单用户工具）
-  - AI 注册表不使用缓存层：每次 AI 调用时从 DB 查询供应商+模型 → 构建 `createProviderRegistry` → 调用 AI SDK（开销 ~1ms，远小于网络 I/O）
-  - 功能调用（function calling）视为基础能力，不列入 capability 标签
- 用户偏好：
-  - 前端使用 antd `Tabs` 组件在同一页面内展示供应商和模型两个标签页
-  - 供应商表单中 type 默认值为 `openai-compatible`，baseURL 不设默认值
-  - 连通性测试为可选功能，不阻塞模型创建
- 约束：
-  - 严格遵循现有代码模式（路由拆分、数据访问函数、hooks、页面组件结构）
-  - 不引入新的样式系统
- 被否决方案：
-  - API Key 加密存储：对本地/自部署单用户场景过度设计
-  - AI 注册表缓存：增加复杂度但收益极小（~1ms vs 数百毫秒网络 I/O）
-  - LangChain 等重量级框架：Vercel AI SDK 更轻量且 API 更统一
-
-## 需求
-
-| 需求 | 验收标准 |
-| ---- | -------- |
-| 供应商 CRUD | 管理员可新增、查看、编辑、删除供应商（名称、类型、baseURL、apiKey） |
-| 供应商类型支持 | 支持 openai、anthropic、openai-compatible 三种类型，各自对应 AI SDK 不同 provider 工厂 |
-| 模型 CRUD | 管理员可新增、查看、编辑、删除模型（名称、所属供应商、modelId、能力标签、可选参数） |
-| 能力标签多选 | 模型表单中可多选能力标签（text / reasoning / image-generation / video-generation / audio-generation / image-recognition / video-recognition / audio-recognition） |
-| 连通性测试 | 供应商编辑/创建时可测试 API 连通性，返回成功/失败提示 |
-| 模型启用/禁用 | 供应商和模型均可启用/禁用，不影响数据 |
-| 管理控制台菜单 | Admin 控制台侧栏新增"模型管理"菜单项 |
-| AI 注册表服务 | 后端提供 AI 注册表构建服务，按需从 DB 查询构建，供后续 AI 功能调用 |
-| 级联约束 | 删除供应商时，若存在关联模型则阻止删除，用户需先处理关联模型 |
-
-## 数据模型规格
-
-### providers 表
-
-| 字段 | 类型 | 约束 | 说明 |
-| ---- | ---- | ---- | ---- |
-| id | TEXT | PK, UUID | 自动生成 |
-| name | TEXT | NOT NULL, UNIQUE | 供应商显示名称 |
-| type | TEXT | NOT NULL | 枚举：`openai` \| `anthropic` \| `openai-compatible`，默认 `openai-compatible` |
-| baseUrl | TEXT | NOT NULL | API 基础 URL，不设默认值，由用户填写 |
-| apiKey | TEXT | NOT NULL | API 密钥，明文存储，GET 接口完整返回 |
-| enabled | INTEGER | NOT NULL, DEFAULT 1 | 1=启用, 0=禁用 |
-| createdAt | TEXT | NOT NULL | ISO 8601 时间戳 |
-| updatedAt | TEXT | NOT NULL | ISO 8601 时间戳 |
-
-### models 表
-
-| 字段 | 类型 | 约束 | 说明 |
-| ---- | ---- | ---- | ---- |
-| id | TEXT | PK, UUID | 自动生成 |
-| name | TEXT | NOT NULL | 模型显示名称 |
-| providerId | TEXT | NOT NULL, FK → providers.id | 所属供应商 |
-| modelId | TEXT | NOT NULL | API 调用用的模型标识（如 `gpt-4o`） |
-| capabilities | TEXT | NOT NULL | JSON 数组，能力标签（见下方定义） |
-| contextLength | INTEGER | 可选 | 上下文窗口长度 |
-| maxOutputTokens | INTEGER | 可选 | 最大输出 token 数 |
-| enabled | INTEGER | NOT NULL, DEFAULT 1 | 1=启用, 0=禁用 |
-| createdAt | TEXT | NOT NULL | ISO 8601 时间戳 |
-| updatedAt | TEXT | NOT NULL | ISO 8601 时间戳 |
-
-**唯一约束：** `(providerId, modelId)` 联合唯一——同一供应商下 modelId 不可重复，不同供应商可以有相同 modelId。
-
-**能力标签定义（ModelCapability）：**
-
-```
-"text" | "reasoning" | "image-generation" | "video-generation" | "audio-generation" | "image-recognition" | "video-recognition" | "audio-recognition"
-```
-
-存储为 JSON 数组字符串，如 `["text","reasoning","image-recognition"]`。
-
-## 目标 / 非目标
-
-**目标：**
- 在管理控制台提供完整的供应商和模型管理界面
- 建立后端 AI 服务层（注册表 + 类型定义），为后续 AI 功能提供可复用基础
- 完成 Vercel AI SDK 集成的依赖安装和基础配置
- 新增 DB migration 支持 providers 和 models 表
-
-**非目标：**
- 不实现实际的 AI 调用功能（文本生成、图片生成等）——这是后续变更的内容
- 不实现 API Key 加密存储
- 不实现供应商/模型的导入导出功能
- 不实现多用户权限控制
-
-## 执行约束
-
- 依赖限制：
-  - 新增 npm 依赖仅限 `ai`、`@ai-sdk/openai`、`@ai-sdk/anthropic`、`@ai-sdk/openai-compatible`
-  - 使用 `bun add` 安装，严禁 npm/pnpm
-  - 优先使用项目已有依赖（Drizzle ORM、antd、TanStack React Query 等）
- 约束：
-  - 后端遵循 Bun 内置 API > es-toolkit > 三方库优先级
-  - 前端遵循 antd 组件默认能力优先，禁止内联 style、覆盖 antd 内部类名
-  - Git 提交格式：中文，"类型: 简短描述"
- 质量门禁：
-  - 新增代码必须编写完善的测试
-  - 不允许跳过任何测试
-  - 代码变更需执行文档影响分析
- 相关方：
-  - 本变更为基础设施层，所有后续 AI 功能变更将依赖本变更的 AI 注册表服务
- 文档 / 沟通：
-  - 每次代码变更执行文档影响分析：用户可见行为变更 → `docs/user/`，开发流程/架构变更 → `docs/development/`
- 兼容性 / 连续性：
-  - 无需考虑向前兼容性
-
-## 影响范围
-
-| 范围 | Artifacts / 参考资料 | 预期变更 | 备注 |
-| ---- | -------------------- | -------- | ---- |
-| DB Schema | `src/server/db/schema.ts` | 新增 providers 和 models 表定义 | 遵循现有 projects 表模式 |
-| DB Migration | `drizzle/` | 新增 migration SQL 文件 | 自动生成 |
-| 数据访问层 | `src/server/db/projects.ts`（参考模式） | 新增 `providers.ts` 和 `models.ts` | CRUD + 启用/禁用 |
-| DB 导出 | `src/server/db/index.ts` | 新增 providers 和 models schema 导出 | 遵循现有导出模式 |
-| 共享类型 | `src/shared/api.ts` | 新增供应商和模型相关类型定义 | 前后端共用 |
-| 后端路由 | `src/server/routes/` | 新增 `providers/` 和 `models/` 目录 | CRUD + 连通性测试 |
-| 服务器入口 | `src/server/server.ts` | 注册新路由 | 懒加载导入 |
-| AI 服务层 | `src/server/ai/`（新建） | 新增 `registry.ts` 和 `types.ts` | AI 注册表构建服务 |
-| 前端菜单 | `src/web/consoles/admin/menu.tsx` | 新增"模型管理"菜单项 | |
-| 前端页面 | `src/web/pages/models/`（新建） | 新增模型管理页面（Tabs + 表格 + 表单） | 遵循 projects 页面模式 |
-| 前端组件 | `src/web/pages/models/components/`（新建） | ProviderTable、ProviderFormModal、ModelTable、ModelFormModal | |
-| 前端路由 | `src/web/routes.tsx` | 新增 `/models` 路由 | |
-| 前端 Hooks | `src/web/hooks/` | 新增 `use-providers.ts`、`use-models.ts` | TanStack React Query |
-| 依赖 | `package.json` | 新增 `ai`、`@ai-sdk/openai`、`@ai-sdk/anthropic`、`@ai-sdk/openai-compatible` | |
-| 测试 | `tests/` | 新增后端路由、数据访问、前端 hooks 和组件测试 | |
-| 文档 | `docs/development/backend.md` | 更新后端架构说明，补充 AI 服务层 | 开发文档 |
-| 文档 | `docs/development/frontend.md` | 补充模型管理页面组件说明 | 开发文档 |
-
-## 决策
-
-| 决策 | 理由 | 已否决替代方案 |
-| ---- | ---- | ---------------- |
-| 使用 Vercel AI SDK | 轻量、统一 API、支持多供应商、TypeScript 优先、与 Bun 兼容 | LangChain（过重，API 复杂）、自行封装 fetch（维护成本高，无法统一接口） |
-| 三种供应商类型 | 覆盖主流场景：OpenAI（Responses API + Chat Completions API）、Anthropic、OpenAI 兼容协议（DeepSeek/Qwen/Ollama 等） | 仅区分"OpenAI 协议"和"其他"（丢失 Anthropic 特有能力） |
-| API Key 明文存储 | 本地/自部署单用户场景，加密增加复杂度但安全性提升有限 | 加密存储（过度设计） |
-| AI 注册表不缓存 | DB 查询 + 注册表构建开销 ~1ms，远小于网络 I/O；无缓存则无需处理失效/一致性问题 | 内存缓存（增加复杂度，收益极小） |
-| capability 标签用 JSON 数组 | 灵活可扩展，SQLite 中 TEXT 字段存储 JSON 数组 | 关联表（过度设计，标签数量有限且固定） |
-| 连通性测试不阻塞操作 | 测试是辅助功能，网络波动不应阻止用户保存配置 | 强制测试通过才能保存（用户体验差） |
-| 删除供应商时阻止而非级联删除 | 防止误删导致模型数据丢失，用户需先处理关联模型 | CASCADE 删除（数据安全风险） |
-| GET 接口完整返回 apiKey | 本地/自部署单用户场景，前端使用 antd Password 组件隐藏显示，无需脱敏 | apiKey 脱敏返回（增加复杂度，编辑时需额外处理） |
-| providerId + modelId 联合唯一 | 同一供应商下 modelId 不可重复，不同供应商可有相同 modelId；符合 AI SDK 注册表 key 格式 `providerId:modelId` | modelId 全局唯一（限制过严）、无约束（可能导致注册表冲突） |
-| 连通性测试使用 generateText 最小请求 | 调用 `generateText({ model, prompt: 'hi' })` 验证连通性和 apiKey 有效性，简单直接 | 仅验证 HTTP 连接（不验证 apiKey）、listModels（并非所有供应商支持） |
-| 启用/禁用使用 enable/disable 双端点 | 语义明确，与 archive/restore 模式一致；供应商/模型的启用禁用是布尔切换，双端点更清晰 | toggle 单端点（语义含糊，前端需知道当前状态才能确定操作） |
-| 供应商 type 默认 openai-compatible | 覆盖最广（DeepSeek/Qwen/Ollama 等），用户只需填写 baseURL 和 apiKey 即可使用 | 默认 openai（限制性强，不适合自部署场景） |
-| baseURL 不设默认值 | 不同部署环境的 baseURL 差异大，自动填充可能误导用户填错地址 | 设默认值（看似方便，但可能掩盖配置错误） |
-
-## 执行计划
-
-**阶段 1：基础层（DB + 类型 + 依赖）**
-1. 安装 Vercel AI SDK 相关依赖
-2. 在 `src/server/db/schema.ts` 新增 providers 和 models 表定义
-3. 生成 DB migration
-4. 在 `src/shared/api.ts` 新增供应商和模型相关类型定义
-5. 在 `src/server/ai/types.ts` 新增 AI 相关类型定义（ModelCapability 等）
-
-**阶段 2：后端（数据访问 + 路由 + AI 服务）**
-6. 新增 `src/server/db/providers.ts` 数据访问函数
-7. 新增 `src/server/db/models.ts` 数据访问函数
-8. 新增 `src/server/routes/providers/` 目录下的 CRUD 路由处理器（含 enable/disable 双端点）
-9. 新增 `src/server/routes/models/` 目录下的 CRUD 路由处理器（含 enable/disable 双端点）
-10. 新增 `src/server/routes/providers/test.ts` 连通性测试路由
-11. 在 `src/server/server.ts` 注册所有新路由
-12. 新增 `src/server/ai/registry.ts`，包含 `buildProviderRegistry(db)`（从 DB 查询启用的供应商构建 AI SDK Provider Registry）和 `testProviderConnection(config)`（使用 generateText 测试连通性）
-
-**阶段 3：前端（页面 + 组件 + Hooks）**
-13. 新增 `src/web/hooks/use-providers.ts` 和 `src/web/hooks/use-models.ts`
-14. 在 `src/web/consoles/admin/menu.tsx` 新增"模型管理"菜单项
-15. 在 `src/web/routes.tsx` 新增 `/models` 路由
-16. 新增 `src/web/pages/models/index.tsx` 页面（Tabs 布局）
-17. 新增 `src/web/pages/models/components/ProviderTable.tsx`
-18. 新增 `src/web/pages/models/components/ProviderFormModal.tsx`
-19. 新增 `src/web/pages/models/components/ModelTable.tsx`
-20. 新增 `src/web/pages/models/components/ModelFormModal.tsx`
-
-**阶段 4：测试**
-21. 后端数据访问层测试（providers.ts、models.ts）
-22. 后端路由测试（providers/、models/）
-23. AI 注册表测试
-24. 前端 hooks 测试
-25. 前端组件测试
-
-**阶段 5：文档**
-26. 执行文档影响分析，更新 `docs/development/` 相关文档
-
-## 验证计划
-
-| 需求 / 风险 | 验证方式 |
-| ----------- | -------- |
-| 供应商 CRUD API | 后端路由测试覆盖创建、查询、更新、删除、启用/禁用 |
-| 模型 CRUD API | 后端路由测试覆盖创建、查询、更新、删除、启用/禁用 |
-| 供应商删除约束 | 测试删除有关联模型的供应商时返回错误 |
-| 连通性测试 API | 测试 mock 场景下的成功/失败响应 |
-| AI 注册表构建 | 测试从 DB 数据正确构建 AI SDK provider 实例 |
-| DB Migration | 测试 migration 正确创建表和索引 |
-| 前端供应商管理 | 组件测试覆盖表格渲染、表单提交、启用/禁用操作 |
-| 前端模型管理 | 组件测试覆盖表格渲染、表单提交、能力标签多选 |
-| 前端菜单和路由 | 测试菜单项显示和路由跳转 |
-| 文档完整性 | 检查 docs/development/ 和 docs/user/ 是否已更新 |
-
-## 风险 / 权衡
-
- [Vercel AI SDK 与 Bun 的兼容性] -> AI SDK 基于 Web 标准 API，Bun 对 Web API 支持良好；安装后需验证 import 正常
- [OpenAI-compatible 供应商行为不一致] -> 注册表构建时使用 `createOpenAICompatible` 标准接口；连通性测试帮助用户提前发现问题
- [API Key 明文存储安全风险] -> 文档中说明安全模型（单用户本地部署）；未来可按需增加加密
- [migration 与现有数据兼容性] -> 新增表不影响现有 projects 表；migration 为增量操作
-
-## 待解决问题
-
-| 状态 | 问题 | 所需决策 |
-| ---- | ---- | -------- |
-| 无 | 无待解决问题。 | 无需决策 |
--- a/openspec/changes/add-model-management/tasks.md
+++ b/openspec/changes/add-model-management/tasks.md
@@ -1,89 +0,0 @@
-## 1. 上下文审查
-
- [x] 1.1 阅读 design.md，识别范围、需求、决策、执行约束和待解决问题
- [x] 1.2 审查影响范围中列出的相关文件：`src/server/db/schema.ts`、`src/server/db/projects.ts`、`src/server/server.ts`、`src/shared/api.ts`、`src/web/consoles/admin/menu.tsx`、`src/web/routes.tsx`、`src/web/pages/projects/`
- [x] 1.3 审查现有测试模式：`tests/server/routes/projects.test.ts`、`tests/server/db/projects.test.ts`、`tests/web/hooks/use-projects.test.ts`、`tests/web/routes/projects.test.tsx`
-
-## 2. 基础层：依赖安装与类型定义
-
- [x] 2.1 使用 `bun add ai @ai-sdk/openai @ai-sdk/anthropic @ai-sdk/openai-compatible` 安装 Vercel AI SDK 依赖
- [x] 2.2 在 `src/shared/api.ts` 新增供应商和模型相关类型定义（ProviderType、ModelCapability、Provider 相关请求/响应类型、Model 相关请求/响应类型）
- [x] 2.3 新建 `src/server/ai/types.ts`，定义 AI 层专用类型（ProviderType、ModelCapability、AIRegistryConfig 等）
-
-## 3. 数据库层：Schema 与 Migration
-
- [x] 3.1 在 `src/server/db/schema.ts` 新增 providers 表定义（id、name、type、baseUrl、apiKey、enabled、createdAt、updatedAt）
- [x] 3.2 在 `src/server/db/schema.ts` 新增 models 表定义（id、name、providerId、modelId、capabilities、contextLength、maxOutputTokens、enabled、createdAt、updatedAt）
- [x] 3.3 使用 `bunx drizzle-kit generate` 生成 migration SQL 文件
- [x] 3.4 验证 migration SQL 文件正确性（表结构、索引、外键约束）
-
-## 4. 数据访问层
-
- [x] 4.1 新建 `src/server/db/providers.ts`，实现供应商 CRUD 数据访问函数（create、list、get、update、delete、enable、disable），遵循 `projects.ts` 模式
- [x] 4.2 新建 `src/server/db/models.ts`，实现模型 CRUD 数据访问函数（create、list、get、update、delete、enable、disable），包含按 providerId 查询和关联检查
-
-## 5. 后端路由层
-
- [x] 5.1 新建 `src/server/routes/providers/create.ts`（POST /api/providers）
- [x] 5.2 新建 `src/server/routes/providers/list.ts`（GET /api/providers）
- [x] 5.3 新建 `src/server/routes/providers/get.ts`（GET /api/providers/:id）
- [x] 5.4 新建 `src/server/routes/providers/update.ts`（PATCH /api/providers/:id）
- [x] 5.5 新建 `src/server/routes/providers/delete.ts`（DELETE /api/providers/:id，有关联模型时阻止删除）
- [x] 5.6 新建 `src/server/routes/providers/enable.ts`（POST /api/providers/:id/enable）
- [x] 5.7 新建 `src/server/routes/providers/disable.ts`（POST /api/providers/:id/disable）
- [x] 5.8 新建 `src/server/routes/providers/test.ts`（POST /api/providers/:id/test，使用 AI SDK generateText 测试连通性）
- [x] 5.9 新建 `src/server/routes/models/create.ts`（POST /api/models）
- [x] 5.10 新建 `src/server/routes/models/list.ts`（GET /api/models，支持按 providerId 筛选）
- [x] 5.11 新建 `src/server/routes/models/get.ts`（GET /api/models/:id）
- [x] 5.12 新建 `src/server/routes/models/update.ts`（PATCH /api/models/:id）
- [x] 5.13 新建 `src/server/routes/models/delete.ts`（DELETE /api/models/:id）
- [x] 5.14 新建 `src/server/routes/models/enable.ts`（POST /api/models/:id/enable）
- [x] 5.15 新建 `src/server/routes/models/disable.ts`（POST /api/models/:id/disable）
- [x] 5.16 在 `src/server/server.ts` 中注册所有新路由（懒加载导入）
-
-## 6. AI 服务层
-
- [x] 6.1 新建 `src/server/ai/registry.ts`，实现 `buildProviderRegistry(db)`（从 DB 查询启用的供应商构建 AI SDK Provider Registry，模型通过 `registry.languageModel('providerId:modelId')` 获取）和 `testProviderConnection(config)`（使用 generateText 测试连通性）
-
-## 7. 前端：Hooks 与路由
-
- [x] 7.1 新建 `src/web/hooks/use-providers.ts`，实现供应商 CRUD 的 TanStack React Query hooks
- [x] 7.2 新建 `src/web/hooks/use-models.ts`，实现模型 CRUD 的 TanStack React Query hooks
- [x] 7.3 在 `src/web/consoles/admin/menu.tsx` 新增"模型管理"菜单项，图标使用 antd 的 RobotOutlined 或类似图标
- [x] 7.4 在 `src/web/routes.tsx` 新增 `/models` 路由，指向 AdminConsoleLayout 下的模型管理页面
-
-## 8. 前端：页面与组件
-
- [x] 8.1 新建 `src/web/pages/models/index.tsx`，使用 antd Tabs 实现供应商/模型双标签页布局
- [x] 8.2 新建 `src/web/pages/models/components/ProviderTable.tsx`，实现供应商列表表格（名称、类型、baseURL、状态、操作）
- [x] 8.3 新建 `src/web/pages/models/components/ProviderFormModal.tsx`，实现供应商创建/编辑表单弹窗（name、type Select 默认 openai-compatible、apiKey Password 输入、baseURL 不设默认值）
- [x] 8.4 新建 `src/web/pages/models/components/ModelTable.tsx`，实现模型列表表格（名称、供应商、modelId、能力标签、状态、操作）
- [x] 8.5 新建 `src/web/pages/models/components/ModelFormModal.tsx`，实现模型创建/编辑表单弹窗（name、provider Select、modelId、capabilities Checkbox.Group、contextLength、maxOutputTokens 可选输入、连通性测试按钮）
-
-## 9. 测试：后端
-
- [x] 9.1 编写 `tests/server/db/providers.test.ts`，覆盖供应商 CRUD 和启用/禁用数据访问函数
- [x] 9.2 编写 `tests/server/db/models.test.ts`，覆盖模型 CRUD、启用/禁用和关联检查数据访问函数
- [x] 9.3 编写 `tests/server/routes/providers.test.ts`，覆盖供应商路由的请求验证、CRUD 操作和连通性测试
- [x] 9.4 编写 `tests/server/routes/models.test.ts`，覆盖模型路由的请求验证和 CRUD 操作
- [x] 9.5 编写 `tests/server/ai/registry.test.ts`，覆盖 AI 注册表构建逻辑
-
-## 10. 测试：前端
-
- [x] 10.1 编写 `tests/web/hooks/use-providers.test.ts`，覆盖供应商 hooks 的 query 和 mutation
- [x] 10.2 编写 `tests/web/hooks/use-models.test.ts`，覆盖模型 hooks 的 query 和 mutation
- [x] 10.3 编写 `tests/web/routes/models.test.tsx`，覆盖模型管理页面路由和渲染
- [x] 10.4 编写 `tests/web/components/ProviderTable.test.tsx`，覆盖供应商表格渲染和交互
- [x] 10.5 编写 `tests/web/components/ModelTable.test.tsx`，覆盖模型表格渲染和交互
-
-## 11. 质量保障
-
- [x] 11.1 运行全部测试（`bun test`），确保无失败
- [x] 11.2 运行 lint 检查（`bun run lint`），确保无错误
- [x] 11.3 运行格式检查（`bun run format:check`），确保代码格式正确
-
-## 12. 文档
-
- [x] 12.1 执行文档影响分析：评估本次变更对 docs/ 下各文档的影响
- [x] 12.2 更新 `docs/development/backend.md`，补充 AI 服务层架构说明（`src/server/ai/` 目录结构和职责）
- [x] 12.3 更新 `docs/development/frontend.md`，补充模型管理页面组件说明
--- a/package.json
+++ b/package.json
@@ -10,6 +10,7 @@
    "build": "bun run scripts/build.ts",
    "lint": "eslint .",
    "format": "prettier . --write",
+    "format:check": "prettier . --check",
    "check": "bun run schema:check && bun run typecheck && bun run lint && bun test",
    "schema": "bun run scripts/generate-config-schema.ts",
    "schema:check": "bun run scripts/generate-config-schema.ts -- --check",
--- a/src/server/ai/registry.ts
+++ b/src/server/ai/registry.ts
@@ -8,10 +8,10 @@ import { createProviderRegistry, generateText } from "ai";
 import type { AIProviderConfig } from "./types";

 export function buildProviderRegistry(db: Database) {
-  const enabledProviders = getEnabledProviders(db);
+  const providers = getProviders(db);

  const providerEntries: Record<string, ReturnType<typeof createProvider>> = {};
-  for (const p of enabledProviders) {
+  for (const p of providers) {
    providerEntries[p.id] = createProvider({
      apiKey: p.api_key,
      baseUrl: p.base_url,
@@ -23,24 +23,105 @@ export function buildProviderRegistry(db: Database) {
  return createProviderRegistry(providerEntries);
 }

-export async function testProviderConnection(config: AIProviderConfig): Promise<{ message: string; ok: boolean }> {
+export async function testModelConnection(
+  config: AIProviderConfig & { modelId: string },
+): Promise<{ message: string; ok: boolean }> {
  try {
    const provider = createProvider(config);
-    const model = provider.languageModel("test");
-
    await generateText({
-      maxOutputTokens: 1,
-      model,
+      maxOutputTokens: 10,
+      model: provider.languageModel(config.modelId),
      prompt: "Hi",
    });
-
-    return { message: "连接成功", ok: true };
+    return { message: "模型连接成功", ok: true };
  } catch (e: unknown) {
    const msg = e instanceof Error ? e.message : String(e);
-    return { message: `连接失败: ${msg}`, ok: false };
+    return { message: `模型连接失败：${msg}`, ok: false };
  }
 }

+export async function testProviderConnection(config: AIProviderConfig): Promise<{ message: string; ok: boolean }> {
+  const baseUrlResult = await probeBaseUrl(config.baseUrl);
+  if (!baseUrlResult.ok) return baseUrlResult;
+
+  const modelsUrl = buildModelsUrl(config.baseUrl);
+
+  try {
+    const response = await fetch(modelsUrl, {
+      headers: buildModelsHeaders(config),
+      signal: AbortSignal.timeout(5000),
+    });
+
+    if (response.status === 401 || response.status === 403) {
+      return { message: "Base URL 可连接，但 API Key 无效或权限不足。", ok: false };
+    }
+
+    if ([404, 405, 501].includes(response.status)) {
+      return {
+        message: "Base URL 可连接，但可能不支持 /models 接口；可检查 URL 或忽略此提示。",
+        ok: true,
+      };
+    }
+
+    if (!response.ok) {
+      return {
+        message: `Base URL 可连接，但 /models 请求失败（HTTP ${response.status}）；可检查 URL 或忽略此提示。`,
+        ok: true,
+      };
+    }
+
+    const body = (await response.json().catch(() => null)) as unknown;
+    const modelCount = countModels(body);
+    if (modelCount !== null) {
+      return { message: `连接成功，/models 返回 ${modelCount} 个模型。`, ok: true };
+    }
+
+    return {
+      message: "Base URL 可连接，但 /models 返回格式不兼容，可能不支持 /models；可检查 URL 或忽略此提示。",
+      ok: true,
+    };
+  } catch (e: unknown) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { message: `Base URL 可连接，但 /models 请求异常：${msg}；可检查 URL 或忽略此提示。`, ok: true };
+  }
+}
+
+function buildModelsHeaders(config: AIProviderConfig): HeadersInit {
+  if (config.type === "anthropic") {
+    return {
+      accept: "application/json",
+      "anthropic-version": "2023-06-01",
+      "x-api-key": config.apiKey,
+    };
+  }
+
+  return {
+    accept: "application/json",
+    authorization: `Bearer ${config.apiKey}`,
+  };
+}
+
+function buildModelsUrl(baseUrl: string): string {
+  const url = new URL(baseUrl);
+  url.pathname = `${url.pathname.replace(/\/$/, "")}/models`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+
+function countModels(body: unknown): null | number {
+  if (Array.isArray(body)) return body.length;
+  if (!body || typeof body !== "object") return null;
+
+  const data = (body as { data?: unknown }).data;
+  if (Array.isArray(data)) return data.length;
+
+  const models = (body as { models?: unknown }).models;
+  if (Array.isArray(models)) return models.length;
+
+  return null;
+}
+
 function createProvider(config: AIProviderConfig) {
  switch (config.type) {
    case "anthropic":
@@ -56,14 +137,14 @@ function createProvider(config: AIProviderConfig) {
  }
 }

-function getEnabledProviders(db: Database): Array<{
+function getProviders(db: Database): Array<{
  api_key: string;
  base_url: string;
  id: string;
  name: string;
  type: "anthropic" | "openai" | "openai-compatible";
 }> {
-  const stmt = db.prepare("SELECT id, name, type, base_url, api_key FROM providers WHERE enabled = 1");
+  const stmt = db.prepare("SELECT id, name, type, base_url, api_key FROM providers");
  return stmt.all() as Array<{
    api_key: string;
    base_url: string;
@@ -72,3 +153,16 @@ function getEnabledProviders(db: Database): Array<{
    type: "anthropic" | "openai" | "openai-compatible";
  }>;
 }
+
+async function probeBaseUrl(baseUrl: string): Promise<{ message: string; ok: boolean }> {
+  try {
+    await fetch(baseUrl, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5000),
+    });
+    return { message: "Base URL 可连接", ok: true };
+  } catch (e: unknown) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { message: `Base URL 不可达：${msg}`, ok: false };
+  }
+}
--- a/src/server/db/models.ts
+++ b/src/server/db/models.ts
@@ -36,7 +36,6 @@ export function createModel(
        capabilities: JSON.stringify(capabilities),
        contextLength: request.contextLength ?? null,
        createdAt: now,
-        enabled: true,
        id,
        maxOutputTokens: request.maxOutputTokens ?? null,
        modelId,
@@ -66,32 +65,6 @@ export function deleteModel(raw: Database, id: string): { error: string; status:
  return { success: true };
 }

-export function disableModel(raw: Database, id: string): { error: string; status: number } | { model: Model } {
-  const db = wrap(raw);
-  const existing = db.select().from(models).where(eq(models.id, id)).get();
-  if (!existing) return { error: "模型不存在", status: 404 };
-  if (!existing.enabled) return { error: "模型已禁用", status: 409 };
-
-  const now = new Date().toISOString();
-  db.update(models).set({ enabled: false, updatedAt: now }).where(eq(models.id, id)).run();
-
-  const updated = db.select().from(models).where(eq(models.id, id)).get();
-  return { model: toModel(updated!) };
-}
-
-export function enableModel(raw: Database, id: string): { error: string; status: number } | { model: Model } {
-  const db = wrap(raw);
-  const existing = db.select().from(models).where(eq(models.id, id)).get();
-  if (!existing) return { error: "模型不存在", status: 404 };
-  if (existing.enabled) return { error: "模型已启用", status: 409 };
-
-  const now = new Date().toISOString();
-  db.update(models).set({ enabled: true, updatedAt: now }).where(eq(models.id, id)).run();
-
-  const updated = db.select().from(models).where(eq(models.id, id)).get();
-  return { model: toModel(updated!) };
-}
-
 export function getModel(raw: Database, id: string): { error: string; status: number } | { model: Model } {
  const db = wrap(raw);
  const row = db.select().from(models).where(eq(models.id, id)).get();
@@ -222,7 +195,6 @@ function toModel(row: typeof models.$inferSelect): Model {
    capabilities: JSON.parse(row.capabilities) as ModelCapability[],
    contextLength: row.contextLength,
    createdAt: row.createdAt,
-    enabled: row.enabled,
    id: row.id,
    maxOutputTokens: row.maxOutputTokens,
    modelId: row.modelId,
--- a/src/server/db/providers.ts
+++ b/src/server/db/providers.ts
@@ -3,7 +3,7 @@ import type Database from "bun:sqlite";
 import { and, desc, eq, like, sql } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/bun-sqlite";

-import type { CreateProviderRequest, Provider, UpdateProviderRequest } from "../../shared/api";
+import type { CreateProviderRequest, Provider, ProviderOption, UpdateProviderRequest } from "../../shared/api";

 import { providers } from "./schema";

@@ -30,7 +30,6 @@ export function createProvider(
        apiKey,
        baseUrl,
        createdAt: now,
-        enabled: true,
        id,
        name,
        type: request.type,
@@ -58,32 +57,6 @@ export function deleteProvider(raw: Database, id: string): { error: string; stat
  return { success: true };
 }

-export function disableProvider(raw: Database, id: string): { error: string; status: number } | { provider: Provider } {
-  const db = wrap(raw);
-  const existing = db.select().from(providers).where(eq(providers.id, id)).get();
-  if (!existing) return { error: "供应商不存在", status: 404 };
-  if (!existing.enabled) return { error: "供应商已禁用", status: 409 };
-
-  const now = new Date().toISOString();
-  db.update(providers).set({ enabled: false, updatedAt: now }).where(eq(providers.id, id)).run();
-
-  const updated = db.select().from(providers).where(eq(providers.id, id)).get();
-  return { provider: toProvider(updated!) };
-}
-
-export function enableProvider(raw: Database, id: string): { error: string; status: number } | { provider: Provider } {
-  const db = wrap(raw);
-  const existing = db.select().from(providers).where(eq(providers.id, id)).get();
-  if (!existing) return { error: "供应商不存在", status: 404 };
-  if (existing.enabled) return { error: "供应商已启用", status: 409 };
-
-  const now = new Date().toISOString();
-  db.update(providers).set({ enabled: true, updatedAt: now }).where(eq(providers.id, id)).run();
-
-  const updated = db.select().from(providers).where(eq(providers.id, id)).get();
-  return { provider: toProvider(updated!) };
-}
-
 export function getProvider(raw: Database, id: string): { error: string; status: number } | { provider: Provider } {
  const db = wrap(raw);
  const row = db.select().from(providers).where(eq(providers.id, id)).get();
@@ -92,6 +65,17 @@ export function getProvider(raw: Database, id: string): { error: string; status:
  return { provider: toProvider(row) };
 }

+export function listProviderOptions(raw: Database): ProviderOption[] {
+  const db = wrap(raw);
+  const rows = db
+    .select({ id: providers.id, name: providers.name, type: providers.type })
+    .from(providers)
+    .orderBy(desc(providers.createdAt))
+    .all();
+
+  return rows;
+}
+
 export function listProviders(
  raw: Database,
  options: { keyword?: string; page: number; pageSize: number },
@@ -189,7 +173,6 @@ function toProvider(row: typeof providers.$inferSelect): Provider {
    apiKey: row.apiKey,
    baseUrl: row.baseUrl,
    createdAt: row.createdAt,
-    enabled: row.enabled,
    id: row.id,
    name: row.name,
    type: row.type,
--- a/src/server/db/schema.ts
+++ b/src/server/db/schema.ts
@@ -16,7 +16,6 @@ export const providers = sqliteTable("providers", {
  apiKey: text("api_key").notNull(),
  baseUrl: text("base_url").notNull(),
  createdAt: text("created_at").notNull(),
-  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
  id: text("id").primaryKey(),
  name: text("name").notNull().unique(),
  type: text("type", { enum: ["anthropic", "openai", "openai-compatible"] })
@@ -31,7 +30,6 @@ export const models = sqliteTable(
    capabilities: text("capabilities").notNull(),
    contextLength: integer("context_length"),
    createdAt: text("created_at").notNull(),
-    enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
    id: text("id").primaryKey(),
    maxOutputTokens: integer("max_output_tokens"),
    modelId: text("model_id").notNull(),
--- a/src/server/routes/models/create.ts
+++ b/src/server/routes/models/create.ts
@@ -38,6 +38,12 @@ export async function handleCreateModel(req: Request, db: Database, mode: Runtim
    return jsonResponse(createApiError(`Invalid capabilities: ${invalidCaps.join(", ")}`, 400), { mode, status: 400 });
  }

+  const numberError = validateOptionalPositiveInteger("contextLength", body.contextLength);
+  if (numberError) return jsonResponse(createApiError(numberError, 400), { mode, status: 400 });
+
+  const tokenError = validateOptionalPositiveInteger("maxOutputTokens", body.maxOutputTokens);
+  if (tokenError) return jsonResponse(createApiError(tokenError, 400), { mode, status: 400 });
+
  const result = createModel(db, body);
  if ("error" in result) {
    return jsonResponse(createApiError(result.error, result.status), { mode, status: result.status });
@@ -45,3 +51,9 @@ export async function handleCreateModel(req: Request, db: Database, mode: Runtim

  return jsonResponse(result, { mode, status: 201 });
 }
+
+function validateOptionalPositiveInteger(field: string, value: null | number | undefined): null | string {
+  if (value === undefined || value === null) return null;
+  if (!Number.isInteger(value) || value <= 0) return `${field} must be a positive integer`;
+  return null;
+}
--- a/src/server/routes/models/disable.ts
+++ b/src/server/routes/models/disable.ts
@@ -1,22 +0,0 @@
-import type Database from "bun:sqlite";
-
-import type { RuntimeMode } from "../../../shared/api";
-
-import { disableModel } from "../../db/models";
-import { createApiError, jsonResponse } from "../../helpers";
-import { validateIdParam } from "../../middleware";
-
-export function handleDisableModel(req: Request, db: Database, mode: RuntimeMode): Response {
-  const url = new URL(req.url);
-  const idStr = url.pathname.split("/")[3];
-
-  const validated = validateIdParam(idStr ?? "", mode);
-  if (validated instanceof Response) return validated;
-
-  const result = disableModel(db, validated.id);
-  if ("error" in result) {
-    return jsonResponse(createApiError(result.error, result.status), { mode, status: result.status });
-  }
-
-  return jsonResponse(result, { mode });
-}
--- a/src/server/routes/models/enable.ts
+++ b/src/server/routes/models/enable.ts
@@ -1,22 +0,0 @@
-import type Database from "bun:sqlite";
-
-import type { RuntimeMode } from "../../../shared/api";
-
-import { enableModel } from "../../db/models";
-import { createApiError, jsonResponse } from "../../helpers";
-import { validateIdParam } from "../../middleware";
-
-export function handleEnableModel(req: Request, db: Database, mode: RuntimeMode): Response {
-  const url = new URL(req.url);
-  const idStr = url.pathname.split("/")[3];
-
-  const validated = validateIdParam(idStr ?? "", mode);
-  if (validated instanceof Response) return validated;
-
-  const result = enableModel(db, validated.id);
-  if ("error" in result) {
-    return jsonResponse(createApiError(result.error, result.status), { mode, status: result.status });
-  }
-
-  return jsonResponse(result, { mode });
-}
--- a/src/server/routes/models/test.ts
+++ b/src/server/routes/models/test.ts
@@ -0,0 +1,42 @@
+import type Database from "bun:sqlite";
+
+import type { RuntimeMode, TestModelRequest } from "../../../shared/api";
+
+import { testModelConnection } from "../../ai/registry";
+import { getProvider } from "../../db/providers";
+import { createApiError, jsonResponse } from "../../helpers";
+
+export async function handleTestModelConfig(req: Request, db: Database, mode: RuntimeMode): Promise<Response> {
+  let body: TestModelRequest;
+  try {
+    body = (await req.json()) as TestModelRequest;
+  } catch {
+    return jsonResponse(createApiError("Invalid JSON body", 400), { mode, status: 400 });
+  }
+
+  if (!body.providerId || typeof body.providerId !== "string") {
+    return jsonResponse(createApiError("providerId is required", 400), { mode, status: 400 });
+  }
+
+  if (!body.modelId || typeof body.modelId !== "string") {
+    return jsonResponse(createApiError("modelId is required", 400), { mode, status: 400 });
+  }
+
+  const providerResult = getProvider(db, body.providerId);
+  if ("error" in providerResult) {
+    return jsonResponse(createApiError(providerResult.error, providerResult.status), {
+      mode,
+      status: providerResult.status,
+    });
+  }
+
+  const testResult = await testModelConnection({
+    apiKey: providerResult.provider.apiKey,
+    baseUrl: providerResult.provider.baseUrl,
+    modelId: body.modelId,
+    name: providerResult.provider.name,
+    type: providerResult.provider.type,
+  });
+
+  return jsonResponse({ modelTestResponse: testResult }, { mode });
+}
--- a/src/server/routes/models/update.ts
+++ b/src/server/routes/models/update.ts
@@ -34,6 +34,12 @@ export async function handleUpdateModel(req: Request, db: Database, mode: Runtim
    }
  }

+  const numberError = validateOptionalPositiveInteger("contextLength", body.contextLength);
+  if (numberError) return jsonResponse(createApiError(numberError, 400), { mode, status: 400 });
+
+  const tokenError = validateOptionalPositiveInteger("maxOutputTokens", body.maxOutputTokens);
+  if (tokenError) return jsonResponse(createApiError(tokenError, 400), { mode, status: 400 });
+
  const result = updateModel(db, validated.id, body);
  if ("error" in result) {
    return jsonResponse(createApiError(result.error, result.status), { mode, status: result.status });
@@ -41,3 +47,9 @@ export async function handleUpdateModel(req: Request, db: Database, mode: Runtim

  return jsonResponse(result, { mode });
 }
+
+function validateOptionalPositiveInteger(field: string, value: null | number | undefined): null | string {
+  if (value === undefined || value === null) return null;
+  if (!Number.isInteger(value) || value <= 0) return `${field} must be a positive integer`;
+  return null;
+}
--- a/src/server/routes/providers/disable.ts
+++ b/src/server/routes/providers/disable.ts
@@ -1,22 +0,0 @@
-import type Database from "bun:sqlite";
-
-import type { RuntimeMode } from "../../../shared/api";
-
-import { disableProvider } from "../../db/providers";
-import { createApiError, jsonResponse } from "../../helpers";
-import { validateIdParam } from "../../middleware";
-
-export function handleDisableProvider(req: Request, db: Database, mode: RuntimeMode): Response {
-  const url = new URL(req.url);
-  const idStr = url.pathname.split("/")[3];
-
-  const validated = validateIdParam(idStr ?? "", mode);
-  if (validated instanceof Response) return validated;
-
-  const result = disableProvider(db, validated.id);
-  if ("error" in result) {
-    return jsonResponse(createApiError(result.error, result.status), { mode, status: result.status });
-  }
-
-  return jsonResponse(result, { mode });
-}
--- a/src/server/routes/providers/enable.ts
+++ b/src/server/routes/providers/enable.ts
@@ -1,22 +0,0 @@
-import type Database from "bun:sqlite";
-
-import type { RuntimeMode } from "../../../shared/api";
-
-import { enableProvider } from "../../db/providers";
-import { createApiError, jsonResponse } from "../../helpers";
-import { validateIdParam } from "../../middleware";
-
-export function handleEnableProvider(req: Request, db: Database, mode: RuntimeMode): Response {
-  const url = new URL(req.url);
-  const idStr = url.pathname.split("/")[3];
-
-  const validated = validateIdParam(idStr ?? "", mode);
-  if (validated instanceof Response) return validated;
-
-  const result = enableProvider(db, validated.id);
-  if ("error" in result) {
-    return jsonResponse(createApiError(result.error, result.status), { mode, status: result.status });
-  }
-
-  return jsonResponse(result, { mode });
-}
--- a/src/server/routes/providers/options.ts
+++ b/src/server/routes/providers/options.ts
@@ -0,0 +1,10 @@
+import type Database from "bun:sqlite";
+
+import type { RuntimeMode } from "../../../shared/api";
+
+import { listProviderOptions } from "../../db/providers";
+import { jsonResponse } from "../../helpers";
+
+export function handleListProviderOptions(db: Database, mode: RuntimeMode): Response {
+  return jsonResponse({ items: listProviderOptions(db) }, { mode });
+}
--- a/src/server/routes/providers/test.ts
+++ b/src/server/routes/providers/test.ts
@@ -1,34 +1,50 @@
 import type Database from "bun:sqlite";

-import type { RuntimeMode } from "../../../shared/api";
+import type { CreateProviderRequest, RuntimeMode } from "../../../shared/api";

 import { testProviderConnection } from "../../ai/registry";
-import { getProvider } from "../../db/providers";
 import { createApiError, jsonResponse } from "../../helpers";
-import { validateIdParam } from "../../middleware";

-export async function handleTestProvider(req: Request, db: Database, mode: RuntimeMode): Promise<Response> {
-  const url = new URL(req.url);
-  const idStr = url.pathname.split("/")[3];
-
-  const validated = validateIdParam(idStr ?? "", mode);
+export async function handleTestProviderConfig(req: Request, _db: Database, mode: RuntimeMode): Promise<Response> {
+  const validated = await readProviderConfig(req, mode);
  if (validated instanceof Response) return validated;

-  const providerResult = getProvider(db, validated.id);
-  if ("error" in providerResult) {
-    return jsonResponse(createApiError(providerResult.error, providerResult.status), {
-      mode,
-      status: providerResult.status,
-    });
-  }
-
-  const provider = providerResult.provider;
  const testResult = await testProviderConnection({
-    apiKey: provider.apiKey,
-    baseUrl: provider.baseUrl,
-    name: provider.name,
-    type: provider.type,
+    apiKey: validated.apiKey,
+    baseUrl: validated.baseUrl,
+    name: validated.name,
+    type: validated.type,
  });

  return jsonResponse({ providerTestResponse: testResult }, { mode });
 }
+
+async function readProviderConfig(req: Request, mode: RuntimeMode): Promise<CreateProviderRequest | Response> {
+  let body: CreateProviderRequest;
+  try {
+    body = (await req.json()) as CreateProviderRequest;
+  } catch {
+    return jsonResponse(createApiError("Invalid JSON body", 400), { mode, status: 400 });
+  }
+
+  if (!body.name || typeof body.name !== "string") {
+    return jsonResponse(createApiError("name is required", 400), { mode, status: 400 });
+  }
+
+  if (!body.baseUrl || typeof body.baseUrl !== "string") {
+    return jsonResponse(createApiError("baseUrl is required", 400), { mode, status: 400 });
+  }
+
+  if (!body.apiKey || typeof body.apiKey !== "string") {
+    return jsonResponse(createApiError("apiKey is required", 400), { mode, status: 400 });
+  }
+
+  if (!body.type || !["anthropic", "openai", "openai-compatible"].includes(body.type)) {
+    return jsonResponse(createApiError("type must be one of: openai, anthropic, openai-compatible", 400), {
+      mode,
+      status: 400,
+    });
+  }
+
+  return body;
+}
--- a/src/server/server.ts
+++ b/src/server/server.ts
@@ -67,16 +67,10 @@ export function startServer(options: StartServerOptions) {
          return handleUpdateModel(req, db, mode);
        },
      },
-      "/api/models/:id/disable": {
+      "/api/models/test": {
        POST: async (req) => {
-          const { handleDisableModel } = await import("./routes/models/disable");
-          return handleDisableModel(req, db, mode);
-        },
-      },
-      "/api/models/:id/enable": {
-        POST: async (req) => {
-          const { handleEnableModel } = await import("./routes/models/enable");
-          return handleEnableModel(req, db, mode);
+          const { handleTestModelConfig } = await import("./routes/models/test");
+          return handleTestModelConfig(req, db, mode);
        },
      },
      "/api/projects": {
@@ -139,22 +133,16 @@ export function startServer(options: StartServerOptions) {
          return handleUpdateProvider(req, db, mode);
        },
      },
-      "/api/providers/:id/disable": {
-        POST: async (req) => {
-          const { handleDisableProvider } = await import("./routes/providers/disable");
-          return handleDisableProvider(req, db, mode);
+      "/api/providers/options": {
+        GET: async () => {
+          const { handleListProviderOptions } = await import("./routes/providers/options");
+          return handleListProviderOptions(db, mode);
        },
      },
-      "/api/providers/:id/enable": {
+      "/api/providers/test": {
        POST: async (req) => {
-          const { handleEnableProvider } = await import("./routes/providers/enable");
-          return handleEnableProvider(req, db, mode);
-        },
-      },
-      "/api/providers/:id/test": {
-        POST: async (req) => {
-          const { handleTestProvider } = await import("./routes/providers/test");
-          return handleTestProvider(req, db, mode);
+          const { handleTestProviderConfig } = await import("./routes/providers/test");
+          return handleTestProviderConfig(req, db, mode);
        },
      },
    },
--- a/src/shared/api.ts
+++ b/src/shared/api.ts
@@ -40,7 +40,6 @@ export interface Model {
  capabilities: ModelCapability[];
  contextLength: null | number;
  createdAt: string;
-  enabled: boolean;
  id: string;
  maxOutputTokens: null | number;
  modelId: string;
@@ -81,6 +80,15 @@ export interface ModelResponse {
  model: Model;
 }

+export interface ModelTestResponse {
+  message: string;
+  ok: boolean;
+}
+
+export interface ModelTestResultResponse {
+  modelTestResponse: ModelTestResponse;
+}
+
 export interface Project {
  archivedAt: null | string;
  createdAt: string;
@@ -108,7 +116,6 @@ export interface Provider {
  apiKey: string;
  baseUrl: string;
  createdAt: string;
-  enabled: boolean;
  id: string;
  name: string;
  type: ProviderType;
@@ -122,6 +129,16 @@ export interface ProviderListResponse {
  total: number;
 }

+export interface ProviderOption {
+  id: string;
+  name: string;
+  type: ProviderType;
+}
+
+export interface ProviderOptionsResponse {
+  items: ProviderOption[];
+}
+
 export interface ProviderResponse {
  provider: Provider;
 }
@@ -131,10 +148,19 @@ export interface ProviderTestResponse {
  ok: boolean;
 }

+export interface ProviderTestResultResponse {
+  providerTestResponse: ProviderTestResponse;
+}
+
 export type ProviderType = "anthropic" | "openai" | "openai-compatible";

 export type RuntimeMode = "development" | "production" | "test";

+export interface TestModelRequest {
+  modelId: string;
+  providerId: string;
+}
+
 export interface UpdateModelRequest {
  capabilities?: ModelCapability[];
  contextLength?: null | number;
--- a/src/web/hooks/use-models.ts
+++ b/src/web/hooks/use-models.ts
@@ -1,6 +1,15 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";

-import type { CreateModelRequest, Model, ModelListResponse, ModelResponse, UpdateModelRequest } from "../../shared/api";
+import type {
+  CreateModelRequest,
+  Model,
+  ModelListResponse,
+  ModelResponse,
+  ModelTestResponse,
+  ModelTestResultResponse,
+  TestModelRequest,
+  UpdateModelRequest,
+} from "../../shared/api";

 const MODELS_KEY = ["models"] as const;

@@ -21,16 +30,6 @@ export async function deleteModel(id: string): Promise<void> {
  }
 }

-export async function disableModel(id: string): Promise<Model> {
-  const response = await fetch(`/api/models/${id}/disable`, { method: "POST" });
-  return handleResponse(response);
-}
-
-export async function enableModel(id: string): Promise<Model> {
-  const response = await fetch(`/api/models/${id}/enable`, { method: "POST" });
-  return handleResponse(response);
-}
-
 export async function fetchModel(id: string): Promise<Model> {
  const response = await fetch(`/api/models/${id}`);
  return handleResponse(response);
@@ -57,6 +56,20 @@ export async function fetchModelList(params: {
  return response.json() as Promise<ModelListResponse>;
 }

+export async function testModelConnection(data: TestModelRequest): Promise<ModelTestResponse> {
+  const response = await fetch("/api/models/test", {
+    body: JSON.stringify(data),
+    headers: { "Content-Type": "application/json" },
+    method: "POST",
+  });
+  if (!response.ok) {
+    const body = (await response.json().catch(() => null)) as null | { error?: string };
+    throw new Error(body?.error ?? `HTTP ${response.status}`);
+  }
+  const result = (await response.json()) as ModelTestResultResponse;
+  return result.modelTestResponse;
+}
+
 export async function updateModel(id: string, data: UpdateModelRequest): Promise<Model> {
  const response = await fetch(`/api/models/${id}`, {
    body: JSON.stringify(data),
@@ -86,26 +99,6 @@ export function useDeleteModel() {
  });
 }

-export function useDisableModel() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: disableModel,
-    onSuccess: () => {
-      void queryClient.invalidateQueries({ queryKey: MODELS_KEY });
-    },
-  });
-}
-
-export function useEnableModel() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: enableModel,
-    onSuccess: () => {
-      void queryClient.invalidateQueries({ queryKey: MODELS_KEY });
-    },
-  });
-}
-
 export function useModel(id: string) {
  return useQuery({
    enabled: !!id,
@@ -121,6 +114,12 @@ export function useModelList(params: { keyword?: string; page?: number; pageSize
  });
 }

+export function useTestModelConnection() {
+  return useMutation({
+    mutationFn: testModelConnection,
+  });
+}
+
 export function useUpdateModel() {
  const queryClient = useQueryClient();
  return useMutation({
--- a/src/web/hooks/use-providers.ts
+++ b/src/web/hooks/use-providers.ts
@@ -4,8 +4,10 @@ import type {
  CreateProviderRequest,
  Provider,
  ProviderListResponse,
+  ProviderOptionsResponse,
  ProviderResponse,
  ProviderTestResponse,
+  ProviderTestResultResponse,
  UpdateProviderRequest,
 } from "../../shared/api";

@@ -29,16 +31,6 @@ export async function deleteProvider(id: string): Promise<void> {
  }
 }

-export async function disableProvider(id: string): Promise<Provider> {
-  const response = await fetch(`/api/providers/${id}/disable`, { method: "POST" });
-  return handleResponse(response);
-}
-
-export async function enableProvider(id: string): Promise<Provider> {
-  const response = await fetch(`/api/providers/${id}/enable`, { method: "POST" });
-  return handleResponse(response);
-}
-
 export async function fetchProvider(id: string): Promise<Provider> {
  const response = await fetch(`/api/providers/${id}`);
  return handleResponse(response);
@@ -63,14 +55,27 @@ export async function fetchProviderList(params: {
  return response.json() as Promise<ProviderListResponse>;
 }

-export async function testProviderConnection(id: string): Promise<ProviderTestResponse> {
-  const response = await fetch(`/api/providers/${id}/test`, { method: "POST" });
+export async function fetchProviderOptions(): Promise<ProviderOptionsResponse> {
+  const response = await fetch("/api/providers/options");
  if (!response.ok) {
    const body = (await response.json().catch(() => null)) as null | { error?: string };
    throw new Error(body?.error ?? `HTTP ${response.status}`);
  }
-  const data = (await response.json()) as { providerTestResponse: ProviderTestResponse };
-  return data.providerTestResponse;
+  return response.json() as Promise<ProviderOptionsResponse>;
+}
+
+export async function testProviderConfig(data: CreateProviderRequest): Promise<ProviderTestResponse> {
+  const response = await fetch("/api/providers/test", {
+    body: JSON.stringify(data),
+    headers: { "Content-Type": "application/json" },
+    method: "POST",
+  });
+  if (!response.ok) {
+    const body = (await response.json().catch(() => null)) as null | { error?: string };
+    throw new Error(body?.error ?? `HTTP ${response.status}`);
+  }
+  const result = (await response.json()) as ProviderTestResultResponse;
+  return result.providerTestResponse;
 }

 export async function updateProvider(id: string, data: UpdateProviderRequest): Promise<Provider> {
@@ -103,26 +108,6 @@ export function useDeleteProvider() {
  });
 }

-export function useDisableProvider() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: disableProvider,
-    onSuccess: () => {
-      void queryClient.invalidateQueries({ queryKey: PROVIDERS_KEY });
-    },
-  });
-}
-
-export function useEnableProvider() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: enableProvider,
-    onSuccess: () => {
-      void queryClient.invalidateQueries({ queryKey: PROVIDERS_KEY });
-    },
-  });
-}
-
 export function useProvider(id: string) {
  return useQuery({
    enabled: !!id,
@@ -138,9 +123,16 @@ export function useProviderList(params: { keyword?: string; page?: number; pageS
  });
 }

-export function useTestProviderConnection() {
+export function useProviderOptions() {
+  return useQuery({
+    queryFn: fetchProviderOptions,
+    queryKey: [...PROVIDERS_KEY, "options"],
+  });
+}
+
+export function useTestProviderConfig() {
  return useMutation({
-    mutationFn: testProviderConnection,
+    mutationFn: testProviderConfig,
  });
 }

--- a/src/web/pages/models/components/ModelFormModal.tsx
+++ b/src/web/pages/models/components/ModelFormModal.tsx
@@ -1,7 +1,15 @@
 import { App as AntApp, Button, Checkbox, Col, Form, Input, InputNumber, Modal, Row, Select, Space } from "antd";
 import { useEffect, useState } from "react";

-import type { CreateModelRequest, Model, ModelCapability, Provider, UpdateModelRequest } from "../../../../shared/api";
+import type {
+  CreateModelRequest,
+  Model,
+  ModelCapability,
+  ModelTestResponse,
+  ProviderOption,
+  TestModelRequest,
+  UpdateModelRequest,
+} from "../../../../shared/api";

 interface FormValues {
  capabilities: ModelCapability[];
@@ -19,11 +27,15 @@ interface ModelFormModalProps {
  onOpenChange: (open: boolean) => void;
  onUpdate: (args: { data: UpdateModelRequest; id: string }) => Promise<unknown>;
  open: boolean;
-  providers: Provider[];
+  providers: ProviderOption[];
+  providersError: Error | null;
+  providersLoading: boolean;
  submitting: boolean;
-  testConnection?: (providerId: string) => Promise<unknown>;
+  testModelConnection?: (data: TestModelRequest) => Promise<ModelTestResponse>;
 }

+const DEFAULT_CAPABILITIES: ModelCapability[] = ["text", "reasoning"];
+
 const CAPABILITY_OPTIONS: Array<{ label: string; value: ModelCapability }> = [
  { label: "文本", value: "text" },
  { label: "推理", value: "reasoning" },
@@ -43,8 +55,10 @@ export function ModelFormModal({
  onUpdate,
  open,
  providers,
+  providersError,
+  providersLoading,
  submitting,
-  testConnection,
+  testModelConnection,
 }: ModelFormModalProps) {
  const { message } = AntApp.useApp();
  const [form] = Form.useForm<FormValues>();
@@ -63,6 +77,7 @@ export function ModelFormModal({
      });
    } else {
      form.resetFields();
+      form.setFieldsValue({ capabilities: DEFAULT_CAPABILITIES });
    }
  }, [editingModel, form, open]);

@@ -102,16 +117,25 @@ export function ModelFormModal({
  };

  const handleTest = async () => {
-    if (!testConnection) return;
+    if (!testModelConnection) return;
    const providerId: unknown = form.getFieldValue("providerId");
+    const modelId: unknown = form.getFieldValue("modelId");
    if (typeof providerId !== "string" || !providerId) {
      message.warning("请先选择供应商");
      return;
    }
+    if (typeof modelId !== "string" || !modelId) {
+      message.warning("请先输入模型 ID");
+      return;
+    }
    setTesting(true);
    try {
-      const result = await testConnection(providerId);
-      message.success((result as { message: string }).message);
+      const result = await testModelConnection({ modelId, providerId });
+      if (result.ok) {
+        message.success(result.message);
+      } else {
+        message.error(result.message);
+      }
    } catch (err) {
      message.error((err as Error).message);
    } finally {
@@ -119,7 +143,7 @@ export function ModelFormModal({
    }
  };

-  const providerOptions = providers.filter((p) => p.enabled).map((p) => ({ label: p.name, value: p.id }));
+  const providerOptions = providers.map((p) => ({ label: p.name, value: p.id }));

  return (
    <Modal
@@ -141,7 +165,15 @@ export function ModelFormModal({
          <Input placeholder="请输入模型名称" />
        </Form.Item>
        <Form.Item label="所属供应商" name="providerId" rules={[{ message: "请选择供应商", required: true }]}>
-          <Select options={providerOptions} placeholder="请选择供应商" />
+          <Select
+            loading={providersLoading}
+            notFoundContent={getProviderNotFoundContent(providersLoading, providersError)}
+            optionFilterProp="label"
+            options={providerOptions}
+            placeholder="请选择供应商"
+            showSearch
+            status={providersError ? "error" : undefined}
+          />
        </Form.Item>
        <Form.Item
          label="模型 ID"
@@ -152,22 +184,28 @@ export function ModelFormModal({
        </Form.Item>
        <Form.Item label="能力标签" name="capabilities" rules={[{ message: "请至少选择一个能力标签", required: true }]}>
          <Checkbox.Group>
-            <Row>
+            <Row gutter={[8, 8]}>
              {CAPABILITY_OPTIONS.map((opt) => (
-                <Col key={opt.value} span={12}>
+                <Col key={opt.value} md={8} sm={12} xs={24}>
                  <Checkbox value={opt.value}>{opt.label}</Checkbox>
                </Col>
              ))}
            </Row>
          </Checkbox.Group>
        </Form.Item>
-        <Form.Item label="上下文长度" name="contextLength">
-          <InputNumber placeholder="可选" style={{ width: "100%" }} />
-        </Form.Item>
-        <Form.Item label="最大输出 Token" name="maxOutputTokens">
-          <InputNumber placeholder="可选" style={{ width: "100%" }} />
-        </Form.Item>
-        {editingModel && testConnection && (
+        <Row gutter={16}>
+          <Col sm={12} xs={24}>
+            <Form.Item label="上下文长度" name="contextLength" rules={[positiveIntegerRule("上下文长度")]}>
+              <InputNumber min={1} placeholder="可选" precision={0} styles={{ root: { width: "100%" } }} />
+            </Form.Item>
+          </Col>
+          <Col sm={12} xs={24}>
+            <Form.Item label="最大输出 Token" name="maxOutputTokens" rules={[positiveIntegerRule("最大输出 Token")]}>
+              <InputNumber min={1} placeholder="可选" precision={0} styles={{ root: { width: "100%" } }} />
+            </Form.Item>
+          </Col>
+        </Row>
+        {testModelConnection && (
          <Form.Item>
            <Space>
              <Button loading={testing} onClick={() => void handleTest()}>
@@ -180,3 +218,19 @@ export function ModelFormModal({
    </Modal>
  );
 }
+
+function getProviderNotFoundContent(loading: boolean, error: Error | null): string {
+  if (loading) return "正在加载供应商";
+  if (error) return `供应商加载失败：${error.message}`;
+  return "暂无供应商，请先新建供应商";
+}
+
+function positiveIntegerRule(label: string) {
+  return {
+    validator(_: unknown, value: null | number | undefined) {
+      if (value === undefined || value === null) return Promise.resolve();
+      if (Number.isInteger(value) && value > 0) return Promise.resolve();
+      return Promise.reject(new Error(`${label}必须为正整数`));
+    },
+  };
+}
--- a/src/web/pages/models/components/ModelTable.tsx
+++ b/src/web/pages/models/components/ModelTable.tsx
@@ -1,21 +1,19 @@
 import type { ColumnsType } from "antd/es/table";

-import { CheckCircleOutlined, DeleteOutlined, EditOutlined, StopOutlined } from "@ant-design/icons";
+import { DeleteOutlined, EditOutlined } from "@ant-design/icons";
 import { App as AntApp, Button, Popconfirm, Space, Table, Tag } from "antd";

-import type { Model, ModelListResponse, Provider } from "../../../../shared/api";
+import type { Model, ModelListResponse, ProviderOption } from "../../../../shared/api";

 interface ModelTableProps {
  data: ModelListResponse | undefined;
  loading: boolean;
  onDelete: (id: string) => Promise<unknown>;
-  onDisable: (id: string) => Promise<unknown>;
  onEdit: (model: Model) => void;
-  onEnable: (id: string) => Promise<unknown>;
  onPageChange: (page: number, pageSize: number) => void;
  page: number;
  pageSize: number;
-  providers: Provider[];
+  providers: ProviderOption[];
 }

 const CAPABILITY_LABELS: Record<string, string> = {
@@ -29,13 +27,12 @@ const CAPABILITY_LABELS: Record<string, string> = {
  "video-recognition": "视频识别",
 };

-function getProviderName(providerId: string, providers: Provider[]): string {
+function getProviderName(providerId: string, providers: ProviderOption[]): string {
  return providers.find((p) => p.id === providerId)?.name ?? providerId;
 }

 const COLUMNS: ColumnsType<Model> = [
-  { dataIndex: "name", ellipsis: true, title: "模型名称", width: 160 },
-  { dataIndex: "modelId", ellipsis: true, title: "模型 ID", width: 180 },
+  { dataIndex: "name", ellipsis: true, title: "名称", width: 180 },
  {
    dataIndex: "providerId",
    ellipsis: true,
@@ -45,27 +42,14 @@ const COLUMNS: ColumnsType<Model> = [
  {
    dataIndex: "capabilities",
    render: (value: string[]) =>
-      value.map((c) => (
-        <Tag key={c} style={{ marginBottom: 2 }}>
-          {CAPABILITY_LABELS[c] ?? c}
-        </Tag>
-      )),
+      value.length > 0 ? (
+        <Space size={[4, 4]} wrap>
+          {value.map((c) => (
+            <Tag key={c}>{CAPABILITY_LABELS[c] ?? c}</Tag>
+          ))}
+        </Space>
+      ) : null,
    title: "能力",
-    width: 200,
-  },
-  {
-    align: "center",
-    dataIndex: "enabled",
-    render: (value: boolean) => (value ? <Tag color="blue">已启用</Tag> : <Tag>已禁用</Tag>),
-    title: "状态",
-    width: 100,
-  },
-  {
-    align: "center",
-    dataIndex: "createdAt",
-    render: (_value: unknown, record: Model) => formatDatetime(record.createdAt),
-    title: "创建时间",
-    width: 185,
  },
 ];

@@ -73,9 +57,7 @@ export function ModelTable({
  data,
  loading,
  onDelete,
-  onDisable,
  onEdit,
-  onEnable,
  onPageChange,
  page,
  pageSize,
@@ -83,24 +65,6 @@ export function ModelTable({
 }: ModelTableProps) {
  const { message } = AntApp.useApp();

-  const handleEnable = async (id: string) => {
-    try {
-      await onEnable(id);
-      message.success("模型已启用");
-    } catch (err) {
-      message.error((err as Error).message);
-    }
-  };
-
-  const handleDisable = async (id: string) => {
-    try {
-      await onDisable(id);
-      message.success("模型已禁用");
-    } catch (err) {
-      message.error((err as Error).message);
-    }
-  };
-
  const handleDelete = async (id: string) => {
    try {
      await onDelete(id);
@@ -121,23 +85,11 @@ export function ModelTable({

  const operationColumn: ColumnsType<Model>[number] = {
    dataIndex: "op",
-    fixed: "right",
    render: (_value: unknown, record: Model) => (
      <Space size="small">
        <Button icon={<EditOutlined />} onClick={() => onEdit(record)} size="small" type="link">
          编辑
        </Button>
-        {record.enabled ? (
-          <Popconfirm onConfirm={() => void handleDisable(record.id)} title="确认禁用此模型？">
-            <Button color="orange" icon={<StopOutlined />} size="small" variant="link">
-              禁用
-            </Button>
-          </Popconfirm>
-        ) : (
-          <Button icon={<CheckCircleOutlined />} onClick={() => void handleEnable(record.id)} size="small" type="link">
-            启用
-          </Button>
-        )}
        <Popconfirm
          description="此操作不可恢复。"
          onConfirm={() => void handleDelete(record.id)}
@@ -150,7 +102,7 @@ export function ModelTable({
      </Space>
    ),
    title: "操作",
-    width: 220,
+    width: 180,
  };

  return (
@@ -167,13 +119,6 @@ export function ModelTable({
        total: data?.total ?? 0,
      }}
      rowKey="id"
-      scroll={{ x: 1100 }}
    />
  );
 }
-
-function formatDatetime(dateStr: string): string {
-  const d = new Date(dateStr);
-  const pad = (n: number) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-}
--- a/src/web/pages/models/components/ModelToolbar.tsx
+++ b/src/web/pages/models/components/ModelToolbar.tsx
@@ -1,34 +0,0 @@
-import { PlusOutlined } from "@ant-design/icons";
-import { Button, Flex, Input } from "antd";
-import { useState } from "react";
-
-interface ModelToolbarProps {
-  keyword: string;
-  onSearch: (value: string) => void;
-  onSearchClear: () => void;
-  openCreateDialog: () => void;
-}
-
-export function ModelToolbar({ keyword, onSearch, onSearchClear, openCreateDialog }: ModelToolbarProps) {
-  const [draftKeyword, setDraftKeyword] = useState(keyword);
-
-  return (
-    <Flex align="center" gap="small" justify="space-between" wrap="wrap">
-      <Input.Search
-        allowClear
-        enterButton="搜索"
-        onChange={(event) => setDraftKeyword(event.target.value)}
-        onClear={() => {
-          setDraftKeyword("");
-          onSearchClear();
-        }}
-        onSearch={(value) => onSearch(value)}
-        placeholder="搜索模型名称或 ID"
-        value={draftKeyword}
-      />
-      <Button icon={<PlusOutlined />} onClick={openCreateDialog} type="primary">
-        新建模型
-      </Button>
-    </Flex>
-  );
-}
--- a/src/web/pages/models/components/ModelsToolbar.tsx
+++ b/src/web/pages/models/components/ModelsToolbar.tsx
@@ -0,0 +1,53 @@
+import { PlusOutlined } from "@ant-design/icons";
+import { Button, Flex, Input, Tabs } from "antd";
+import { useState } from "react";
+
+interface ModelsToolbarProps {
+  activeTab: string;
+  keyword: string;
+  onSearch: (value: string) => void;
+  onSearchClear: () => void;
+  onTabChange: (key: string) => void;
+  openCreateDialog: () => void;
+}
+
+const TAB_ITEMS = [
+  { key: "models", label: "模型" },
+  { key: "providers", label: "供应商" },
+];
+
+export function ModelsToolbar({
+  activeTab,
+  keyword,
+  onSearch,
+  onSearchClear,
+  onTabChange,
+  openCreateDialog,
+}: ModelsToolbarProps) {
+  const [draftKeyword, setDraftKeyword] = useState(keyword);
+  const placeholder = activeTab === "providers" ? "搜索供应商名称" : "搜索模型名称或 ID";
+  const createLabel = activeTab === "providers" ? "新建供应商" : "新建模型";
+
+  return (
+    <Flex align="center" gap="var(--ant-margin-lg)" justify="space-between" wrap="wrap">
+      <Tabs activeKey={activeTab} items={TAB_ITEMS} onChange={onTabChange} />
+      <Flex align="center" gap="small">
+        <Input.Search
+          allowClear
+          enterButton="搜索"
+          onChange={(event) => setDraftKeyword(event.target.value)}
+          onClear={() => {
+            setDraftKeyword("");
+            onSearchClear();
+          }}
+          onSearch={(value) => onSearch(value)}
+          placeholder={placeholder}
+          value={draftKeyword}
+        />
+        <Button icon={<PlusOutlined />} onClick={openCreateDialog} type="primary">
+          {createLabel}
+        </Button>
+      </Flex>
+    </Flex>
+  );
+}
--- a/src/web/pages/models/components/ProviderFormModal.tsx
+++ b/src/web/pages/models/components/ProviderFormModal.tsx
@@ -1,7 +1,13 @@
-import { App as AntApp, Form, Input, Modal, Select } from "antd";
-import { useEffect } from "react";
+import { App as AntApp, Button, Form, Input, Modal, Select, Space } from "antd";
+import { useEffect, useState } from "react";

-import type { CreateProviderRequest, Provider, ProviderType, UpdateProviderRequest } from "../../../../shared/api";
+import type {
+  CreateProviderRequest,
+  Provider,
+  ProviderTestResponse,
+  ProviderType,
+  UpdateProviderRequest,
+} from "../../../../shared/api";

 interface FormValues {
  apiKey: string;
@@ -15,6 +21,7 @@ interface ProviderFormModalProps {
  onCancel: () => void;
  onCreate: (data: CreateProviderRequest) => Promise<unknown>;
  onOpenChange: (open: boolean) => void;
+  onTest: (data: CreateProviderRequest) => Promise<ProviderTestResponse>;
  onUpdate: (args: { data: UpdateProviderRequest; id: string }) => Promise<unknown>;
  open: boolean;
  submitting: boolean;
@@ -31,12 +38,14 @@ export function ProviderFormModal({
  onCancel,
  onCreate,
  onOpenChange,
+  onTest,
  onUpdate,
  open,
  submitting,
 }: ProviderFormModalProps) {
  const { message } = AntApp.useApp();
  const [form] = Form.useForm<FormValues>();
+  const [testing, setTesting] = useState(false);

  useEffect(() => {
    if (!open) return;
@@ -49,6 +58,7 @@ export function ProviderFormModal({
      });
    } else {
      form.resetFields();
+      form.setFieldsValue({ type: "openai-compatible" });
    }
  }, [editingProvider, form, open]);

@@ -80,6 +90,30 @@ export function ProviderFormModal({
    }
  };

+  const handleTest = async () => {
+    try {
+      const values = await form.validateFields(["name", "type", "baseUrl", "apiKey"]);
+      setTesting(true);
+      const result = await onTest({
+        apiKey: values.apiKey,
+        baseUrl: values.baseUrl,
+        name: values.name,
+        type: values.type,
+      });
+      if (result.ok) {
+        message.success(result.message);
+      } else {
+        message.error(result.message);
+      }
+    } catch (err) {
+      if (err instanceof Error) {
+        message.error(err.message);
+      }
+    } finally {
+      setTesting(false);
+    }
+  };
+
  return (
    <Modal
      confirmLoading={submitting}
@@ -107,6 +141,13 @@ export function ProviderFormModal({
        <Form.Item label="API Key" name="apiKey" rules={[{ message: "请输入 API Key", required: true }]}>
          <Input.Password placeholder="请输入 API Key" />
        </Form.Item>
+        <Form.Item>
+          <Space>
+            <Button loading={testing} onClick={() => void handleTest()}>
+              测试连接
+            </Button>
+          </Space>
+        </Form.Item>
      </Form>
    </Modal>
  );
--- a/src/web/pages/models/components/ProviderTable.tsx
+++ b/src/web/pages/models/components/ProviderTable.tsx
@@ -1,13 +1,7 @@
 import type { ColumnsType } from "antd/es/table";

-import {
-  CheckCircleOutlined,
-  DeleteOutlined,
-  EditOutlined,
-  StopOutlined,
-  ThunderboltOutlined,
-} from "@ant-design/icons";
-import { App as AntApp, Button, Popconfirm, Space, Table, Tag, Tooltip } from "antd";
+import { DeleteOutlined, EditOutlined } from "@ant-design/icons";
+import { App as AntApp, Button, Popconfirm, Space, Table } from "antd";

 import type { Provider, ProviderListResponse } from "../../../../shared/api";

@@ -15,11 +9,8 @@ interface ProviderTableProps {
  data: ProviderListResponse | undefined;
  loading: boolean;
  onDelete: (id: string) => Promise<unknown>;
-  onDisable: (id: string) => Promise<unknown>;
  onEdit: (provider: Provider) => void;
-  onEnable: (id: string) => Promise<unknown>;
  onPageChange: (page: number, pageSize: number) => void;
-  onTest: (id: string) => Promise<unknown>;
  page: number;
  pageSize: number;
 }
@@ -31,63 +22,19 @@ const TYPE_LABELS: Record<Provider["type"], string> = {
 };

 const COLUMNS: ColumnsType<Provider> = [
-  { dataIndex: "name", ellipsis: true, title: "供应商名称", width: 160 },
+  { dataIndex: "name", ellipsis: true, title: "名称", width: 180 },
  {
-    align: "center",
    dataIndex: "type",
    render: (value: Provider["type"]) => TYPE_LABELS[value] ?? value,
    title: "类型",
-    width: 130,
+    width: 140,
  },
  { dataIndex: "baseUrl", ellipsis: true, title: "Base URL" },
-  {
-    align: "center",
-    dataIndex: "enabled",
-    render: (value: boolean) => (value ? <Tag color="blue">已启用</Tag> : <Tag>已禁用</Tag>),
-    title: "状态",
-    width: 100,
-  },
-  {
-    align: "center",
-    dataIndex: "createdAt",
-    render: (_value: unknown, record: Provider) => formatDatetime(record.createdAt),
-    title: "创建时间",
-    width: 185,
-  },
 ];

-export function ProviderTable({
-  data,
-  loading,
-  onDelete,
-  onDisable,
-  onEdit,
-  onEnable,
-  onPageChange,
-  onTest,
-  page,
-  pageSize,
-}: ProviderTableProps) {
+export function ProviderTable({ data, loading, onDelete, onEdit, onPageChange, page, pageSize }: ProviderTableProps) {
  const { message } = AntApp.useApp();

-  const handleEnable = async (id: string) => {
-    try {
-      await onEnable(id);
-      message.success("供应商已启用");
-    } catch (err) {
-      message.error((err as Error).message);
-    }
-  };
-
-  const handleDisable = async (id: string) => {
-    try {
-      await onDisable(id);
-      message.success("供应商已禁用");
-    } catch (err) {
-      message.error((err as Error).message);
-    }
-  };
-
  const handleDelete = async (id: string) => {
    try {
      await onDelete(id);
@@ -97,39 +44,15 @@ export function ProviderTable({
    }
  };

-  const handleTest = async (id: string) => {
-    try {
-      const result = await onTest(id);
-      message.success((result as { message: string }).message);
-    } catch (err) {
-      message.error((err as Error).message);
-    }
-  };
-
  const operationColumn: ColumnsType<Provider>[number] = {
    dataIndex: "op",
-    fixed: "right",
    render: (_value: unknown, record: Provider) => (
      <Space size="small">
-        <Tooltip title="测试连接">
-          <Button icon={<ThunderboltOutlined />} onClick={() => void handleTest(record.id)} size="small" type="link" />
-        </Tooltip>
        <Button icon={<EditOutlined />} onClick={() => onEdit(record)} size="small" type="link">
          编辑
        </Button>
-        {record.enabled ? (
-          <Popconfirm onConfirm={() => void handleDisable(record.id)} title="确认禁用此供应商？">
-            <Button color="orange" icon={<StopOutlined />} size="small" variant="link">
-              禁用
-            </Button>
-          </Popconfirm>
-        ) : (
-          <Button icon={<CheckCircleOutlined />} onClick={() => void handleEnable(record.id)} size="small" type="link">
-            启用
-          </Button>
-        )}
        <Popconfirm
-          description="该供应商下存在模型时无法删除。"
+          description="该供应商下存在模型时无法删除，请先删除或迁移相关模型。"
          onConfirm={() => void handleDelete(record.id)}
          title="确认删除此供应商？"
        >
@@ -140,7 +63,7 @@ export function ProviderTable({
      </Space>
    ),
    title: "操作",
-    width: 280,
+    width: 180,
  };

  return (
@@ -157,13 +80,6 @@ export function ProviderTable({
        total: data?.total ?? 0,
      }}
      rowKey="id"
-      scroll={{ x: 900 }}
    />
  );
 }
-
-function formatDatetime(dateStr: string): string {
-  const d = new Date(dateStr);
-  const pad = (n: number) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-}
--- a/src/web/pages/models/components/ProviderToolbar.tsx
+++ b/src/web/pages/models/components/ProviderToolbar.tsx
@@ -1,34 +0,0 @@
-import { PlusOutlined } from "@ant-design/icons";
-import { Button, Flex, Input } from "antd";
-import { useState } from "react";
-
-interface ProviderToolbarProps {
-  keyword: string;
-  onSearch: (value: string) => void;
-  onSearchClear: () => void;
-  openCreateDialog: () => void;
-}
-
-export function ProviderToolbar({ keyword, onSearch, onSearchClear, openCreateDialog }: ProviderToolbarProps) {
-  const [draftKeyword, setDraftKeyword] = useState(keyword);
-
-  return (
-    <Flex align="center" gap="small" justify="space-between" wrap="wrap">
-      <Input.Search
-        allowClear
-        enterButton="搜索"
-        onChange={(event) => setDraftKeyword(event.target.value)}
-        onClear={() => {
-          setDraftKeyword("");
-          onSearchClear();
-        }}
-        onSearch={(value) => onSearch(value)}
-        placeholder="搜索供应商名称"
-        value={draftKeyword}
-      />
-      <Button icon={<PlusOutlined />} onClick={openCreateDialog} type="primary">
-        新建供应商
-      </Button>
-    </Flex>
-  );
-}
--- a/src/web/pages/models/index.tsx
+++ b/src/web/pages/models/index.tsx
@@ -1,34 +1,31 @@
-import { Flex, Tabs } from "antd";
+import { Flex } from "antd";
 import { useState } from "react";

-import type { Model, Provider } from "../../../shared/api";
+import type { Model, Provider, TestModelRequest } from "../../../shared/api";

 import {
  useCreateModel,
  useDeleteModel,
-  useDisableModel,
-  useEnableModel,
  useModelList,
+  useTestModelConnection,
  useUpdateModel,
 } from "../../hooks/use-models";
 import {
  useCreateProvider,
  useDeleteProvider,
-  useDisableProvider,
-  useEnableProvider,
  useProviderList,
-  useTestProviderConnection,
+  useProviderOptions,
+  useTestProviderConfig,
  useUpdateProvider,
 } from "../../hooks/use-providers";
 import { ModelFormModal } from "./components/ModelFormModal";
+import { ModelsToolbar } from "./components/ModelsToolbar";
 import { ModelTable } from "./components/ModelTable";
-import { ModelToolbar } from "./components/ModelToolbar";
 import { ProviderFormModal } from "./components/ProviderFormModal";
 import { ProviderTable } from "./components/ProviderTable";
-import { ProviderToolbar } from "./components/ProviderToolbar";

 export function ModelsPage() {
-  const [activeTab, setActiveTab] = useState<string>("providers");
+  const [activeTab, setActiveTab] = useState<string>("models");

  const [providerPage, setProviderPage] = useState(1);
  const [providerPageSize, setProviderPageSize] = useState(20);
@@ -48,6 +45,13 @@ export function ModelsPage() {
    pageSize: providerPageSize,
  });

+  const {
+    data: providerOptionsData,
+    error: providerOptionsError,
+    isError: providerOptionsIsError,
+    isLoading: providerOptionsLoading,
+  } = useProviderOptions();
+
  const { data: modelData, isLoading: modelLoading } = useModelList({
    keyword: modelKeyword || undefined,
    page: modelPage,
@@ -57,67 +61,81 @@ export function ModelsPage() {
  const createProviderMutation = useCreateProvider();
  const updateProviderMutation = useUpdateProvider();
  const deleteProviderMutation = useDeleteProvider();
-  const enableProviderMutation = useEnableProvider();
-  const disableProviderMutation = useDisableProvider();
-  const testProviderMutation = useTestProviderConnection();
+  const testProviderConfigMutation = useTestProviderConfig();

  const createModelMutation = useCreateModel();
  const updateModelMutation = useUpdateModel();
  const deleteModelMutation = useDeleteModel();
-  const enableModelMutation = useEnableModel();
-  const disableModelMutation = useDisableModel();
+  const testModelMutation = useTestModelConnection();

  const isProviderSubmitting = createProviderMutation.isPending || updateProviderMutation.isPending;
-  const isProviderActionPending =
-    deleteProviderMutation.isPending || enableProviderMutation.isPending || disableProviderMutation.isPending;
+  const isProviderActionPending = deleteProviderMutation.isPending;

  const isModelSubmitting = createModelMutation.isPending || updateModelMutation.isPending;
-  const isModelActionPending =
-    deleteModelMutation.isPending || enableModelMutation.isPending || disableModelMutation.isPending;
+  const isModelActionPending = deleteModelMutation.isPending;
+  const modelProviders = providerOptionsData?.items ?? [];
+
+  const currentKeyword = activeTab === "providers" ? providerKeyword : modelKeyword;
+
+  const handleSearch =
+    activeTab === "providers"
+      ? (value: string) => {
+          setProviderKeyword(value);
+          setProviderPage(1);
+        }
+      : (value: string) => {
+          setModelKeyword(value);
+          setModelPage(1);
+        };
+
+  const handleSearchClear =
+    activeTab === "providers"
+      ? () => {
+          setProviderKeyword("");
+          setProviderPage(1);
+        }
+      : () => {
+          setModelKeyword("");
+          setModelPage(1);
+        };
+
+  const handleOpenCreate =
+    activeTab === "providers"
+      ? () => {
+          setEditingProvider(null);
+          setProviderDialogOpen(true);
+        }
+      : () => {
+          setEditingModel(null);
+          setModelDialogOpen(true);
+        };

  return (
    <Flex flex={1} gap="var(--ant-margin-lg)" vertical>
-      <Tabs
-        activeKey={activeTab}
-        items={[
-          { key: "providers", label: "供应商" },
-          { key: "models", label: "模型" },
-        ]}
-        onChange={(key) => setActiveTab(key)}
+      <ModelsToolbar
+        activeTab={activeTab}
+        key={activeTab}
+        keyword={currentKeyword}
+        onSearch={handleSearch}
+        onSearchClear={handleSearchClear}
+        onTabChange={(key) => setActiveTab(key)}
+        openCreateDialog={handleOpenCreate}
      />

      {activeTab === "providers" && (
        <>
-          <ProviderToolbar
-            keyword={providerKeyword}
-            onSearch={(value) => {
-              setProviderKeyword(value);
-              setProviderPage(1);
-            }}
-            onSearchClear={() => {
-              setProviderKeyword("");
-              setProviderPage(1);
-            }}
-            openCreateDialog={() => {
-              setEditingProvider(null);
-              setProviderDialogOpen(true);
-            }}
-          />
          <ProviderTable
            data={providerData}
            loading={providerLoading || isProviderActionPending}
            onDelete={(id) => deleteProviderMutation.mutateAsync(id)}
-            onDisable={(id) => disableProviderMutation.mutateAsync(id)}
            onEdit={(provider) => {
              setEditingProvider(provider);
              setProviderDialogOpen(true);
            }}
-            onEnable={(id) => enableProviderMutation.mutateAsync(id)}
            onPageChange={(p, ps) => {
              setProviderPage(p);
              setProviderPageSize(ps);
            }}
-            onTest={(id) => testProviderMutation.mutateAsync(id)}
            page={providerPage}
            pageSize={providerPageSize}
          />
@@ -126,6 +144,7 @@ export function ModelsPage() {
            onCancel={() => setProviderDialogOpen(false)}
            onCreate={(data) => createProviderMutation.mutateAsync(data)}
            onOpenChange={setProviderDialogOpen}
+            onTest={(data) => testProviderConfigMutation.mutateAsync(data)}
            onUpdate={(args) => updateProviderMutation.mutateAsync(args)}
            open={providerDialogOpen}
            submitting={isProviderSubmitting}
@@ -135,38 +154,21 @@ export function ModelsPage() {

      {activeTab === "models" && (
        <>
-          <ModelToolbar
-            keyword={modelKeyword}
-            onSearch={(value) => {
-              setModelKeyword(value);
-              setModelPage(1);
-            }}
-            onSearchClear={() => {
-              setModelKeyword("");
-              setModelPage(1);
-            }}
-            openCreateDialog={() => {
-              setEditingModel(null);
-              setModelDialogOpen(true);
-            }}
-          />
          <ModelTable
            data={modelData}
-            loading={modelLoading || isModelActionPending}
+            loading={modelLoading || providerOptionsLoading || isModelActionPending}
            onDelete={(id) => deleteModelMutation.mutateAsync(id)}
-            onDisable={(id) => disableModelMutation.mutateAsync(id)}
            onEdit={(model) => {
              setEditingModel(model);
              setModelDialogOpen(true);
            }}
-            onEnable={(id) => enableModelMutation.mutateAsync(id)}
            onPageChange={(p, ps) => {
              setModelPage(p);
              setModelPageSize(ps);
            }}
            page={modelPage}
            pageSize={modelPageSize}
-            providers={providerData?.items ?? []}
+            providers={modelProviders}
          />
          <ModelFormModal
            editingModel={editingModel}
@@ -175,9 +177,11 @@ export function ModelsPage() {
            onOpenChange={setModelDialogOpen}
            onUpdate={(args) => updateModelMutation.mutateAsync(args)}
            open={modelDialogOpen}
-            providers={providerData?.items ?? []}
+            providers={modelProviders}
+            providersError={providerOptionsIsError ? providerOptionsError : null}
+            providersLoading={providerOptionsLoading}
            submitting={isModelSubmitting}
-            testConnection={editingModel ? (id: string) => testProviderMutation.mutateAsync(id) : undefined}
+            testModelConnection={(data: TestModelRequest) => testModelMutation.mutateAsync(data)}
          />
        </>
      )}
--- a/tests/server/ai/registry.test.ts
+++ b/tests/server/ai/registry.test.ts
@@ -2,70 +2,125 @@ import { describe, expect, mock, test } from "bun:test";

 import { createMigratedTestDatabase } from "../../helpers";

-describe("AI registry", () => {
-  test("testProviderConnection rejects invalid config", async () => {
-    void mock.module("ai", () => ({
-      generateText: mock(() => {
-        throw new Error("Connection failed");
-      }),
-    }));
+void mock.module("ai", () => ({
+  createProviderRegistry: (providers: Record<string, { languageModel: (modelId: string) => unknown }>) => ({
+    languageModel: (id: string) => {
+      const [providerId, modelId] = id.split(":");
+      const provider = providers[providerId ?? ""];
+      if (!provider || !modelId) throw new Error(`No such provider: ${id}`);
+      return provider.languageModel(modelId);
+    },
+  }),
+  generateText: () => Promise.resolve({ text: "Hi" }),
+}));

+async function withProviderServer(
+  modelsResponse: Response,
+  callback: (baseUrl: string) => Promise<void>,
+): Promise<void> {
+  const server = Bun.serve({
+    fetch(request) {
+      if (request.method === "HEAD") return new Response(null, { status: 200 });
+      return modelsResponse;
+    },
+    port: 0,
+  });
+  try {
+    await callback(`http://127.0.0.1:${server.port}/v1`);
+  } finally {
+    await server.stop(true);
+  }
+}
+
+describe("AI registry", () => {
+  test("testProviderConnection reports unreachable Base URL", async () => {
    const { testProviderConnection } = await import("../../../src/server/ai/registry");

    const result = await testProviderConnection({
      apiKey: "bad-key",
-      baseUrl: "https://0.0.0.0:1",
+      baseUrl: "http://127.0.0.1:1",
      name: "Bad",
      type: "openai-compatible",
    });

    expect(result.ok).toBe(false);
-    expect(result.message).toContain("连接失败");
-    expect(typeof result.message).toBe("string");
+    expect(result.message).toContain("Base URL 不可达");
+  });
+
+  test("testProviderConnection rejects invalid config", async () => {
+    await withProviderServer(new Response(null, { status: 401 }), async (baseUrl) => {
+      const { testProviderConnection } = await import("../../../src/server/ai/registry");
+
+      const result = await testProviderConnection({
+        apiKey: "bad-key",
+        baseUrl,
+        name: "Bad",
+        type: "openai-compatible",
+      });
+
+      expect(result.ok).toBe(false);
+      expect(result.message).toContain("API Key 无效");
+      expect(typeof result.message).toBe("string");
+    });
  });

  test("testProviderConnection return shape is correct", async () => {
-    void mock.module("ai", () => ({
-      generateText: mock((_opts: unknown) => ({})),
-    }));
+    await withProviderServer(Response.json({ data: [{ id: "gpt-4o" }] }), async (baseUrl) => {
+      const { testProviderConnection } = await import("../../../src/server/ai/registry");

-    const { testProviderConnection } = await import("../../../src/server/ai/registry");
+      const result = await testProviderConnection({
+        apiKey: "sk-test",
+        baseUrl,
+        name: "Test",
+        type: "openai",
+      });

-    const result = await testProviderConnection({
-      apiKey: "sk-test",
-      baseUrl: "https://api.openai.com/v1",
-      name: "Test",
-      type: "openai",
+      expect(result.ok).toBe(true);
+      expect(result.message).toContain("/models 返回 1 个模型");
    });
-
-    expect(result.ok).toBe(true);
-    expect(result.message).toBe("连接成功");
  });

-  test("buildProviderRegistry 从 DB 构建包含启用供应商的注册表", async () => {
+  test("testProviderConnection treats unsupported /models as non-blocking", async () => {
+    await withProviderServer(new Response(null, { status: 404 }), async (baseUrl) => {
+      const { testProviderConnection } = await import("../../../src/server/ai/registry");
+
+      const result = await testProviderConnection({
+        apiKey: "sk-test",
+        baseUrl,
+        name: "Test",
+        type: "openai",
+      });
+
+      expect(result.ok).toBe(true);
+      expect(result.message).toContain("可能不支持 /models");
+    });
+  });
+
+  test("buildProviderRegistry 从 DB 构建包含所有供应商的注册表", async () => {
    const handle = createMigratedTestDatabase("registry-build-test");
    const now = new Date().toISOString();

    handle.db
      .prepare(
-        "INSERT INTO providers (id, name, type, base_url, api_key, enabled, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+        "INSERT INTO providers (id, name, type, base_url, api_key, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
      )
-      .run("pv1", "OpenAI", "openai", "https://api.openai.com/v1", "sk-test", 1, now, now);
+      .run("pv1", "OpenAI", "openai", "https://api.openai.com/v1", "sk-test", now, now);
    handle.db
      .prepare(
-        "INSERT INTO providers (id, name, type, base_url, api_key, enabled, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+        "INSERT INTO providers (id, name, type, base_url, api_key, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
      )
-      .run("pv2", "Disabled", "anthropic", "https://api.anthropic.com", "sk-off", 0, now, now);
+      .run("pv2", "Anthropic", "anthropic", "https://api.anthropic.com", "sk-off", now, now);

    const { buildProviderRegistry } = await import("../../../src/server/ai/registry");
    const registry = buildProviderRegistry(handle.db);

    expect(() => registry.languageModel("pv1:gpt-4o")).not.toThrow();
+    expect(() => registry.languageModel("pv2:claude-3")).not.toThrow();

    handle.cleanup();
  });

-  test("buildProviderRegistry 无启用供应商时返回空注册表", async () => {
+  test("buildProviderRegistry 无供应商时返回空注册表", async () => {
    const handle = createMigratedTestDatabase("registry-empty-test");

    const { buildProviderRegistry } = await import("../../../src/server/ai/registry");
@@ -75,4 +130,19 @@ describe("AI registry", () => {

    handle.cleanup();
  });
+
+  test("testModelConnection 成功返回 ok:true", async () => {
+    const { testModelConnection } = await import("../../../src/server/ai/registry");
+
+    const result = await testModelConnection({
+      apiKey: "sk-test",
+      baseUrl: "https://api.openai.com/v1",
+      modelId: "gpt-4o",
+      name: "Test",
+      type: "openai",
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.message).toContain("模型连接成功");
+  });
 });
--- a/tests/server/db/models.test.ts
+++ b/tests/server/db/models.test.ts
@@ -5,8 +5,6 @@ import { describe, expect, test } from "bun:test";
 import {
  createModel,
  deleteModel,
-  disableModel,
-  enableModel,
  getModel,
  getModelsByProviderId,
  listModels,
@@ -41,16 +39,12 @@ describe("模型数据访问层", () => {
        providerId,
      });
      expect("error" in result).toBe(false);
-      const model = (
-        result as {
-          model: { capabilities: string[]; enabled: boolean; modelId: string; name: string; providerId: string };
-        }
-      ).model;
+      const model = (result as { model: { capabilities: string[]; modelId: string; name: string; providerId: string } })
+        .model;
      expect(model.name).toBe("GPT-4o");
      expect(model.modelId).toBe("gpt-4o");
      expect(model.providerId).toBe(providerId);
      expect(model.capabilities).toEqual(["text", "reasoning"]);
-      expect(model.enabled).toBe(true);
    });
  });

@@ -150,35 +144,6 @@ describe("模型数据访问层", () => {
    });
  });

-  test("启用/禁用模型", () => {
-    withDb((db) => {
-      const providerId = seedProvider(db);
-      const created = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "测试", providerId });
-      const id = (created as { model: { id: string } }).model.id;
-
-      const disabled = disableModel(db, id);
-      expect("error" in disabled).toBe(false);
-      expect((disabled as { model: { enabled: boolean } }).model.enabled).toBe(false);
-
-      const enabled = enableModel(db, id);
-      expect("error" in enabled).toBe(false);
-      expect((enabled as { model: { enabled: boolean } }).model.enabled).toBe(true);
-    });
-  });
-
-  test("重复禁用失败", () => {
-    withDb((db) => {
-      const providerId = seedProvider(db);
-      const created = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "测试", providerId });
-      const id = (created as { model: { id: string } }).model.id;
-      disableModel(db, id);
-
-      const result = disableModel(db, id);
-      expect("error" in result).toBe(true);
-      expect((result as unknown as { status: number }).status).toBe(409);
-    });
-  });
-
  test("删除模型", () => {
    withDb((db) => {
      const providerId = seedProvider(db);
--- a/tests/server/db/providers.test.ts
+++ b/tests/server/db/providers.test.ts
@@ -5,9 +5,8 @@ import { describe, expect, test } from "bun:test";
 import {
  createProvider,
  deleteProvider,
-  disableProvider,
-  enableProvider,
  getProvider,
+  listProviderOptions,
  listProviders,
  updateProvider,
 } from "../../../src/server/db/providers";
@@ -24,6 +23,16 @@ function withDb(callback: (db: Database) => void): void {
 }

 describe("供应商数据访问层", () => {
+  test("迁移后的供应商和模型表不包含 enabled 字段", () => {
+    withDb((db) => {
+      const providerColumns = db.query("PRAGMA table_info(providers)").all() as Array<{ name: string }>;
+      const modelColumns = db.query("PRAGMA table_info(models)").all() as Array<{ name: string }>;
+
+      expect(providerColumns.map((column) => column.name)).not.toContain("enabled");
+      expect(modelColumns.map((column) => column.name)).not.toContain("enabled");
+    });
+  });
+
  test("创建供应商", () => {
    withDb((db) => {
      const result = createProvider(db, {
@@ -33,14 +42,12 @@ describe("供应商数据访问层", () => {
        type: "openai",
      });
      expect("error" in result).toBe(false);
-      const provider = (
-        result as { provider: { apiKey: string; baseUrl: string; enabled: boolean; name: string; type: string } }
-      ).provider;
+      const provider = (result as { provider: { apiKey: string; baseUrl: string; name: string; type: string } })
+        .provider;
      expect(provider.name).toBe("OpenAI");
      expect(provider.type).toBe("openai");
      expect(provider.baseUrl).toBe("https://api.openai.com/v1");
      expect(provider.apiKey).toBe("sk-test");
-      expect(provider.enabled).toBe(true);
    });
  });

@@ -121,44 +128,6 @@ describe("供应商数据访问层", () => {
    });
  });

-  test("启用/禁用供应商", () => {
-    withDb((db) => {
-      const created = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "测试", type: "openai" });
-      const id = (created as { provider: { id: string } }).provider.id;
-
-      const disabled = disableProvider(db, id);
-      expect("error" in disabled).toBe(false);
-      expect((disabled as { provider: { enabled: boolean } }).provider.enabled).toBe(false);
-
-      const enabled = enableProvider(db, id);
-      expect("error" in enabled).toBe(false);
-      expect((enabled as { provider: { enabled: boolean } }).provider.enabled).toBe(true);
-    });
-  });
-
-  test("重复禁用失败", () => {
-    withDb((db) => {
-      const created = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "测试", type: "openai" });
-      const id = (created as { provider: { id: string } }).provider.id;
-      disableProvider(db, id);
-
-      const result = disableProvider(db, id);
-      expect("error" in result).toBe(true);
-      expect((result as unknown as { status: number }).status).toBe(409);
-    });
-  });
-
-  test("重复启用失败", () => {
-    withDb((db) => {
-      const created = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "测试", type: "openai" });
-      const id = (created as { provider: { id: string } }).provider.id;
-
-      const result = enableProvider(db, id);
-      expect("error" in result).toBe(true);
-      expect((result as unknown as { status: number }).status).toBe(409);
-    });
-  });
-
  test("删除供应商", () => {
    withDb((db) => {
      const created = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "删除测试", type: "openai" });
@@ -192,4 +161,17 @@ describe("供应商数据访问层", () => {
      expect((result as { provider: { type: string } }).provider.type).toBe("openai-compatible");
    });
  });
+
+  test("供应商 options 返回最小字段", () => {
+    withDb((db) => {
+      createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "选项", type: "openai" });
+
+      const options = listProviderOptions(db);
+      expect(options.length).toBe(1);
+      expect(typeof options[0]?.id).toBe("string");
+      expect(options[0]).toMatchObject({ name: "选项", type: "openai" });
+      expect(options[0]).not.toHaveProperty("apiKey");
+      expect(options[0]).not.toHaveProperty("enabled");
+    });
+  });
 });
--- a/tests/server/routes/models.test.ts
+++ b/tests/server/routes/models.test.ts
@@ -1,6 +1,6 @@
 import type Database from "bun:sqlite";

-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";

 import type { Model, RuntimeMode } from "../../../src/shared/api";

@@ -30,16 +30,6 @@ async function deleteModelViaHandler(req: Request, db: Database): Promise<Respon
  return h(req, db, MODE);
 }

-async function disableModelViaHandler(req: Request, db: Database): Promise<Response> {
-  const { handleDisableModel: h } = await import("../../../src/server/routes/models/disable");
-  return h(req, db, MODE);
-}
-
-async function enableModelViaHandler(req: Request, db: Database): Promise<Response> {
-  const { handleEnableModel: h } = await import("../../../src/server/routes/models/enable");
-  return h(req, db, MODE);
-}
-
 async function getModelViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleGetModel: h } = await import("../../../src/server/routes/models/get");
  return h(req, db, MODE);
@@ -53,6 +43,13 @@ async function listModelsViaHandler(req: Request, db: Database): Promise<Respons
 import { createModel } from "../../../src/server/db/models";
 import { createProvider } from "../../../src/server/db/providers";

+void mock.module("ai", () => ({
+  createProviderRegistry: () => ({
+    languageModel: () => ({}),
+  }),
+  generateText: () => Promise.resolve({ text: "Hi" }),
+}));
+
 function seedProvider(db: Database, name?: string): string {
  const result = createProvider(db, {
    apiKey: "sk-test",
@@ -64,6 +61,11 @@ function seedProvider(db: Database, name?: string): string {
  return result.provider.id;
 }

+async function testModelViaHandler(req: Request, db: Database): Promise<Response> {
+  const { handleTestModelConfig: h } = await import("../../../src/server/routes/models/test");
+  return h(req, db, MODE);
+}
+
 async function updateModelViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleUpdateModel: h } = await import("../../../src/server/routes/models/update");
  return h(req, db, MODE);
@@ -163,34 +165,6 @@ describe("models API routes", () => {
    });
  });

-  test("POST /api/models/:id/enable", async () => {
-    await withRouteDb(async (db) => {
-      const model = createTestModel(db, "EnableTest");
-      await disableModelViaHandler(
-        new Request("http://localhost/api/models/" + model.id + "/disable", { method: "POST" }),
-        db,
-      );
-
-      const req = new Request("http://localhost/api/models/" + model.id + "/enable", { method: "POST" });
-      const res = await enableModelViaHandler(req, db);
-      expect(res.status).toBe(200);
-      const body = (await res.json()) as { model: Model };
-      expect(body.model.enabled).toBe(true);
-    });
-  });
-
-  test("POST /api/models/:id/disable", async () => {
-    await withRouteDb(async (db) => {
-      const model = createTestModel(db, "DisableTest");
-
-      const req = new Request("http://localhost/api/models/" + model.id + "/disable", { method: "POST" });
-      const res = await disableModelViaHandler(req, db);
-      expect(res.status).toBe(200);
-      const body = (await res.json()) as { model: Model };
-      expect(body.model.enabled).toBe(false);
-    });
-  });
-
  test("DELETE /api/models/:id", async () => {
    await withRouteDb(async (db) => {
      const model = createTestModel(db, "DeleteTest");
@@ -219,4 +193,74 @@ describe("models API routes", () => {
      expect(res.status).toBe(400);
    });
  });
+
+  test("invalid numeric fields return 400", async () => {
+    await withRouteDb(async (db) => {
+      const providerId = seedProvider(db);
+
+      const createReq = new Request("http://localhost/api/models", {
+        body: JSON.stringify({
+          capabilities: ["text"],
+          contextLength: 0,
+          modelId: "test",
+          name: "Test",
+          providerId,
+        }),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      });
+      const createRes = await createModelViaHandler(createReq, db);
+      expect(createRes.status).toBe(400);
+
+      const model = createTestModel(db, "NumericTest", providerId);
+      const updateReq = new Request("http://localhost/api/models/" + model.id, {
+        body: JSON.stringify({ maxOutputTokens: 1.5 }),
+        headers: { "Content-Type": "application/json" },
+        method: "PATCH",
+      });
+      const updateRes = await updateModelViaHandler(updateReq, db);
+      expect(updateRes.status).toBe(400);
+    });
+  });
+
+  test("POST /api/models/test 成功测试模型连接", async () => {
+    await withRouteDb(async (db) => {
+      const providerId = seedProvider(db);
+
+      const req = new Request("http://localhost/api/models/test", {
+        body: JSON.stringify({ modelId: "gpt-4o", providerId }),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      });
+      const res = await testModelViaHandler(req, db);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { modelTestResponse: { message: string; ok: boolean } };
+      expect(body.modelTestResponse.ok).toBe(true);
+      expect(body.modelTestResponse.message).toContain("模型连接成功");
+    });
+  });
+
+  test("POST /api/models/test 缺少 providerId 返回 400", async () => {
+    await withRouteDb(async (db) => {
+      const req = new Request("http://localhost/api/models/test", {
+        body: JSON.stringify({ modelId: "gpt-4o" }),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      });
+      const res = await testModelViaHandler(req, db);
+      expect(res.status).toBe(400);
+    });
+  });
+
+  test("POST /api/models/test 不存在的供应商返回 404", async () => {
+    await withRouteDb(async (db) => {
+      const req = new Request("http://localhost/api/models/test", {
+        body: JSON.stringify({ modelId: "gpt-4o", providerId: "nonexistent" }),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      });
+      const res = await testModelViaHandler(req, db);
+      expect(res.status).toBe(404);
+    });
+  });
 });
--- a/tests/server/routes/providers.test.ts
+++ b/tests/server/routes/providers.test.ts
@@ -1,22 +1,30 @@
 import type Database from "bun:sqlite";

-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";

-import type { Provider, RuntimeMode } from "../../../src/shared/api";
+import type { Provider, ProviderOption, RuntimeMode } from "../../../src/shared/api";

+import { createModel } from "../../../src/server/db/models";
+import { createProvider } from "../../../src/server/db/providers";
 import { createMigratedMemoryTestDatabase } from "../../helpers";

 const MODE: RuntimeMode = "test";

+void mock.module("ai", () => ({
+  createProviderRegistry: () => ({
+    languageModel: () => ({}),
+  }),
+}));
+
 async function createProviderViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleCreateProvider: h } = await import("../../../src/server/routes/providers/create");
  return h(req, db, MODE);
 }

-function createTestProvider(db: Database, name = "测试供应商"): Provider {
+function createTestProvider(db: Database, name = "测试供应商", baseUrl = "https://api.test.com/v1"): Provider {
  const result = createProvider(db, {
    apiKey: "sk-test",
-    baseUrl: "https://api.test.com/v1",
+    baseUrl,
    name,
    type: "openai",
  });
@@ -29,33 +37,49 @@ async function deleteProviderViaHandler(req: Request, db: Database): Promise<Res
  return h(req, db, MODE);
 }

-async function disableProviderViaHandler(req: Request, db: Database): Promise<Response> {
-  const { handleDisableProvider: h } = await import("../../../src/server/routes/providers/disable");
-  return h(req, db, MODE);
-}
-
-async function enableProviderViaHandler(req: Request, db: Database): Promise<Response> {
-  const { handleEnableProvider: h } = await import("../../../src/server/routes/providers/enable");
-  return h(req, db, MODE);
-}
-
 async function getProviderViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleGetProvider: h } = await import("../../../src/server/routes/providers/get");
  return h(req, db, MODE);
 }

+async function listProviderOptionsViaHandler(_req: Request, db: Database): Promise<Response> {
+  const { handleListProviderOptions: h } = await import("../../../src/server/routes/providers/options");
+  return h(db, MODE);
+}
+
 async function listProvidersViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleListProviders: h } = await import("../../../src/server/routes/providers/list");
  return h(req, db, MODE);
 }

-import { createProvider } from "../../../src/server/db/providers";
+async function testProviderConfigViaHandler(req: Request, db: Database): Promise<Response> {
+  const { handleTestProviderConfig: h } = await import("../../../src/server/routes/providers/test");
+  return h(req, db, MODE);
+}

 async function updateProviderViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleUpdateProvider: h } = await import("../../../src/server/routes/providers/update");
  return h(req, db, MODE);
 }

+async function withProviderServer(
+  modelsResponse: Response,
+  callback: (baseUrl: string) => Promise<void>,
+): Promise<void> {
+  const server = Bun.serve({
+    fetch(request) {
+      if (request.method === "HEAD") return new Response(null, { status: 200 });
+      return modelsResponse;
+    },
+    port: 0,
+  });
+  try {
+    await callback(`http://127.0.0.1:${server.port}/v1`);
+  } finally {
+    await server.stop(true);
+  }
+}
+
 async function withRouteDb(callback: (db: Database) => Promise<void>): Promise<void> {
  const handle = createMigratedMemoryTestDatabase("route-provider-test");
  try {
@@ -101,6 +125,22 @@ describe("供应商 API 路由", () => {
    });
  });

+  test("GET /api/providers/options 返回最小字段", async () => {
+    await withRouteDb(async (db) => {
+      createTestProvider(db, "选项供应商");
+
+      const req = new Request("http://localhost/api/providers/options");
+      const res = await listProviderOptionsViaHandler(req, db);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { items: ProviderOption[] };
+      expect(body.items).toHaveLength(1);
+      expect(typeof body.items[0]?.id).toBe("string");
+      expect(body.items[0]).toMatchObject({ name: "选项供应商", type: "openai" });
+      expect(body.items[0]).not.toHaveProperty("apiKey");
+      expect(body.items[0]).not.toHaveProperty("enabled");
+    });
+  });
+
  test("GET /api/providers/:id 获取详情", async () => {
    await withRouteDb(async (db) => {
      const provider = createTestProvider(db, "详情路由");
@@ -129,34 +169,6 @@ describe("供应商 API 路由", () => {
    });
  });

-  test("POST /api/providers/:id/enable 启用", async () => {
-    await withRouteDb(async (db) => {
-      const provider = createTestProvider(db, "启用测试");
-      await disableProviderViaHandler(
-        new Request(`http://localhost/api/providers/${provider.id}/disable`, { method: "POST" }),
-        db,
-      );
-
-      const req = new Request(`http://localhost/api/providers/${provider.id}/enable`, { method: "POST" });
-      const res = await enableProviderViaHandler(req, db);
-      expect(res.status).toBe(200);
-      const body = (await res.json()) as { provider: Provider };
-      expect(body.provider.enabled).toBe(true);
-    });
-  });
-
-  test("POST /api/providers/:id/disable 禁用", async () => {
-    await withRouteDb(async (db) => {
-      const provider = createTestProvider(db, "禁用测试");
-
-      const req = new Request(`http://localhost/api/providers/${provider.id}/disable`, { method: "POST" });
-      const res = await disableProviderViaHandler(req, db);
-      expect(res.status).toBe(200);
-      const body = (await res.json()) as { provider: Provider };
-      expect(body.provider.enabled).toBe(false);
-    });
-  });
-
  test("DELETE /api/providers/:id 删除供应商", async () => {
    await withRouteDb(async (db) => {
      const provider = createTestProvider(db, "删除路由");
@@ -167,6 +179,47 @@ describe("供应商 API 路由", () => {
    });
  });

+  test("DELETE /api/providers/:id 存在关联模型时返回 409", async () => {
+    await withRouteDb(async (db) => {
+      const provider = createTestProvider(db, "有关联模型");
+      const modelResult = createModel(db, {
+        capabilities: ["text"],
+        modelId: "gpt-4o",
+        name: "GPT-4o",
+        providerId: provider.id,
+      });
+      if ("error" in modelResult) throw new Error(modelResult.error);
+
+      const req = new Request(`http://localhost/api/providers/${provider.id}`, { method: "DELETE" });
+      const res = await deleteProviderViaHandler(req, db);
+      expect(res.status).toBe(409);
+      const body = (await res.json()) as { error: string };
+      expect(body.error).toContain("存在模型");
+    });
+  });
+
+  test("POST /api/providers/test 使用表单配置测试连通性", async () => {
+    await withRouteDb(async (db) => {
+      await withProviderServer(Response.json({ data: [{ id: "gpt-4o" }] }), async (baseUrl) => {
+        const req = new Request("http://localhost/api/providers/test", {
+          body: JSON.stringify({
+            apiKey: "sk-test",
+            baseUrl,
+            name: "OpenAI",
+            type: "openai",
+          }),
+          headers: { "Content-Type": "application/json" },
+          method: "POST",
+        });
+        const res = await testProviderConfigViaHandler(req, db);
+        expect(res.status).toBe(200);
+        const body = (await res.json()) as { providerTestResponse: { message: string; ok: boolean } };
+        expect(body.providerTestResponse.ok).toBe(true);
+        expect(body.providerTestResponse.message).toContain("/models 返回 1 个模型");
+      });
+    });
+  });
+
  test("创建同名供应商返回 409", async () => {
    await withRouteDb(async (db) => {
      const req1 = new Request("http://localhost/api/providers", {
--- a/tests/web/components/ModelTable.test.tsx
+++ b/tests/web/components/ModelTable.test.tsx
@@ -2,38 +2,27 @@ import { fireEvent, screen, waitFor } from "@testing-library/react";
 import { describe, expect, mock, test } from "bun:test";
 import { createElement } from "react";

-import type { Model, Provider } from "../../../src/shared/api";
+import type { Model, ProviderOption } from "../../../src/shared/api";

 import { ModelTable } from "../../../src/web/pages/models/components/ModelTable";
 import { renderWithProviders } from "../test-utils";

-const ENABLED_PROVIDER: Provider = {
-  apiKey: "sk-test",
-  baseUrl: "https://api.openai.com/v1",
-  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: true,
+const OPENAI_PROVIDER: ProviderOption = {
  id: "pv1",
  name: "OpenAI",
  type: "openai",
-  updatedAt: "2024-01-01T00:00:00.000Z",
 };

-const DISABLED_PROVIDER: Provider = {
-  apiKey: "sk-off",
-  baseUrl: "https://api.deepseek.com/v1",
-  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: false,
+const DEEPSEEK_PROVIDER: ProviderOption = {
  id: "pv2",
  name: "DeepSeek",
  type: "openai-compatible",
-  updatedAt: "2024-01-01T00:00:00.000Z",
 };

 const ENABLED_MODEL: Model = {
  capabilities: ["text", "reasoning"],
  contextLength: 128000,
  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: true,
  id: "m1",
  maxOutputTokens: 4096,
  modelId: "gpt-4o",
@@ -46,7 +35,6 @@ const DISABLED_MODEL: Model = {
  capabilities: ["text"],
  contextLength: null,
  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: false,
  id: "m2",
  maxOutputTokens: null,
  modelId: "deepseek-chat",
@@ -67,49 +55,45 @@ describe("ModelTable", () => {
        data: { items: [ENABLED_MODEL, DISABLED_MODEL], page: 1, pageSize: 20, total: 2 },
        loading: false,
        onDelete: () => Promise.resolve(),
-        onDisable: () => Promise.resolve(),
        onEdit: () => undefined,
-        onEnable: () => Promise.resolve(),
        onPageChange: () => undefined,
        page: 1,
        pageSize: 20,
-        providers: [ENABLED_PROVIDER, DISABLED_PROVIDER],
+        providers: [OPENAI_PROVIDER, DEEPSEEK_PROVIDER],
      }),
    );

    expect(screen.getByText("GPT-4o")).not.toBeNull();
-    expect(screen.getByText("gpt-4o")).not.toBeNull();
    expect(screen.getByText("DeepSeek Chat")).not.toBeNull();
+    expect(screen.getByText("OpenAI")).not.toBeNull();
+    expect(screen.getByText("DeepSeek")).not.toBeNull();
+    expect(screen.queryByText("状态")).toBeNull();
+    expect(screen.queryByRole("button", { name: /启用|禁用/ })).toBeNull();
  });

-  test("模型表格操作触发 enable/disable/delete", async () => {
-    const onDisable = mock(() => Promise.resolve());
-    const onEnable = mock(() => Promise.resolve());
+  test("模型表格操作触发 edit/delete", async () => {
    const onDelete = mock(() => Promise.resolve());
+    const onEdit = mock(() => undefined);

    renderWithProviders(
      createElement(ModelTable, {
        data: { items: [ENABLED_MODEL, DISABLED_MODEL], page: 1, pageSize: 20, total: 2 },
        loading: false,
        onDelete,
-        onDisable,
-        onEdit: () => undefined,
-        onEnable,
+        onEdit,
        onPageChange: () => undefined,
        page: 1,
        pageSize: 20,
-        providers: [ENABLED_PROVIDER, DISABLED_PROVIDER],
+        providers: [OPENAI_PROVIDER, DEEPSEEK_PROVIDER],
      }),
    );

-    const disableButtons = screen.getAllByRole("button", { name: /禁用/ });
-    fireEvent.click(disableButtons[0]!);
-    await waitFor(() => expect(screen.getByText("确认禁用此模型？")).not.toBeNull());
-    clickLatestConfirmButton();
-    await waitFor(() => expect(onDisable).toHaveBeenCalledWith("m1"));
+    fireEvent.click(screen.getAllByRole("button", { name: /编辑/ })[0]!);
+    expect(onEdit).toHaveBeenCalledWith(ENABLED_MODEL);

-    const enableButtons = screen.getAllByRole("button", { name: /启用/ });
-    fireEvent.click(enableButtons[0]!);
-    await waitFor(() => expect(onEnable).toHaveBeenCalledWith("m2"));
+    fireEvent.click(screen.getAllByRole("button", { name: /删除/ })[0]!);
+    await waitFor(() => expect(screen.getByText("确认删除此模型？")).not.toBeNull());
+    clickLatestConfirmButton();
+    await waitFor(() => expect(onDelete).toHaveBeenCalledWith("m1"));
  });
 });
--- a/tests/web/components/ProviderTable.test.tsx
+++ b/tests/web/components/ProviderTable.test.tsx
@@ -7,22 +7,20 @@ import type { Provider } from "../../../src/shared/api";
 import { ProviderTable } from "../../../src/web/pages/models/components/ProviderTable";
 import { renderWithProviders } from "../test-utils";

-const ENABLED_PROVIDER: Provider = {
+const OPENAI_PROVIDER: Provider = {
  apiKey: "sk-test",
  baseUrl: "https://api.openai.com/v1",
  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: true,
  id: "pv1",
  name: "OpenAI",
  type: "openai",
  updatedAt: "2024-01-01T00:00:00.000Z",
 };

-const DISABLED_PROVIDER: Provider = {
+const DEEPSEEK_PROVIDER: Provider = {
  apiKey: "sk-off",
  baseUrl: "https://api.deepseek.com/v1",
  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: false,
  id: "pv2",
  name: "DeepSeek",
  type: "openai-compatible",
@@ -38,14 +36,11 @@ describe("ProviderTable", () => {
  test("渲染供应商表格数据", () => {
    renderWithProviders(
      createElement(ProviderTable, {
-        data: { items: [ENABLED_PROVIDER, DISABLED_PROVIDER], page: 1, pageSize: 20, total: 2 },
+        data: { items: [OPENAI_PROVIDER, DEEPSEEK_PROVIDER], page: 1, pageSize: 20, total: 2 },
        loading: false,
        onDelete: () => Promise.resolve(),
-        onDisable: () => Promise.resolve(),
        onEdit: () => undefined,
-        onEnable: () => Promise.resolve(),
        onPageChange: () => undefined,
-        onTest: () => Promise.resolve({ message: "ok", ok: true }),
        page: 1,
        pageSize: 20,
      }),
@@ -54,36 +49,33 @@ describe("ProviderTable", () => {
    expect(screen.getAllByText("OpenAI").length).toBeGreaterThan(0);
    expect(screen.getByText("DeepSeek")).not.toBeNull();
    expect(screen.getByText("https://api.openai.com/v1")).not.toBeNull();
+    expect(screen.queryByText("状态")).toBeNull();
+    expect(screen.queryByRole("button", { name: "测试连接" })).toBeNull();
+    expect(screen.queryByRole("button", { name: /启用|禁用/ })).toBeNull();
  });

-  test("供应商表格操作触发 enable/disable/delete", async () => {
-    const onDisable = mock(() => Promise.resolve());
-    const onEnable = mock(() => Promise.resolve());
+  test("供应商表格操作触发 edit/delete", async () => {
    const onDelete = mock(() => Promise.resolve());
+    const onEdit = mock(() => undefined);

    renderWithProviders(
      createElement(ProviderTable, {
-        data: { items: [ENABLED_PROVIDER, DISABLED_PROVIDER], page: 1, pageSize: 20, total: 2 },
+        data: { items: [OPENAI_PROVIDER, DEEPSEEK_PROVIDER], page: 1, pageSize: 20, total: 2 },
        loading: false,
        onDelete,
-        onDisable,
-        onEdit: () => undefined,
-        onEnable,
+        onEdit,
        onPageChange: () => undefined,
-        onTest: () => Promise.resolve({ message: "ok", ok: true }),
        page: 1,
        pageSize: 20,
      }),
    );

-    const disableButtons = screen.getAllByRole("button", { name: /禁用/ });
-    fireEvent.click(disableButtons[0]!);
-    await waitFor(() => expect(screen.getByText("确认禁用此供应商？")).not.toBeNull());
-    clickLatestConfirmButton();
-    await waitFor(() => expect(onDisable).toHaveBeenCalledWith("pv1"));
+    fireEvent.click(screen.getAllByRole("button", { name: /编辑/ })[0]!);
+    expect(onEdit).toHaveBeenCalledWith(OPENAI_PROVIDER);

-    const enableButtons = screen.getAllByRole("button", { name: /启用/ });
-    fireEvent.click(enableButtons[0]!);
-    await waitFor(() => expect(onEnable).toHaveBeenCalledWith("pv2"));
+    fireEvent.click(screen.getAllByRole("button", { name: /删除/ })[0]!);
+    await waitFor(() => expect(screen.getByText("确认删除此供应商？")).not.toBeNull());
+    clickLatestConfirmButton();
+    await waitFor(() => expect(onDelete).toHaveBeenCalledWith("pv1"));
  });
 });
--- a/tests/web/hooks/use-models.test.ts
+++ b/tests/web/hooks/use-models.test.ts
@@ -3,10 +3,9 @@ import { describe, expect, test } from "bun:test";
 import {
  createModel,
  deleteModel,
-  disableModel,
-  enableModel,
  fetchModel,
  fetchModelList,
+  testModelConnection,
  updateModel,
 } from "../../../src/web/hooks/use-models";
 import { installFetchMock, jsonResponse } from "../test-utils";
@@ -15,7 +14,6 @@ const MODEL = {
  capabilities: ["text"] as Array<"text">,
  contextLength: null,
  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: true,
  id: "m1",
  maxOutputTokens: null,
  modelId: "gpt-4o",
@@ -50,7 +48,7 @@ describe("use-models request helpers", () => {
    expect(calls[0]?.url).toContain("keyword=GPT");
  });

-  test("模型 CRUD 与 enable/disable 使用正确 method、URL 与 body", async () => {
+  test("模型 CRUD 使用正确 method、URL 与 body", async () => {
    const calls = installFetchMock((call) => {
      if (call.method === "DELETE") return new Response(null, { status: 204 });
      return jsonResponse(
@@ -66,16 +64,12 @@ describe("use-models request helpers", () => {
      providerId: "pv1",
    });
    await updateModel("m1", { name: "GPT-4o Mini" });
-    await enableModel("m1");
-    await disableModel("m1");
    await deleteModel("m1");
    await fetchModel("m1");

    expect(calls.map((call) => `${call.method} ${call.url}`)).toEqual([
      "POST /api/models",
      "PATCH /api/models/m1",
-      "POST /api/models/m1/enable",
-      "POST /api/models/m1/disable",
      "DELETE /api/models/m1",
      "GET /api/models/m1",
    ]);
@@ -102,4 +96,16 @@ describe("use-models request helpers", () => {

    await expectRejectsWithMessage(() => fetchModel("m-missing"), "HTTP 500");
  });
+
+  test("testModelConnection 调用正确 URL 和 body", async () => {
+    const calls = installFetchMock(() => jsonResponse({ modelTestResponse: { message: "模型连接成功", ok: true } }));
+
+    const result = await testModelConnection({ modelId: "gpt-4o", providerId: "pv1" });
+
+    expect(result.ok).toBe(true);
+    expect(result.message).toBe("模型连接成功");
+    expect(calls[0]?.method).toBe("POST");
+    expect(calls[0]?.url).toBe("/api/models/test");
+    expect(jsonBody(calls[0]?.body)).toEqual({ modelId: "gpt-4o", providerId: "pv1" });
+  });
 });
--- a/tests/web/hooks/use-providers.test.ts
+++ b/tests/web/hooks/use-providers.test.ts
@@ -3,11 +3,10 @@ import { describe, expect, test } from "bun:test";
 import {
  createProvider,
  deleteProvider,
-  disableProvider,
-  enableProvider,
  fetchProvider,
  fetchProviderList,
-  testProviderConnection,
+  fetchProviderOptions,
+  testProviderConfig,
  updateProvider,
 } from "../../../src/web/hooks/use-providers";
 import { installFetchMock, jsonResponse } from "../test-utils";
@@ -16,7 +15,6 @@ const PROVIDER = {
  apiKey: "sk-test",
  baseUrl: "https://api.openai.com/v1",
  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: true,
  id: "pv1",
  name: "OpenAI",
  type: "openai" as const,
@@ -48,7 +46,7 @@ describe("use-providers request helpers", () => {
    expect(calls[0]?.url).toBe("/api/providers?page=1&pageSize=20&keyword=OpenAI");
  });

-  test("CRUD and enable/disable use correct method, URL and body", async () => {
+  test("CRUD uses correct method, URL and body", async () => {
    const calls = installFetchMock((call) => {
      if (call.method === "DELETE") return new Response(null, { status: 204 });
      return jsonResponse(
@@ -59,16 +57,12 @@ describe("use-providers request helpers", () => {

    await createProvider({ apiKey: "sk-test", baseUrl: "https://api.openai.com/v1", name: "OpenAI", type: "openai" });
    await updateProvider("pv1", { name: "New OpenAI" });
-    await enableProvider("pv1");
-    await disableProvider("pv1");
    await deleteProvider("pv1");
    await fetchProvider("pv1");

    expect(calls.map((c) => c.method + " " + c.url)).toEqual([
      "POST /api/providers",
      "PATCH /api/providers/pv1",
-      "POST /api/providers/pv1/enable",
-      "POST /api/providers/pv1/disable",
      "DELETE /api/providers/pv1",
      "GET /api/providers/pv1",
    ]);
@@ -81,12 +75,35 @@ describe("use-providers request helpers", () => {
    expect(jsonBody(calls[1]?.body)).toEqual({ name: "New OpenAI" });
  });

-  test("testProviderConnection uses correct URL and parses response", async () => {
-    installFetchMock(() => jsonResponse({ providerTestResponse: { message: "ok", ok: true } }));
+  test("fetchProviderOptions uses dedicated minimal endpoint", async () => {
+    const calls = installFetchMock(() => jsonResponse({ items: [{ id: "pv1", name: "OpenAI", type: "openai" }] }));

-    const result = await testProviderConnection("pv1");
+    const result = await fetchProviderOptions();
+
+    expect(result.items).toEqual([{ id: "pv1", name: "OpenAI", type: "openai" }]);
+    expect(calls[0]?.method).toBe("GET");
+    expect(calls[0]?.url).toBe("/api/providers/options");
+  });
+
+  test("testProviderConfig posts form config and parses response", async () => {
+    const calls = installFetchMock(() => jsonResponse({ providerTestResponse: { message: "ok", ok: true } }));
+
+    const result = await testProviderConfig({
+      apiKey: "sk-test",
+      baseUrl: "https://api.openai.com/v1",
+      name: "OpenAI",
+      type: "openai-compatible",
+    });

    expect(result).toEqual({ message: "ok", ok: true });
+    expect(calls[0]?.method).toBe("POST");
+    expect(calls[0]?.url).toBe("/api/providers/test");
+    expect(jsonBody(calls[0]?.body)).toEqual({
+      apiKey: "sk-test",
+      baseUrl: "https://api.openai.com/v1",
+      name: "OpenAI",
+      type: "openai-compatible",
+    });
  });

  test("error response uses backend error field", async () => {
--- a/tests/web/routes/models.test.tsx
+++ b/tests/web/routes/models.test.tsx
@@ -12,7 +12,6 @@ const ENABLED_PROVIDER: Provider = {
  apiKey: "sk-test",
  baseUrl: "https://api.openai.com/v1",
  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: true,
  id: "pv1",
  name: "OpenAI",
  type: "openai",
@@ -23,7 +22,6 @@ const DISABLED_PROVIDER: Provider = {
  apiKey: "sk-off",
  baseUrl: "https://api.deepseek.com/v1",
  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: false,
  id: "pv2",
  name: "DeepSeek",
  type: "openai-compatible",
@@ -34,7 +32,6 @@ const ENABLED_MODEL: Model = {
  capabilities: ["text", "reasoning"],
  contextLength: 128000,
  createdAt: "2024-01-01T00:00:00.000Z",
-  enabled: true,
  id: "m1",
  maxOutputTokens: 4096,
  modelId: "gpt-4o",
@@ -58,6 +55,7 @@ describe("ProviderFormModal", () => {
        onCancel: () => undefined,
        onCreate: () => Promise.resolve(),
        onOpenChange: () => undefined,
+        onTest: () => Promise.resolve({ message: "连接成功", ok: true }),
        onUpdate: (args: unknown) => {
          updateCalls.push(args);
          return Promise.resolve();
@@ -74,6 +72,78 @@ describe("ProviderFormModal", () => {
    await waitFor(() => expect(updateCalls.length).toBe(1));
    expect(updateCalls[0]).toEqual({ data: { name: "New OpenAI" }, id: "pv1" });
  });
+
+  test("新建供应商默认使用 openai-compatible 类型", async () => {
+    const createCalls: unknown[] = [];
+
+    renderWithProviders(
+      createElement(ProviderFormModal, {
+        editingProvider: null,
+        onCancel: () => undefined,
+        onCreate: (data: unknown) => {
+          createCalls.push(data);
+          return Promise.resolve();
+        },
+        onOpenChange: () => undefined,
+        onTest: () => Promise.resolve({ message: "连接成功", ok: true }),
+        onUpdate: () => Promise.resolve(),
+        open: true,
+        submitting: false,
+      }),
+    );
+
+    await waitFor(() => expect(screen.getByPlaceholderText("请输入供应商名称")).not.toBeNull());
+    fireEvent.change(screen.getByPlaceholderText("请输入供应商名称"), { target: { value: "兼容供应商" } });
+    fireEvent.change(screen.getByPlaceholderText("https://api.openai.com/v1"), {
+      target: { value: "https://api.test.com/v1" },
+    });
+    fireEvent.change(screen.getByPlaceholderText("请输入 API Key"), { target: { value: "sk-test" } });
+    clickLatestConfirmButton();
+
+    await waitFor(() => expect(createCalls.length).toBe(1));
+    expect(createCalls[0]).toEqual({
+      apiKey: "sk-test",
+      baseUrl: "https://api.test.com/v1",
+      name: "兼容供应商",
+      type: "openai-compatible",
+    });
+  });
+
+  test("供应商表单可使用当前表单配置测试连接", async () => {
+    const testCalls: unknown[] = [];
+
+    renderWithProviders(
+      createElement(ProviderFormModal, {
+        editingProvider: null,
+        onCancel: () => undefined,
+        onCreate: () => Promise.resolve(),
+        onOpenChange: () => undefined,
+        onTest: (data: unknown) => {
+          testCalls.push(data);
+          return Promise.resolve({ message: "连接成功", ok: true });
+        },
+        onUpdate: () => Promise.resolve(),
+        open: true,
+        submitting: false,
+      }),
+    );
+
+    await waitFor(() => expect(screen.getByPlaceholderText("请输入供应商名称")).not.toBeNull());
+    fireEvent.change(screen.getByPlaceholderText("请输入供应商名称"), { target: { value: "兼容供应商" } });
+    fireEvent.change(screen.getByPlaceholderText("https://api.openai.com/v1"), {
+      target: { value: "https://api.test.com/v1" },
+    });
+    fireEvent.change(screen.getByPlaceholderText("请输入 API Key"), { target: { value: "sk-test" } });
+    fireEvent.click(screen.getByRole("button", { name: "测试连接" }));
+
+    await waitFor(() => expect(testCalls.length).toBe(1));
+    expect(testCalls[0]).toEqual({
+      apiKey: "sk-test",
+      baseUrl: "https://api.test.com/v1",
+      name: "兼容供应商",
+      type: "openai-compatible",
+    });
+  });
 });

 describe("ModelFormModal", () => {
@@ -92,6 +162,8 @@ describe("ModelFormModal", () => {
        },
        open: true,
        providers: [ENABLED_PROVIDER, DISABLED_PROVIDER],
+        providersError: null,
+        providersLoading: false,
        submitting: false,
      }),
    );
@@ -116,6 +188,8 @@ describe("ModelFormModal", () => {
        onUpdate: () => Promise.resolve(),
        open: true,
        providers: [ENABLED_PROVIDER],
+        providersError: null,
+        providersLoading: false,
        submitting: false,
      }),
    );
@@ -124,4 +198,122 @@ describe("ModelFormModal", () => {
    clickLatestConfirmButton();
    expect(onCreate).not.toHaveBeenCalled();
  });
+
+  test("新建模型默认选中文本和推理能力", async () => {
+    renderWithProviders(
+      createElement(ModelFormModal, {
+        editingModel: null,
+        onCancel: () => undefined,
+        onCreate: () => Promise.resolve(),
+        onOpenChange: () => undefined,
+        onUpdate: () => Promise.resolve(),
+        open: true,
+        providers: [ENABLED_PROVIDER],
+        providersError: null,
+        providersLoading: false,
+        submitting: false,
+      }),
+    );
+
+    await waitFor(() => expect(screen.getByLabelText("文本")).not.toBeNull());
+    const textCheckbox = screen.getByLabelText("文本");
+    const reasoningCheckbox = screen.getByLabelText("推理");
+    expect((textCheckbox as { checked?: boolean }).checked).toBe(true);
+    expect((reasoningCheckbox as { checked?: boolean }).checked).toBe(true);
+  });
+
+  test("新建模型展示供应商 options 列表", async () => {
+    renderWithProviders(
+      createElement(ModelFormModal, {
+        editingModel: null,
+        onCancel: () => undefined,
+        onCreate: () => Promise.resolve(),
+        onOpenChange: () => undefined,
+        onUpdate: () => Promise.resolve(),
+        open: true,
+        providers: [ENABLED_PROVIDER, DISABLED_PROVIDER],
+        providersError: null,
+        providersLoading: false,
+        submitting: false,
+      }),
+    );
+
+    await waitFor(() => expect(screen.getByPlaceholderText("请输入模型名称")).not.toBeNull());
+    fireEvent.mouseDown(screen.getByRole("combobox"));
+
+    expect(await screen.findByText("OpenAI")).not.toBeNull();
+    expect(await screen.findByText("DeepSeek")).not.toBeNull();
+  });
+
+  test("供应商下拉展示加载错误提示", async () => {
+    renderWithProviders(
+      createElement(ModelFormModal, {
+        editingModel: null,
+        onCancel: () => undefined,
+        onCreate: () => Promise.resolve(),
+        onOpenChange: () => undefined,
+        onUpdate: () => Promise.resolve(),
+        open: true,
+        providers: [],
+        providersError: new Error("options failed"),
+        providersLoading: false,
+        submitting: false,
+      }),
+    );
+
+    await waitFor(() => expect(screen.getByPlaceholderText("请输入模型名称")).not.toBeNull());
+    fireEvent.mouseDown(screen.getByRole("combobox"));
+
+    expect(await screen.findByText("供应商加载失败：options failed")).not.toBeNull();
+  });
+
+  test("编辑模型时可测试模型连接", async () => {
+    const testModelConnection = mock(() => Promise.resolve({ message: "模型连接成功", ok: true }));
+
+    renderWithProviders(
+      createElement(ModelFormModal, {
+        editingModel: ENABLED_MODEL,
+        onCancel: () => undefined,
+        onCreate: () => Promise.resolve(),
+        onOpenChange: () => undefined,
+        onUpdate: () => Promise.resolve(),
+        open: true,
+        providers: [ENABLED_PROVIDER],
+        providersError: null,
+        providersLoading: false,
+        submitting: false,
+        testModelConnection,
+      }),
+    );
+
+    await waitFor(() => expect(screen.getByRole("button", { name: "测试连接" })).not.toBeNull());
+    fireEvent.click(screen.getByRole("button", { name: "测试连接" }));
+
+    await waitFor(() =>
+      expect(testModelConnection).toHaveBeenCalledWith({
+        modelId: "gpt-4o",
+        providerId: "pv1",
+      }),
+    );
+  });
+
+  test("新建模型也显示测试连接按钮", async () => {
+    renderWithProviders(
+      createElement(ModelFormModal, {
+        editingModel: null,
+        onCancel: () => undefined,
+        onCreate: () => Promise.resolve(),
+        onOpenChange: () => undefined,
+        onUpdate: () => Promise.resolve(),
+        open: true,
+        providers: [ENABLED_PROVIDER],
+        providersError: null,
+        providersLoading: false,
+        submitting: false,
+        testModelConnection: () => Promise.resolve({ message: "ok", ok: true }),
+      }),
+    );
+
+    await waitFor(() => expect(screen.getByRole("button", { name: "测试连接" })).not.toBeNull());
+  });
 });
--- a/tests/web/test-utils.tsx
+++ b/tests/web/test-utils.tsx
@@ -7,6 +7,8 @@ import { MemoryRouter } from "react-router";

 import { ErrorBoundary } from "../../src/web/components/ErrorBoundary";

+const REAL_FETCH = globalThis.fetch.bind(globalThis);
+
 // Mock recharts BEFORE any component imports
 void mock.module("recharts", () => ({
  Area: () => null,
@@ -34,6 +36,7 @@ export function installFetchMock(handler: (call: FetchMockCall) => Promise<Respo
  const mocked = (async (input: RequestInfo | URL, init?: RequestInit) => {
    const request = input instanceof Request ? input : undefined;
    const url = request?.url ?? (typeof input === "string" ? input : input instanceof URL ? input.href : input.url);
+    if (url.startsWith("http://") || url.startsWith("https://")) return REAL_FETCH(input, init);
    const call: FetchMockCall = {
      body: init?.body ?? null,
      method: init?.method ?? request?.method ?? "GET",