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

- 移除供应商/模型启用禁用能力，清理DB schema/migration/API/前端 - 供应商测试改为Base URL连通性+/models探测 - 新增POST /api/models/test模型连接测试 - 新增GET /api/providers/options专用供应商选项接口 - 统一工具栏为ModelsToolbar，参考项目管理布局 - 模型弹窗优化：默认能力、响应式3列标签、并排数值 - 前后端正整数校验、供应商下拉loading/error/empty状态 - 表格列宽统一，操作列/名称列固定宽度
2026-05-29 18:03:33 +08:00
parent 9241c782e6
commit 34e915ccf4
39 changed files with 895 additions and 961 deletions
--- a/tests/server/ai/registry.test.ts
+++ b/tests/server/ai/registry.test.ts
@@ -2,8 +2,6 @@ import { describe, expect, mock, test } from "bun:test";

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

-let generateTextImpl: (_opts: unknown) => unknown = () => ({});
-
 void mock.module("ai", () => ({
  createProviderRegistry: (providers: Record<string, { languageModel: (modelId: string) => unknown }>) => ({
    languageModel: (id: string) => {
@@ -13,70 +11,116 @@ void mock.module("ai", () => ({
      return provider.languageModel(modelId);
    },
  }),
-  generateText: mock((opts: unknown) => generateTextImpl(opts)),
+  generateText: () => Promise.resolve({ text: "Hi" }),
 }));

-describe("AI registry", () => {
-  test("testProviderConnection rejects invalid config", async () => {
-    generateTextImpl = () => {
-      throw new Error("Connection failed");
-    };
+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 () => {
-    generateTextImpl = () => ({});
+    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")).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");
@@ -86,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
@@ -2,7 +2,7 @@ import type Database from "bun:sqlite";

 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";
@@ -10,13 +10,10 @@ import { createMigratedMemoryTestDatabase } from "../../helpers";

 const MODE: RuntimeMode = "test";

-let generateTextImpl: (_opts: unknown) => unknown = () => ({});
-
 void mock.module("ai", () => ({
  createProviderRegistry: () => ({
    languageModel: () => ({}),
  }),
-  generateText: mock((opts: unknown) => generateTextImpl(opts)),
 }));

 async function createProviderViaHandler(req: Request, db: Database): Promise<Response> {
@@ -24,10 +21,10 @@ async function createProviderViaHandler(req: Request, db: Database): Promise<Res
  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",
  });
@@ -40,21 +37,16 @@ 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);
@@ -65,16 +57,29 @@ async function testProviderConfigViaHandler(req: Request, db: Database): Promise
  return h(req, db, MODE);
 }

-async function testProviderViaHandler(req: Request, db: Database): Promise<Response> {
-  const { handleTestProvider: 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 {
@@ -120,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, "详情路由");
@@ -148,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, "删除路由");
@@ -205,40 +198,25 @@ describe("供应商 API 路由", () => {
    });
  });

-  test("POST /api/providers/:id/test 返回连通性失败结果", async () => {
-    await withRouteDb(async (db) => {
-      generateTextImpl = () => {
-        throw new Error("bad key");
-      };
-      const provider = createTestProvider(db, "测试失败供应商");
-
-      const req = new Request(`http://localhost/api/providers/${provider.id}/test`, { method: "POST" });
-      const res = await testProviderViaHandler(req, db);
-      expect(res.status).toBe(200);
-      const body = (await res.json()) as { providerTestResponse: { message: string; ok: boolean } };
-      expect(body.providerTestResponse.ok).toBe(false);
-      expect(body.providerTestResponse.message).toContain("连接失败");
-      generateTextImpl = () => ({});
-    });
-  });
-
  test("POST /api/providers/test 使用表单配置测试连通性", async () => {
    await withRouteDb(async (db) => {
-      generateTextImpl = () => ({});
-      const req = new Request("http://localhost/api/providers/test", {
-        body: JSON.stringify({
-          apiKey: "sk-test",
-          baseUrl: "https://api.openai.com/v1",
-          name: "OpenAI",
-          type: "openai",
-        }),
-        headers: { "Content-Type": "application/json" },
-        method: "POST",
+      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 个模型");
      });
-      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).toEqual({ message: "连接成功", ok: true });
    });
  });

--- 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,51 +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,58 +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());
+    fireEvent.click(screen.getAllByRole("button", { name: /编辑/ })[0]!);
+    expect(onEdit).toHaveBeenCalledWith(OPENAI_PROVIDER);
+
+    fireEvent.click(screen.getAllByRole("button", { name: /删除/ })[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"));
-  });
-
-  test("供应商表格操作触发连接测试", async () => {
-    const onTest = mock(() => Promise.resolve({ message: "连接失败", ok: false }));
-
-    renderWithProviders(
-      createElement(ProviderTable, {
-        data: { items: [ENABLED_PROVIDER], page: 1, pageSize: 20, total: 1 },
-        loading: false,
-        onDelete: () => Promise.resolve(),
-        onDisable: () => Promise.resolve(),
-        onEdit: () => undefined,
-        onEnable: () => Promise.resolve(),
-        onPageChange: () => undefined,
-        onTest,
-        page: 1,
-        pageSize: 20,
-      }),
-    );
-
-    fireEvent.click(screen.getByRole("button", { name: "测试连接" }));
-    await waitFor(() => expect(onTest).toHaveBeenCalledWith("pv1"));
+    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,12 +3,10 @@ import { describe, expect, test } from "bun:test";
 import {
  createProvider,
  deleteProvider,
-  disableProvider,
-  enableProvider,
  fetchProvider,
  fetchProviderList,
+  fetchProviderOptions,
  testProviderConfig,
-  testProviderConnection,
  updateProvider,
 } from "../../../src/web/hooks/use-providers";
 import { installFetchMock, jsonResponse } from "../test-utils";
@@ -17,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,
@@ -49,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(
@@ -60,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",
    ]);
@@ -82,12 +75,14 @@ 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).toEqual({ message: "ok", ok: true });
+    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 () => {
--- 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",
@@ -165,8 +162,9 @@ describe("ModelFormModal", () => {
        },
        open: true,
        providers: [ENABLED_PROVIDER, DISABLED_PROVIDER],
+        providersError: null,
+        providersLoading: false,
        submitting: false,
-        testConnection: () => Promise.resolve({ message: "连接成功", ok: true }),
      }),
    );

