feat: 新增模型管理功能（供应商 + 模型 CRUD）

- 新增 providers/models 数据库表、迁移和数据访问层
- 新增 15 个后端 API 路由（供应商/模型 CRUD + 连通性测试）
- 新增 AI 服务层（registry.ts: buildProviderRegistry + testProviderConnection）
- 新增前端模型管理页面（Tabs: 供应商/模型，含表格、表单、工具栏）
- 新增前端 hooks（use-providers, use-models）
- 新增共享类型和 MODEL_CAPABILITIES 常量
- 新增 10 个测试文件（66 个测试用例，4 个因 bun test ESM 兼容问题待修复）
- 更新开发文档（architecture, backend, frontend）
- 附带 apply-review 修复：统一错误响应、提取共享常量、清理重复测试

注意：registry.test.ts 中 4 个测试因 bun test 无法解析
createProviderRegistry ESM 导出而失败，详情见 context.md

tests/server/ai/registry.test.ts

@@ -0,0 +1,78 @@
+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");
+      }),
+    }));
+
+    const { testProviderConnection } = await import("../../../src/server/ai/registry");
+
+    const result = await testProviderConnection({
+      apiKey: "bad-key",
+      baseUrl: "https://0.0.0.0:1",
+      name: "Bad",
+      type: "openai-compatible",
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.message).toContain("连接失败");
+    expect(typeof result.message).toBe("string");
+  });
+
+  test("testProviderConnection return shape is correct", async () => {
+    void mock.module("ai", () => ({
+      generateText: mock((_opts: unknown) => ({})),
+    }));
+
+    const { testProviderConnection } = await import("../../../src/server/ai/registry");
+
+    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).toBe("连接成功");
+  });
+
+  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 (?, ?, ?, ?, ?, ?, ?, ?)",
+      )
+      .run("pv1", "OpenAI", "openai", "https://api.openai.com/v1", "sk-test", 1, now, now);
+    handle.db
+      .prepare(
+        "INSERT INTO providers (id, name, type, base_url, api_key, enabled, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+      )
+      .run("pv2", "Disabled", "anthropic", "https://api.anthropic.com", "sk-off", 0, now, now);
+
+    const { buildProviderRegistry } = await import("../../../src/server/ai/registry");
+    const registry = buildProviderRegistry(handle.db);
+
+    expect(() => registry.languageModel("pv1:gpt-4o")).not.toThrow();
+
+    handle.cleanup();
+  });
+
+  test("buildProviderRegistry 无启用供应商时返回空注册表", async () => {
+    const handle = createMigratedTestDatabase("registry-empty-test");
+
+    const { buildProviderRegistry } = await import("../../../src/server/ai/registry");
+    const registry = buildProviderRegistry(handle.db);
+
+    expect(typeof registry.languageModel).toBe("function");
+
+    handle.cleanup();
+  });
+});

tests/server/db/models.test.ts