@@ -190,8 +188,9 @@ describe("ModelFormModal", () => {
        onUpdate: () => Promise.resolve(),
        open: true,
        providers: [ENABLED_PROVIDER],
+        providersError: null,
+        providersLoading: false,
        submitting: false,
-        testConnection: () => Promise.resolve({ message: "连接成功", ok: true }),
      }),
    );

@@ -200,9 +199,7 @@ describe("ModelFormModal", () => {
    expect(onCreate).not.toHaveBeenCalled();
  });

-  test("新建模型时可测试所选供应商连接", async () => {
-    const testConnection = mock(() => Promise.resolve({ message: "连接成功", ok: true }));
-
+  test("新建模型默认选中文本和推理能力", async () => {
    renderWithProviders(
      createElement(ModelFormModal, {
        editingModel: null,
@@ -212,16 +209,111 @@ describe("ModelFormModal", () => {
        onUpdate: () => Promise.resolve(),
        open: true,
        providers: [ENABLED_PROVIDER],
+        providersError: null,
+        providersLoading: false,
        submitting: false,
-        testConnection,
      }),
    );

-    await waitFor(() => expect(screen.getByText("测试连接")).not.toBeNull());
+    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"));
-    fireEvent.click(await screen.findByText("OpenAI"));
+
+    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(testConnection).toHaveBeenCalledWith("pv1"));
+    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",