@@ -0,0 +1,226 @@
+import type Database from "bun:sqlite";
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  createModel,
+  deleteModel,
+  disableModel,
+  enableModel,
+  getModel,
+  getModelsByProviderId,
+  listModels,
+  updateModel,
+} from "../../../src/server/db/models";
+import { createProvider } from "../../../src/server/db/providers";
+import { createMigratedTestDatabase } from "../../helpers";
+
+function seedProvider(db: Database, name = "TestProvider"): string {
+  const result = createProvider(db, { apiKey: "sk-test", baseUrl: "https://api.test.com/v1", name, type: "openai" });
+  return (result as { provider: { id: string } }).provider.id;
+}
+
+function withDb(callback: (db: Database) => void): void {
+  const handle = createMigratedTestDatabase("models-test");
+  try {
+    callback(handle.db);
+    handle.close();
+  } finally {
+    handle.cleanup();
+  }
+}
+
+describe("模型数据访问层", () => {
+  test("创建模型", () => {
+    withDb((db) => {
+      const providerId = seedProvider(db);
+      const result = createModel(db, {
+        capabilities: ["text", "reasoning"],
+        modelId: "gpt-4o",
+        name: "GPT-4o",
+        providerId,
+      });
+      expect("error" in result).toBe(false);
+      const model = (
+        result as {
+          model: { capabilities: string[]; enabled: boolean; 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);
+    });
+  });
+
+  test("供应商不存在时创建失败", () => {
+    withDb((db) => {
+      const result = createModel(db, {
+        capabilities: ["text"],
+        modelId: "test",
+        name: "Test",
+        providerId: "nonexistent",
+      });
+      expect("error" in result).toBe(true);
+      expect((result as unknown as { status: number }).status).toBe(400);
+    });
+  });
+
+  test("同一供应商下模型 ID 唯一", () => {
+    withDb((db) => {
+      const providerId = seedProvider(db);
+      createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "Model1", providerId });
+      const result = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "Model2", providerId });
+      expect("error" in result).toBe(true);
+      expect((result as unknown as { error: string }).error).toContain("已存在");
+    });
+  });
+
+  test("不同供应商下模型 ID 可重复", () => {
+    withDb((db) => {
+      const p1 = seedProvider(db, "P1");
+      const p2 = seedProvider(db, "P2");
+      const r1 = createModel(db, { capabilities: ["text"], modelId: "same-id", name: "M1", providerId: p1 });
+      const r2 = createModel(db, { capabilities: ["text"], modelId: "same-id", name: "M2", providerId: p2 });
+      expect("error" in r1).toBe(false);
+      expect("error" in r2).toBe(false);
+    });
+  });
+
+  test("能力标签为空时创建失败", () => {
+    withDb((db) => {
+      const providerId = seedProvider(db);
+      const result = createModel(db, { capabilities: [], modelId: "test", name: "Test", providerId });
+      expect("error" in result).toBe(true);
+      expect((result as unknown as { error: string }).error).toContain("能力标签");
+    });
+  });
+
+  test("列表查询（分页、关键字、供应商过滤）", () => {
+    withDb((db) => {
+      const p1 = seedProvider(db, "P1");
+      const p2 = seedProvider(db, "P2");
+      createModel(db, { capabilities: ["text"], modelId: "m1", name: "Alpha", providerId: p1 });
+      createModel(db, { capabilities: ["text"], modelId: "m2", name: "Beta", providerId: p1 });
+      createModel(db, { capabilities: ["text"], modelId: "m3", name: "Gamma", providerId: p2 });
+
+      const all = listModels(db, { page: 1, pageSize: 20 });
+      expect(all.total).toBe(3);
+
+      const filtered = listModels(db, { page: 1, pageSize: 20, providerId: p1 });
+      expect(filtered.total).toBe(2);
+
+      const searched = listModels(db, { keyword: "Alpha", page: 1, pageSize: 20 });
+      expect(searched.total).toBe(1);
+    });
+  });
+
+  test("获取模型详情", () => {
+    withDb((db) => {
+      const providerId = seedProvider(db);
+      const created = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "GPT-4o", providerId });
+      const id = (created as { model: { id: string } }).model.id;
+
+      const result = getModel(db, id);
+      expect("error" in result).toBe(false);
+      expect((result as { model: { name: string } }).model.name).toBe("GPT-4o");
+    });
+  });
+
+  test("获取不存在的模型返回 404", () => {
+    withDb((db) => {
+      const result = getModel(db, "nonexistent");
+      expect("error" in result).toBe(true);
+      expect((result as unknown as { status: number }).status).toBe(404);
+    });
+  });
+
+  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 result = updateModel(db, id, { capabilities: ["text", "reasoning"], name: "新名" });
+      expect("error" in result).toBe(false);
+      const updated = (result as { model: { capabilities: string[]; name: string } }).model;
+      expect(updated.name).toBe("新名");
+      expect(updated.capabilities).toEqual(["text", "reasoning"]);
+    });
+  });
+
+  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);
+      const created = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "删除测试", providerId });
+      const id = (created as { model: { id: string } }).model.id;
+
+      const result = deleteModel(db, id);
+      expect("error" in result).toBe(false);
+
+      const after = getModel(db, id);
+      expect("error" in after).toBe(true);
+    });
+  });
+
+  test("getModelsByProviderId 返回正确数量", () => {
+    withDb((db) => {
+      const p1 = seedProvider(db, "P1");
+      const p2 = seedProvider(db, "P2");
+      createModel(db, { capabilities: ["text"], modelId: "m1", name: "M1", providerId: p1 });
+      createModel(db, { capabilities: ["text"], modelId: "m2", name: "M2", providerId: p1 });
+      createModel(db, { capabilities: ["text"], modelId: "m3", name: "M3", providerId: p2 });
+
+      expect(getModelsByProviderId(db, p1)).toBe(2);
+      expect(getModelsByProviderId(db, p2)).toBe(1);
+    });
+  });
+
+  test("可选字段 contextLength 和 maxOutputTokens", () => {
+    withDb((db) => {
+      const providerId = seedProvider(db);
+      const result = createModel(db, {
+        capabilities: ["text"],
+        contextLength: 128000,
+        maxOutputTokens: 4096,
+        modelId: "gpt-4o",
+        name: "GPT-4o",
+        providerId,
+      });
+      expect("error" in result).toBe(false);
+      const model = (result as { model: { contextLength: null | number; maxOutputTokens: null | number } }).model;
+      expect(model.contextLength).toBe(128000);
+      expect(model.maxOutputTokens).toBe(4096);
+    });
+  });
+});

tests/server/db/providers.test.ts

@@ -0,0 +1,195 @@
+import type Database from "bun:sqlite";
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  createProvider,
+  deleteProvider,
+  disableProvider,
+  enableProvider,
+  getProvider,
+  listProviders,
+  updateProvider,
+} from "../../../src/server/db/providers";
+import { createMigratedTestDatabase } from "../../helpers";
+
+function withDb(callback: (db: Database) => void): void {
+  const handle = createMigratedTestDatabase("providers-test");
+  try {
+    callback(handle.db);
+    handle.close();
+  } finally {
+    handle.cleanup();
+  }
+}
+
+describe("供应商数据访问层", () => {
+  test("创建供应商", () => {
+    withDb((db) => {
+      const result = createProvider(db, {
+        apiKey: "sk-test",
+        baseUrl: "https://api.openai.com/v1",
+        name: "OpenAI",
+        type: "openai",
+      });
+      expect("error" in result).toBe(false);
+      const provider = (
+        result as { provider: { apiKey: string; baseUrl: string; enabled: boolean; 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);
+    });
+  });
+
+  test("供应商名称唯一", () => {
+    withDb((db) => {
+      createProvider(db, { apiKey: "sk-1", baseUrl: "https://a.com", name: "唯一", type: "openai" });
+      const result = createProvider(db, { apiKey: "sk-2", baseUrl: "https://b.com", name: "唯一", type: "openai" });
+      expect("error" in result).toBe(true);
+      expect((result as unknown as { error: string }).error).toContain("已存在");
+    });
+  });
+
+  test("名称为空时创建失败", () => {
+    withDb((db) => {
+      const result = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "   ", type: "openai" });
+      expect("error" in result).toBe(true);
+      expect((result as unknown as { error: string }).error).toContain("不能为空");
+    });
+  });
+
+  test("列表查询（分页和关键字）", () => {
+    withDb((db) => {
+      createProvider(db, { apiKey: "sk-1", baseUrl: "https://a.com", name: "Alpha", type: "openai" });
+      createProvider(db, { apiKey: "sk-2", baseUrl: "https://b.com", name: "Beta", type: "anthropic" });
+      createProvider(db, { apiKey: "sk-3", baseUrl: "https://c.com", name: "Gamma", type: "openai-compatible" });
+
+      const result1 = listProviders(db, { page: 1, pageSize: 20 });
+      expect(result1.total).toBe(3);
+
+      const result2 = listProviders(db, { keyword: "Alpha", page: 1, pageSize: 20 });
+      expect(result2.total).toBe(1);
+      expect(result2.items[0]!.name).toBe("Alpha");
+
+      const result3 = listProviders(db, { page: 1, pageSize: 2 });
+      expect(result3.items.length).toBe(2);
+    });
+  });
+
+  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 = getProvider(db, id);
+      expect("error" in result).toBe(false);
+      expect((result as { provider: { name: string } }).provider.name).toBe("详情");
+    });
+  });
+
+  test("获取不存在的供应商返回 404", () => {
+    withDb((db) => {
+      const result = getProvider(db, "nonexistent");
+      expect("error" in result).toBe(true);
+      expect((result as unknown as { status: number }).status).toBe(404);
+    });
+  });
+
+  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 = updateProvider(db, id, { name: "新名" });
+      expect("error" in result).toBe(false);
+      expect((result as { provider: { name: string } }).provider.name).toBe("新名");
+    });
+  });
+
+  test("更新供应商名称重复失败", () => {
+    withDb((db) => {
+      createProvider(db, { apiKey: "sk-1", baseUrl: "https://a.com", name: "已存在", type: "openai" });
+      const created = createProvider(db, { apiKey: "sk-2", baseUrl: "https://b.com", name: "原名", type: "openai" });
+      const id = (created as { provider: { id: string } }).provider.id;
+
+      const result = updateProvider(db, id, { name: "已存在" });
+      expect("error" in result).toBe(true);
+      expect((result as unknown as { error: string }).error).toContain("已存在");
+    });
+  });
+
+  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" });
+      const id = (created as { provider: { id: string } }).provider.id;
+
+      const result = deleteProvider(db, id);
+      expect("error" in result).toBe(false);
+
+      const after = getProvider(db, id);
+      expect("error" in after).toBe(true);
+    });
+  });
+
+  test("删除不存在的供应商返回 404", () => {
+    withDb((db) => {
+      const result = deleteProvider(db, "nonexistent");
+      expect("error" in result).toBe(true);
+      expect((result as unknown as { status: number }).status).toBe(404);
+    });
+  });
+
+  test("默认类型为 openai-compatible", () => {
+    withDb((db) => {
+      createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "默认类型", type: "openai-compatible" });
+      const result = createProvider(db, {
+        apiKey: "sk2",
+        baseUrl: "https://b.com",
+        name: "显式默认",
+        type: "openai-compatible",
+      });
+      expect((result as { provider: { type: string } }).provider.type).toBe("openai-compatible");
+    });
+  });
+});

tests/server/routes/models.test.ts

@@ -0,0 +1,222 @@
+import type Database from "bun:sqlite";
+
+import { describe, expect, test } from "bun:test";
+
+import type { Model, RuntimeMode } from "../../../src/shared/api";
+
+import { createMigratedMemoryTestDatabase } from "../../helpers";
+
+const MODE: RuntimeMode = "test";
+
+async function createModelViaHandler(req: Request, db: Database): Promise<Response> {
+  const { handleCreateModel: h } = await import("../../../src/server/routes/models/create");
+  return h(req, db, MODE);
+}
+
+function createTestModel(db: Database, pName: string, providerId?: string): Model {
+  const pid = providerId ?? seedProvider(db);
+  const result = createModel(db, {
+    capabilities: ["text"],
+    modelId: pName.toLowerCase().replace(/[^a-z0-9-]/g, "-"),
+    name: pName,
+    providerId: pid,
+  });
+  if ("error" in result) throw new Error(result.error);
+  return result.model;
+}
+
+async function deleteModelViaHandler(req: Request, db: Database): Promise<Response> {
+  const { handleDeleteModel: h } = await import("../../../src/server/routes/models/delete");
+  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);
+}
+
+async function listModelsViaHandler(req: Request, db: Database): Promise<Response> {
+  const { handleListModels: h } = await import("../../../src/server/routes/models/list");
+  return h(req, db, MODE);
+}
+
+import { createModel } from "../../../src/server/db/models";
+import { createProvider } from "../../../src/server/db/providers";
+
+function seedProvider(db: Database, name?: string): string {
+  const result = createProvider(db, {
+    apiKey: "sk-test",
+    baseUrl: "https://api.test.com/v1",
+    name: name ?? "TestProvider",
+    type: "openai",
+  });
+  if ("error" in result) throw new Error(result.error);
+  return result.provider.id;
+}
+
+async function updateModelViaHandler(req: Request, db: Database): Promise<Response> {
+  const { handleUpdateModel: h } = await import("../../../src/server/routes/models/update");
+  return h(req, db, MODE);
+}
+
+async function withRouteDb(callback: (db: Database) => Promise<void>): Promise<void> {
+  const handle = createMigratedMemoryTestDatabase("route-model-test");
+  try {
+    await callback(handle.db);
+    handle.close();
+  } finally {
+    handle.cleanup();
+  }
+}
+
+describe("models API routes", () => {
+  test("POST /api/models create", async () => {
+    await withRouteDb(async (db) => {
+      const providerId = seedProvider(db);
+
+      const req = new Request("http://localhost/api/models", {
+        body: JSON.stringify({
+          capabilities: ["text", "reasoning"],
+          modelId: "gpt-4o",
+          name: "GPT-4o",
+          providerId,
+        }),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      });
+      const res = await createModelViaHandler(req, db);
+      expect(res.status).toBe(201);
+      const body = (await res.json()) as { model: Model };
+      expect(body.model.name).toBe("GPT-4o");
+      expect(body.model.modelId).toBe("gpt-4o");
+    });
+  });
+
+  test("GET /api/models list", async () => {
+    await withRouteDb(async (db) => {
+      const p1 = seedProvider(db, "ListP1");
+      const p2 = seedProvider(db, "ListP2");
+      createTestModel(db, "A-Model", p1);
+      createTestModel(db, "B-Model", p2);
+
+      const req = new Request("http://localhost/api/models?page=1&pageSize=20");
+      const res = await listModelsViaHandler(req, db);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { items: Model[]; total: number };
+      expect(body.total).toBe(2);
+      expect(body.items.length).toBe(2);
+    });
+  });
+
+  test("GET /api/models filter by providerId", async () => {
+    await withRouteDb(async (db) => {
+      const p1 = seedProvider(db, "P1");
+      const p2 = seedProvider(db, "P2");
+      createTestModel(db, "M1", p1);
+      createTestModel(db, "M2", p2);
+
+      const res = await listModelsViaHandler(
+        new Request("http://localhost/api/models?page=1&pageSize=20&providerId=" + p1),
+        db,
+      );
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { items: Model[]; total: number };
+      expect(body.total).toBe(1);
+    });
+  });
+
+  test("GET /api/models/:id get detail", async () => {
+    await withRouteDb(async (db) => {
+      const model = createTestModel(db, "Detail");
+
+      const req = new Request("http://localhost/api/models/" + model.id);
+      const res = await getModelViaHandler(req, db);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { model: Model };
+      expect(body.model.name).toBe("Detail");
+    });
+  });
+
+  test("PATCH /api/models/:id update", async () => {
+    await withRouteDb(async (db) => {
+      const model = createTestModel(db, "OldName");
+
+      const req = new Request("http://localhost/api/models/" + model.id, {
+        body: JSON.stringify({ name: "Updated" }),
+        headers: { "Content-Type": "application/json" },
+        method: "PATCH",
+      });
+      const res = await updateModelViaHandler(req, db);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { model: Model };
+      expect(body.model.name).toBe("Updated");
+    });
+  });
+
+  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");
+
+      const req = new Request("http://localhost/api/models/" + model.id, { method: "DELETE" });
+      const res = await deleteModelViaHandler(req, db);
+      expect(res.status).toBe(204);
+    });
+  });
+
+  test("invalid capabilities returns 400", async () => {
+    await withRouteDb(async (db) => {
+      const providerId = seedProvider(db);
+
+      const req = new Request("http://localhost/api/models", {
+        body: JSON.stringify({
+          capabilities: ["invalid-cap"],
+          modelId: "test",
+          name: "Test",
+          providerId,
+        }),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      });
+      const res = await createModelViaHandler(req, db);
+      expect(res.status).toBe(400);
+    });
+  });
+});

tests/server/routes/providers.test.ts

@@ -0,0 +1,198 @@
+import type Database from "bun:sqlite";
+
+import { describe, expect, test } from "bun:test";
+
+import type { Provider, RuntimeMode } from "../../../src/shared/api";
+
+import { createMigratedMemoryTestDatabase } from "../../helpers";
+
+const MODE: RuntimeMode = "test";
+
+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 {
+  const result = createProvider(db, {
+    apiKey: "sk-test",
+    baseUrl: "https://api.test.com/v1",
+    name,
+    type: "openai",
+  });
+  if ("error" in result) throw new Error(result.error);
+  return result.provider;
+}
+
+async function deleteProviderViaHandler(req: Request, db: Database): Promise<Response> {
+  const { handleDeleteProvider: h } = await import("../../../src/server/routes/providers/delete");
+  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 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 updateProviderViaHandler(req: Request, db: Database): Promise<Response> {
+  const { handleUpdateProvider: h } = await import("../../../src/server/routes/providers/update");
+  return h(req, db, MODE);
+}
+
+async function withRouteDb(callback: (db: Database) => Promise<void>): Promise<void> {
+  const handle = createMigratedMemoryTestDatabase("route-provider-test");
+  try {
+    await callback(handle.db);
+    handle.close();
+  } finally {
+    handle.cleanup();
+  }
+}
+
+describe("供应商 API 路由", () => {
+  test("POST /api/providers 创建供应商", async () => {
+    await withRouteDb(async (db) => {
+      const req = new Request("http://localhost/api/providers", {
+        body: JSON.stringify({
+          apiKey: "sk-test",
+          baseUrl: "https://api.openai.com/v1",
+          name: "OpenAI",
+          type: "openai",
+        }),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      });
+      const res = await createProviderViaHandler(req, db);
+      expect(res.status).toBe(201);
+      const body = (await res.json()) as { provider: Provider };
+      expect(body.provider.name).toBe("OpenAI");
+      expect(body.provider.type).toBe("openai");
+    });
+  });
+
+  test("GET /api/providers 列表查询", async () => {
+    await withRouteDb(async (db) => {
+      createTestProvider(db, "A供应商");
+      createTestProvider(db, "B供应商");
+
+      const req = new Request("http://localhost/api/providers?page=1&pageSize=20");
+      const res = await listProvidersViaHandler(req, db);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { items: Provider[]; total: number };
+      expect(body.total).toBe(2);
+      expect(body.items.length).toBe(2);
+    });
+  });
+
+  test("GET /api/providers/:id 获取详情", async () => {
+    await withRouteDb(async (db) => {
+      const provider = createTestProvider(db, "详情路由");
+
+      const req = new Request(`http://localhost/api/providers/${provider.id}`);
+      const res = await getProviderViaHandler(req, db);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { provider: Provider };
+      expect(body.provider.name).toBe("详情路由");
+    });
+  });
+
+  test("PATCH /api/providers/:id 更新供应商", async () => {
+    await withRouteDb(async (db) => {
+      const provider = createTestProvider(db, "更新路由");
+
+      const req = new Request(`http://localhost/api/providers/${provider.id}`, {
+        body: JSON.stringify({ name: "已更新" }),
+        headers: { "Content-Type": "application/json" },
+        method: "PATCH",
+      });
+      const res = await updateProviderViaHandler(req, db);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { provider: Provider };
+      expect(body.provider.name).toBe("已更新");
+    });
+  });
+
+  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, "删除路由");
+
+      const req = new Request(`http://localhost/api/providers/${provider.id}`, { method: "DELETE" });
+      const res = await deleteProviderViaHandler(req, db);
+      expect(res.status).toBe(204);
+    });
+  });
+
+  test("创建同名供应商返回 409", async () => {
+    await withRouteDb(async (db) => {
+      const req1 = new Request("http://localhost/api/providers", {
+        body: JSON.stringify({
+          apiKey: "sk-a",
+          baseUrl: "https://a.com",
+          name: "重复名",
+          type: "openai",
+        }),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      });
+      await createProviderViaHandler(req1, db);
+
+      const req2 = new Request("http://localhost/api/providers", {
+        body: JSON.stringify({
+          apiKey: "sk-b",
+          baseUrl: "https://b.com",
+          name: "重复名",
+          type: "openai",
+        }),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+      });
+      const res = await createProviderViaHandler(req2, db);
+      expect(res.status).toBe(409);
+    });
+  });
+});

tests/web/components/ModelTable.test.tsx

@@ -0,0 +1,115 @@
+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 { 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,
+  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,
+  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",
+  name: "GPT-4o",
+  providerId: "pv1",
+  updatedAt: "2024-01-01T00:00:00.000Z",
+};
+
+const DISABLED_MODEL: Model = {
+  capabilities: ["text"],
+  contextLength: null,
+  createdAt: "2024-01-01T00:00:00.000Z",
+  enabled: false,
+  id: "m2",
+  maxOutputTokens: null,
+  modelId: "deepseek-chat",
+  name: "DeepSeek Chat",
+  providerId: "pv2",
+  updatedAt: "2024-01-01T00:00:00.000Z",
+};
+
+function clickLatestConfirmButton() {
+  const buttons = screen.getAllByRole("button", { name: /OK|确定/ });
+  fireEvent.click(buttons[buttons.length - 1]!);
+}
+
+describe("ModelTable", () => {
+  test("渲染模型表格数据", () => {
+    renderWithProviders(
+      createElement(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],
+      }),
+    );
+
+    expect(screen.getByText("GPT-4o")).not.toBeNull();
+    expect(screen.getByText("gpt-4o")).not.toBeNull();
+    expect(screen.getByText("DeepSeek Chat")).not.toBeNull();
+  });
+
+  test("模型表格操作触发 enable/disable/delete", async () => {
+    const onDisable = mock(() => Promise.resolve());
+    const onEnable = mock(() => Promise.resolve());
+    const onDelete = mock(() => Promise.resolve());
+
+    renderWithProviders(
+      createElement(ModelTable, {
+        data: { items: [ENABLED_MODEL, DISABLED_MODEL], page: 1, pageSize: 20, total: 2 },
+        loading: false,
+        onDelete,
+        onDisable,
+        onEdit: () => undefined,
+        onEnable,
+        onPageChange: () => undefined,
+        page: 1,
+        pageSize: 20,
+        providers: [ENABLED_PROVIDER, DISABLED_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"));
+
+    const enableButtons = screen.getAllByRole("button", { name: /启用/ });
+    fireEvent.click(enableButtons[0]!);
+    await waitFor(() => expect(onEnable).toHaveBeenCalledWith("m2"));
+  });
+});

tests/web/components/ProviderTable.test.tsx

@@ -0,0 +1,89 @@
+import { fireEvent, screen, waitFor } from "@testing-library/react";
+import { describe, expect, mock, test } from "bun:test";
+import { createElement } from "react";
+
+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 = {
+  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 = {
+  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",
+  updatedAt: "2024-01-01T00:00:00.000Z",
+};
+
+function clickLatestConfirmButton() {
+  const buttons = screen.getAllByRole("button", { name: /OK|确定/ });
+  fireEvent.click(buttons[buttons.length - 1]!);
+}
+
+describe("ProviderTable", () => {
+  test("渲染供应商表格数据", () => {
+    renderWithProviders(
+      createElement(ProviderTable, {
+        data: { items: [ENABLED_PROVIDER, DISABLED_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,
+      }),
+    );
+
+    expect(screen.getAllByText("OpenAI").length).toBeGreaterThan(0);
+    expect(screen.getByText("DeepSeek")).not.toBeNull();
+    expect(screen.getByText("https://api.openai.com/v1")).not.toBeNull();
+  });
+
+  test("供应商表格操作触发 enable/disable/delete", async () => {
+    const onDisable = mock(() => Promise.resolve());
+    const onEnable = mock(() => Promise.resolve());
+    const onDelete = mock(() => Promise.resolve());
+
+    renderWithProviders(
+      createElement(ProviderTable, {
+        data: { items: [ENABLED_PROVIDER, DISABLED_PROVIDER], page: 1, pageSize: 20, total: 2 },
+        loading: false,
+        onDelete,
+        onDisable,
+        onEdit: () => undefined,
+        onEnable,
+        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"));
+
+    const enableButtons = screen.getAllByRole("button", { name: /启用/ });
+    fireEvent.click(enableButtons[0]!);
+    await waitFor(() => expect(onEnable).toHaveBeenCalledWith("pv2"));
+  });
+});

tests/web/hooks/use-models.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  createModel,
+  deleteModel,
+  disableModel,
+  enableModel,
+  fetchModel,
+  fetchModelList,
+  updateModel,
+} from "../../../src/web/hooks/use-models";
+import { installFetchMock, jsonResponse } from "../test-utils";
+
+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",
+  name: "GPT-4o",
+  providerId: "pv1",
+  updatedAt: "2024-01-01T00:00:00.000Z",
+};
+
+async function expectRejectsWithMessage(action: () => Promise<unknown>, message: string) {
+  try {
+    await action();
+    throw new Error("expected rejection");
+  } catch (error) {
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toBe(message);
+  }
+}
+
+function jsonBody(body: BodyInit | null | undefined): unknown {
+  return JSON.parse(typeof body === "string" ? body : "{}");
+}
+
+describe("use-models request helpers", () => {
+  test("fetchModelList 按协议拼接 query 参数（含 providerId）", async () => {
+    const calls = installFetchMock(() => jsonResponse({ items: [MODEL], page: 1, pageSize: 20, total: 1 }));
+
+    const result = await fetchModelList({ keyword: "GPT", page: 1, pageSize: 20, providerId: "pv1" });
+
+    expect(result.items).toHaveLength(1);
+    expect(calls[0]?.method).toBe("GET");
+    expect(calls[0]?.url).toContain("providerId=pv1");
+    expect(calls[0]?.url).toContain("keyword=GPT");
+  });
+
+  test("模型 CRUD 与 enable/disable 使用正确 method、URL 与 body", async () => {
+    const calls = installFetchMock((call) => {
+      if (call.method === "DELETE") return new Response(null, { status: 204 });
+      return jsonResponse(
+        { model: MODEL },
+        { status: call.method === "POST" && call.url === "/api/models" ? 201 : 200 },
+      );
+    });
+
+    await createModel({
+      capabilities: ["text"],
+      modelId: "gpt-4o",
+      name: "GPT-4o",
+      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",
+    ]);
+    expect(jsonBody(calls[0]?.body)).toEqual({
+      capabilities: ["text"],
+      modelId: "gpt-4o",
+      name: "GPT-4o",
+      providerId: "pv1",
+    });
+    expect(jsonBody(calls[1]?.body)).toEqual({ name: "GPT-4o Mini" });
+  });
+
+  test("错误响应优先使用后端 error 字段", async () => {
+    installFetchMock(() => jsonResponse({ error: "模型名称已存在" }, { status: 409 }));
+
+    await expectRejectsWithMessage(
+      () => createModel({ capabilities: ["text"], modelId: "gpt-4o", name: "重复", providerId: "pv1" }),
+      "模型名称已存在",
+    );
+  });
+
+  test("非 JSON 错误响应回退到 HTTP 状态", async () => {
+    installFetchMock(() => new Response("broken", { status: 500 }));
+
+    await expectRejectsWithMessage(() => fetchModel("m-missing"), "HTTP 500");
+  });
+});

tests/web/hooks/use-providers.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  createProvider,
+  deleteProvider,
+  disableProvider,
+  enableProvider,
+  fetchProvider,
+  fetchProviderList,
+  testProviderConnection,
+  updateProvider,
+} from "../../../src/web/hooks/use-providers";
+import { installFetchMock, jsonResponse } from "../test-utils";
+
+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,
+  updatedAt: "2024-01-01T00:00:00.000Z",
+};
+
+async function expectRejectsWithMessage(action: () => Promise<unknown>, message: string) {
+  try {
+    await action();
+    throw new Error("expected rejection");
+  } catch (error) {
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toBe(message);
+  }
+}
+
+function jsonBody(body: BodyInit | null | undefined): unknown {
+  return JSON.parse(typeof body === "string" ? body : "{}");
+}
+
+describe("use-providers request helpers", () => {
+  test("fetchProviderList builds correct query params", async () => {
+    const calls = installFetchMock(() => jsonResponse({ items: [PROVIDER], page: 1, pageSize: 20, total: 1 }));
+
+    const result = await fetchProviderList({ keyword: "OpenAI", page: 1, pageSize: 20 });
+
+    expect(result.items).toHaveLength(1);
+    expect(calls[0]?.method).toBe("GET");
+    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 () => {
+    const calls = installFetchMock((call) => {
+      if (call.method === "DELETE") return new Response(null, { status: 204 });
+      return jsonResponse(
+        { provider: PROVIDER },
+        { status: call.method === "POST" && call.url === "/api/providers" ? 201 : 200 },
+      );
+    });
+
+    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",
+    ]);
+    expect(jsonBody(calls[0]?.body)).toEqual({
+      apiKey: "sk-test",
+      baseUrl: "https://api.openai.com/v1",
+      name: "OpenAI",
+      type: "openai",
+    });
+    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 } }));
+
+    const result = await testProviderConnection("pv1");
+
+    expect(result).toEqual({ message: "ok", ok: true });
+  });
+
+  test("error response uses backend error field", async () => {
+    installFetchMock(() => jsonResponse({ error: "dup" }, { status: 409 }));
+
+    await expectRejectsWithMessage(
+      () => createProvider({ apiKey: "sk", baseUrl: "https://x.com", name: "dup", type: "openai-compatible" }),
+      "dup",
+    );
+  });
+
+  test("non-JSON error falls back to HTTP status", async () => {
+    installFetchMock(() => new Response("broken", { status: 500 }));
+
+    await expectRejectsWithMessage(() => fetchProvider("missing"), "HTTP 500");
+  });
+});

tests/web/routes/models.test.tsx

@@ -0,0 +1,127 @@
+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 { ModelFormModal } from "../../../src/web/pages/models/components/ModelFormModal";
+import { ProviderFormModal } from "../../../src/web/pages/models/components/ProviderFormModal";
+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,
+  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,
+  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",
+  name: "GPT-4o",
+  providerId: "pv1",
+  updatedAt: "2024-01-01T00:00:00.000Z",
+};
+
+function clickLatestConfirmButton() {
+  const buttons = screen.getAllByRole("button", { name: /OK|确\s*定/ });
+  fireEvent.click(buttons[buttons.length - 1]!);
+}
+
+describe("ProviderFormModal", () => {
+  test("编辑供应商表单只提交变更字段", async () => {
+    const updateCalls: unknown[] = [];
+
+    renderWithProviders(
+      createElement(ProviderFormModal, {
+        editingProvider: ENABLED_PROVIDER,
+        onCancel: () => undefined,
+        onCreate: () => Promise.resolve(),
+        onOpenChange: () => undefined,
+        onUpdate: (args: unknown) => {
+          updateCalls.push(args);
+          return Promise.resolve();
+        },
+        open: true,
+        submitting: false,
+      }),
+    );
+
+    await waitFor(() => expect(screen.getByPlaceholderText("请输入供应商名称")).not.toBeNull());
+    fireEvent.change(screen.getByPlaceholderText("请输入供应商名称"), { target: { value: "New OpenAI" } });
+    clickLatestConfirmButton();
+
+    await waitFor(() => expect(updateCalls.length).toBe(1));
+    expect(updateCalls[0]).toEqual({ data: { name: "New OpenAI" }, id: "pv1" });
+  });
+});
+
+describe("ModelFormModal", () => {
+  test("编辑模型表单只提交变更字段", async () => {
+    const updateCalls: unknown[] = [];
+
+    renderWithProviders(
+      createElement(ModelFormModal, {
+        editingModel: ENABLED_MODEL,
+        onCancel: () => undefined,
+        onCreate: () => Promise.resolve(),
+        onOpenChange: () => undefined,
+        onUpdate: (args: unknown) => {
+          updateCalls.push(args);
+          return Promise.resolve();
+        },
+        open: true,
+        providers: [ENABLED_PROVIDER, DISABLED_PROVIDER],
+        submitting: false,
+      }),
+    );
+
+    await waitFor(() => expect(screen.getByPlaceholderText("请输入模型名称")).not.toBeNull());
+    fireEvent.change(screen.getByPlaceholderText("请输入模型名称"), { target: { value: "GPT-4o Mini" } });
+    clickLatestConfirmButton();
+
+    await waitFor(() => expect(updateCalls.length).toBe(1));
+    expect(updateCalls[0]).toEqual({ data: { name: "GPT-4o Mini" }, id: "m1" });
+  });
+
+  test("模型表单校验失败不会提交", async () => {
+    const onCreate = mock(() => Promise.resolve());
+
+    renderWithProviders(
+      createElement(ModelFormModal, {
+        editingModel: null,
+        onCancel: () => undefined,
+        onCreate,
+        onOpenChange: () => undefined,
+        onUpdate: () => Promise.resolve(),
+        open: true,
+        providers: [ENABLED_PROVIDER],
+        submitting: false,
+      }),
+    );
+
+    await waitFor(() => expect(screen.getByPlaceholderText("请输入模型名称")).not.toBeNull());
+    clickLatestConfirmButton();
+    expect(onCreate).not.toHaveBeenCalled();
+  });
+});