feat: 全栈 Logger 依赖注入 — DB/Route/AI 层传参 + 前端 Logger + 测试更新 + 归档 add-frontend-logger

2026-06-01 20:32:19 +08:00
parent 4c72754739
commit 844562303c
60 changed files with 1648 additions and 778 deletions
--- a/tests/server/ai/registry.test.ts
+++ b/tests/server/ai/registry.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, mock, test } from "bun:test";

+import { createNoopLogger } from "../../../src/server/logger";
 import { createMigratedTestDatabase } from "../../helpers";

 void mock.module("ai", () => ({
@@ -36,12 +37,15 @@ 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: "http://127.0.0.1:1",
-      name: "Bad",
-      type: "openai-compatible",
-    });
+    const result = await testProviderConnection(
+      {
+        apiKey: "bad-key",
+        baseUrl: "http://127.0.0.1:1",
+        name: "Bad",
+        type: "openai-compatible",
+      },
+      createNoopLogger(),
+    );

    expect(result.ok).toBe(false);
    expect(result.message).toContain("Base URL 不可达");
@@ -51,12 +55,15 @@ describe("AI registry", () => {
    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",
-      });
+      const result = await testProviderConnection(
+        {
+          apiKey: "bad-key",
+          baseUrl,
+          name: "Bad",
+          type: "openai-compatible",
+        },
+        createNoopLogger(),
+      );

      expect(result.ok).toBe(false);
      expect(result.message).toContain("API Key 无效");
@@ -68,12 +75,15 @@ describe("AI registry", () => {
    await withProviderServer(Response.json({ data: [{ id: "gpt-4o" }] }), async (baseUrl) => {
      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,
+          name: "Test",
+          type: "openai",
+        },
+        createNoopLogger(),
+      );

      expect(result.ok).toBe(true);
      expect(result.message).toContain("/models 返回 1 个模型");
@@ -84,12 +94,15 @@ describe("AI registry", () => {
    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",
-      });
+      const result = await testProviderConnection(
+        {
+          apiKey: "sk-test",
+          baseUrl,
+          name: "Test",
+          type: "openai",
+        },
+        createNoopLogger(),
+      );

      expect(result.ok).toBe(true);
      expect(result.message).toContain("可能不支持 /models");
@@ -134,13 +147,16 @@ describe("AI registry", () => {
  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",
-    });
+    const result = await testModelConnection(
+      {
+        apiKey: "sk-test",
+        baseUrl: "https://api.openai.com/v1",
+        modelId: "gpt-4o",
+        name: "Test",
+        type: "openai",
+      },
+      createNoopLogger(),
+    );

    expect(result.ok).toBe(true);
    expect(result.message).toContain("模型连接成功");
--- a/tests/server/db/models.test.ts
+++ b/tests/server/db/models.test.ts
@@ -11,10 +11,15 @@ import {
  updateModel,
 } from "../../../src/server/db/models";
 import { createProvider } from "../../../src/server/db/providers";
+import { createNoopLogger } from "../../../src/server/logger";
 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" });
+  const result = createProvider(
+    db,
+    { apiKey: "sk-test", baseUrl: "https://api.test.com/v1", name, type: "openai" },
+    createNoopLogger(),
+  );
  return (result as { provider: { id: string } }).provider.id;
 }

@@ -32,12 +37,16 @@ describe("模型数据访问层", () => {
  test("创建模型", () => {
    withDb((db) => {
      const providerId = seedProvider(db);
-      const result = createModel(db, {
-        capabilities: ["text", "reasoning"],
-        modelId: "gpt-4o",
-        name: "GPT-4o",
-        providerId,
-      });
+      const result = createModel(
+        db,
+        {
+          capabilities: ["text", "reasoning"],
+          modelId: "gpt-4o",
+          name: "GPT-4o",
+          providerId,
+        },
+        createNoopLogger(),
+      );
      expect("error" in result).toBe(false);
      const model = (result as { model: { capabilities: string[]; modelId: string; name: string; providerId: string } })
        .model;
@@ -50,12 +59,16 @@ describe("模型数据访问层", () => {

  test("供应商不存在时创建失败", () => {
    withDb((db) => {
-      const result = createModel(db, {
-        capabilities: ["text"],
-        modelId: "test",
-        name: "Test",
-        providerId: "nonexistent",
-      });
+      const result = createModel(
+        db,
+        {
+          capabilities: ["text"],
+          modelId: "test",
+          name: "Test",
+          providerId: "nonexistent",
+        },
+        createNoopLogger(),
+      );
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(400);
    });
@@ -64,8 +77,12 @@ describe("模型数据访问层", () => {
  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 });
+      createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "Model1", providerId }, createNoopLogger());
+      const result = createModel(
+        db,
+        { capabilities: ["text"], modelId: "gpt-4o", name: "Model2", providerId },
+        createNoopLogger(),
+      );
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("已存在");
    });
@@ -75,8 +92,16 @@ describe("模型数据访问层", () => {
    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 });
+      const r1 = createModel(
+        db,
+        { capabilities: ["text"], modelId: "same-id", name: "M1", providerId: p1 },
+        createNoopLogger(),
+      );
+      const r2 = createModel(
+        db,
+        { capabilities: ["text"], modelId: "same-id", name: "M2", providerId: p2 },
+        createNoopLogger(),
+      );
      expect("error" in r1).toBe(false);
      expect("error" in r2).toBe(false);
    });
@@ -85,7 +110,11 @@ describe("模型数据访问层", () => {
  test("能力标签为空时创建失败", () => {
    withDb((db) => {
      const providerId = seedProvider(db);
-      const result = createModel(db, { capabilities: [], modelId: "test", name: "Test", providerId });
+      const result = createModel(
+        db,
+        { capabilities: [], modelId: "test", name: "Test", providerId },
+        createNoopLogger(),
+      );
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("能力标签");
    });
@@ -95,9 +124,9 @@ describe("模型数据访问层", () => {
    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 });
+      createModel(db, { capabilities: ["text"], modelId: "m1", name: "Alpha", providerId: p1 }, createNoopLogger());
+      createModel(db, { capabilities: ["text"], modelId: "m2", name: "Beta", providerId: p1 }, createNoopLogger());
+      createModel(db, { capabilities: ["text"], modelId: "m3", name: "Gamma", providerId: p2 }, createNoopLogger());

      const all = listModels(db, { page: 1, pageSize: 20 });
      expect(all.total).toBe(3);
@@ -113,7 +142,11 @@ describe("模型数据访问层", () => {
  test("获取模型详情", () => {
    withDb((db) => {
      const providerId = seedProvider(db);
-      const created = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "GPT-4o", providerId });
+      const created = createModel(
+        db,
+        { capabilities: ["text"], modelId: "gpt-4o", name: "GPT-4o", providerId },
+        createNoopLogger(),
+      );
      const id = (created as { model: { id: string } }).model.id;

      const result = getModel(db, id);
@@ -133,10 +166,14 @@ describe("模型数据访问层", () => {
  test("更新模型", () => {
    withDb((db) => {
      const providerId = seedProvider(db);
-      const created = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "原名", providerId });
+      const created = createModel(
+        db,
+        { capabilities: ["text"], modelId: "gpt-4o", name: "原名", providerId },
+        createNoopLogger(),
+      );
      const id = (created as { model: { id: string } }).model.id;

-      const result = updateModel(db, id, { capabilities: ["text", "reasoning"], name: "新名" });
+      const result = updateModel(db, id, { capabilities: ["text", "reasoning"], name: "新名" }, createNoopLogger());
      expect("error" in result).toBe(false);
      const updated = (result as { model: { capabilities: string[]; name: string } }).model;
      expect(updated.name).toBe("新名");
@@ -147,10 +184,14 @@ describe("模型数据访问层", () => {
  test("删除模型", () => {
    withDb((db) => {
      const providerId = seedProvider(db);
-      const created = createModel(db, { capabilities: ["text"], modelId: "gpt-4o", name: "删除测试", providerId });
+      const created = createModel(
+        db,
+        { capabilities: ["text"], modelId: "gpt-4o", name: "删除测试", providerId },
+        createNoopLogger(),
+      );
      const id = (created as { model: { id: string } }).model.id;

-      const result = deleteModel(db, id);
+      const result = deleteModel(db, id, createNoopLogger());
      expect("error" in result).toBe(false);

      const after = getModel(db, id);
@@ -162,9 +203,9 @@ describe("模型数据访问层", () => {
    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 });
+      createModel(db, { capabilities: ["text"], modelId: "m1", name: "M1", providerId: p1 }, createNoopLogger());
+      createModel(db, { capabilities: ["text"], modelId: "m2", name: "M2", providerId: p1 }, createNoopLogger());
+      createModel(db, { capabilities: ["text"], modelId: "m3", name: "M3", providerId: p2 }, createNoopLogger());

      expect(getModelsByProviderId(db, p1)).toBe(2);
      expect(getModelsByProviderId(db, p2)).toBe(1);
@@ -174,14 +215,18 @@ describe("模型数据访问层", () => {
  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,
-      });
+      const result = createModel(
+        db,
+        {
+          capabilities: ["text"],
+          contextLength: 128000,
+          maxOutputTokens: 4096,
+          modelId: "gpt-4o",
+          name: "GPT-4o",
+          providerId,
+        },
+        createNoopLogger(),
+      );
      expect("error" in result).toBe(false);
      const model = (result as { model: { contextLength: null | number; maxOutputTokens: null | number } }).model;
      expect(model.contextLength).toBe(128000);
--- a/tests/server/db/projects.test.ts
+++ b/tests/server/db/projects.test.ts
@@ -11,6 +11,7 @@ import {
  restoreProject,
  updateProject,
 } from "../../../src/server/db/projects";
+import { createNoopLogger } from "../../../src/server/logger";
 import { createMigratedTestDatabase } from "../../helpers";

 function withProjectsDb(callback: (db: Database) => void): void {
@@ -26,7 +27,7 @@ function withProjectsDb(callback: (db: Database) => void): void {
 describe("项目数据访问层", () => {
  test("创建项目", () => {
    withProjectsDb((db) => {
-      const result = createProject(db, { description: "测试描述", name: "测试项目" });
+      const result = createProject(db, { description: "测试描述", name: "测试项目" }, createNoopLogger());
      expect("error" in result).toBe(false);
      expect((result as { project: unknown }).project).toBeDefined();

@@ -43,8 +44,8 @@ describe("项目数据访问层", () => {

  test("项目名称全局唯一（含归档项目）", () => {
    withProjectsDb((db) => {
-      createProject(db, { name: "唯一名称" });
-      const result2 = createProject(db, { name: "唯一名称" });
+      createProject(db, { name: "唯一名称" }, createNoopLogger());
+      const result2 = createProject(db, { name: "唯一名称" }, createNoopLogger());
      expect("error" in result2).toBe(true);
      expect((result2 as unknown as { error: string }).error).toContain("已存在");
    });
@@ -52,7 +53,7 @@ describe("项目数据访问层", () => {

  test("trim 后名称为空时创建失败", () => {
    withProjectsDb((db) => {
-      const result = createProject(db, { name: "   " });
+      const result = createProject(db, { name: "   " }, createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("不能为空");
    });
@@ -60,9 +61,9 @@ describe("项目数据访问层", () => {

  test("列表查询（分页和关键字）", () => {
    withProjectsDb((db) => {
-      createProject(db, { description: "descA", name: "项目A" });
-      createProject(db, { description: "descB", name: "项目B" });
-      createProject(db, { name: "其他" });
+      createProject(db, { description: "descA", name: "项目A" }, createNoopLogger());
+      createProject(db, { description: "descB", name: "项目B" }, createNoopLogger());
+      createProject(db, { name: "其他" }, createNoopLogger());

      const result1 = listProjects(db, { page: 1, pageSize: 20 });
      expect(result1.total).toBe(3);
@@ -79,7 +80,7 @@ describe("项目数据访问层", () => {

  test("获取项目详情", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { description: "详情", name: "详情项目" });
+      const created = createProject(db, { description: "详情", name: "详情项目" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;

      const result = getProject(db, id);
@@ -99,10 +100,10 @@ describe("项目数据访问层", () => {

  test("更新项目名称和描述", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { name: "原名" });
+      const created = createProject(db, { name: "原名" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;

-      const result = updateProject(db, id, { description: "新描述", name: "新名" });
+      const result = updateProject(db, id, { description: "新描述", name: "新名" }, createNoopLogger());
      expect("error" in result).toBe(false);

      const updated = result as { project: { description: string; name: string } };
@@ -113,11 +114,11 @@ describe("项目数据访问层", () => {

  test("更新已归档项目失败", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { name: "待归档" });
+      const created = createProject(db, { name: "待归档" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;
-      archiveProject(db, id);
+      archiveProject(db, id, createNoopLogger());

-      const result = updateProject(db, id, { name: "新名称" });
+      const result = updateProject(db, id, { name: "新名称" }, createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(409);
    });
@@ -125,10 +126,10 @@ describe("项目数据访问层", () => {

  test("归档项目", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { name: "待归档" });
+      const created = createProject(db, { name: "待归档" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;

-      const result = archiveProject(db, id);
+      const result = archiveProject(db, id, createNoopLogger());
      expect("error" in result).toBe(false);

      const archived = (result as { project: { archivedAt: null | string; status: string } }).project;
@@ -146,10 +147,10 @@ describe("项目数据访问层", () => {

  test("对已归档项目重复归档失败", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { name: "测试" });
+      const created = createProject(db, { name: "测试" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;
-      archiveProject(db, id);
-      const result = archiveProject(db, id);
+      archiveProject(db, id, createNoopLogger());
+      const result = archiveProject(db, id, createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(409);
    });
@@ -157,11 +158,11 @@ describe("项目数据访问层", () => {

  test("恢复已归档项目", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { name: "恢复测试" });
+      const created = createProject(db, { name: "恢复测试" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;
-      archiveProject(db, id);
+      archiveProject(db, id, createNoopLogger());

-      const result = restoreProject(db, id);
+      const result = restoreProject(db, id, createNoopLogger());
      expect("error" in result).toBe(false);

      const restored = (result as { project: { archivedAt: null | string; status: string } }).project;
@@ -172,9 +173,9 @@ describe("项目数据访问层", () => {

  test("恢复 active 项目失败", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { name: "活跃项目" });
+      const created = createProject(db, { name: "活跃项目" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;
-      const result = restoreProject(db, id);
+      const result = restoreProject(db, id, createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(409);
    });
@@ -182,11 +183,11 @@ describe("项目数据访问层", () => {

  test("永久删除已归档项目", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { name: "删除测试" });
+      const created = createProject(db, { name: "删除测试" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;
-      archiveProject(db, id);
+      archiveProject(db, id, createNoopLogger());

-      const result = deleteProject(db, id);
+      const result = deleteProject(db, id, createNoopLogger());
      expect("error" in result).toBe(false);

      const after = getProject(db, id);
@@ -196,10 +197,10 @@ describe("项目数据访问层", () => {

  test("删除 active 项目失败", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { name: "活跃项目" });
+      const created = createProject(db, { name: "活跃项目" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;

-      const result = deleteProject(db, id);
+      const result = deleteProject(db, id, createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(409);
    });
@@ -207,7 +208,7 @@ describe("项目数据访问层", () => {

  test("创建项目名称超过 10 个字符失败", () => {
    withProjectsDb((db) => {
-      const result = createProject(db, { name: "这是一个非常非常长的名字" });
+      const result = createProject(db, { name: "这是一个非常非常长的名字" }, createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("不能超过 10 个字符");
    });
@@ -215,7 +216,7 @@ describe("项目数据访问层", () => {

  test("创建项目名称刚好 10 个字符成功", () => {
    withProjectsDb((db) => {
-      const result = createProject(db, { name: "一二三四五六七八九十" });
+      const result = createProject(db, { name: "一二三四五六七八九十" }, createNoopLogger());
      expect("error" in result).toBe(false);
      const project = (result as { project: { name: string } }).project;
      expect(project.name).toBe("一二三四五六七八九十");
@@ -224,10 +225,10 @@ describe("项目数据访问层", () => {

  test("更新项目名称超过 10 个字符失败", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { name: "短名" });
+      const created = createProject(db, { name: "短名" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;

-      const result = updateProject(db, id, { name: "这是一个非常非常长的名字" });
+      const result = updateProject(db, id, { name: "这是一个非常非常长的名字" }, createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("不能超过 10 个字符");
    });
@@ -235,10 +236,10 @@ describe("项目数据访问层", () => {

  test("更新项目名称 trim 后为空失败", () => {
    withProjectsDb((db) => {
-      const created = createProject(db, { name: "原名" });
+      const created = createProject(db, { name: "原名" }, createNoopLogger());
      const id = (created as { project: { id: string } }).project.id;

-      const result = updateProject(db, id, { name: "   " });
+      const result = updateProject(db, id, { name: "   " }, createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("不能为空");
    });
--- a/tests/server/db/providers.test.ts
+++ b/tests/server/db/providers.test.ts
@@ -10,6 +10,7 @@ import {
  listProviders,
  updateProvider,
 } from "../../../src/server/db/providers";
+import { createNoopLogger } from "../../../src/server/logger";
 import { createMigratedTestDatabase } from "../../helpers";

 function withDb(callback: (db: Database) => void): void {
@@ -35,12 +36,16 @@ describe("供应商数据访问层", () => {

  test("创建供应商", () => {
    withDb((db) => {
-      const result = createProvider(db, {
-        apiKey: "sk-test",
-        baseUrl: "https://api.openai.com/v1",
-        name: "OpenAI",
-        type: "openai",
-      });
+      const result = createProvider(
+        db,
+        {
+          apiKey: "sk-test",
+          baseUrl: "https://api.openai.com/v1",
+          name: "OpenAI",
+          type: "openai",
+        },
+        createNoopLogger(),
+      );
      expect("error" in result).toBe(false);
      const provider = (result as { provider: { apiKey: string; baseUrl: string; name: string; type: string } })
        .provider;
@@ -53,8 +58,16 @@ describe("供应商数据访问层", () => {

  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" });
+      createProvider(
+        db,
+        { apiKey: "sk-1", baseUrl: "https://a.com", name: "唯一", type: "openai" },
+        createNoopLogger(),
+      );
+      const result = createProvider(
+        db,
+        { apiKey: "sk-2", baseUrl: "https://b.com", name: "唯一", type: "openai" },
+        createNoopLogger(),
+      );
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("已存在");
    });
@@ -62,7 +75,11 @@ describe("供应商数据访问层", () => {

  test("名称为空时创建失败", () => {
    withDb((db) => {
-      const result = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "   ", type: "openai" });
+      const result = createProvider(
+        db,
+        { apiKey: "sk", baseUrl: "https://a.com", name: "   ", type: "openai" },
+        createNoopLogger(),
+      );
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("不能为空");
    });
@@ -70,9 +87,21 @@ describe("供应商数据访问层", () => {

  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" });
+      createProvider(
+        db,
+        { apiKey: "sk-1", baseUrl: "https://a.com", name: "Alpha", type: "openai" },
+        createNoopLogger(),
+      );
+      createProvider(
+        db,
+        { apiKey: "sk-2", baseUrl: "https://b.com", name: "Beta", type: "anthropic" },
+        createNoopLogger(),
+      );
+      createProvider(
+        db,
+        { apiKey: "sk-3", baseUrl: "https://c.com", name: "Gamma", type: "openai-compatible" },
+        createNoopLogger(),
+      );

      const result1 = listProviders(db, { page: 1, pageSize: 20 });
      expect(result1.total).toBe(3);
@@ -88,7 +117,11 @@ describe("供应商数据访问层", () => {

  test("获取供应商详情", () => {
    withDb((db) => {
-      const created = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "详情", type: "openai" });
+      const created = createProvider(
+        db,
+        { apiKey: "sk", baseUrl: "https://a.com", name: "详情", type: "openai" },
+        createNoopLogger(),
+      );
      const id = (created as { provider: { id: string } }).provider.id;

      const result = getProvider(db, id);
@@ -107,10 +140,14 @@ describe("供应商数据访问层", () => {

  test("更新供应商", () => {
    withDb((db) => {
-      const created = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "原名", type: "openai" });
+      const created = createProvider(
+        db,
+        { apiKey: "sk", baseUrl: "https://a.com", name: "原名", type: "openai" },
+        createNoopLogger(),
+      );
      const id = (created as { provider: { id: string } }).provider.id;

-      const result = updateProvider(db, id, { name: "新名" });
+      const result = updateProvider(db, id, { name: "新名" }, createNoopLogger());
      expect("error" in result).toBe(false);
      expect((result as { provider: { name: string } }).provider.name).toBe("新名");
    });
@@ -118,11 +155,19 @@ describe("供应商数据访问层", () => {

  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" });
+      createProvider(
+        db,
+        { apiKey: "sk-1", baseUrl: "https://a.com", name: "已存在", type: "openai" },
+        createNoopLogger(),
+      );
+      const created = createProvider(
+        db,
+        { apiKey: "sk-2", baseUrl: "https://b.com", name: "原名", type: "openai" },
+        createNoopLogger(),
+      );
      const id = (created as { provider: { id: string } }).provider.id;

-      const result = updateProvider(db, id, { name: "已存在" });
+      const result = updateProvider(db, id, { name: "已存在" }, createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("已存在");
    });
@@ -130,10 +175,14 @@ describe("供应商数据访问层", () => {

  test("删除供应商", () => {
    withDb((db) => {
-      const created = createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "删除测试", type: "openai" });
+      const created = createProvider(
+        db,
+        { apiKey: "sk", baseUrl: "https://a.com", name: "删除测试", type: "openai" },
+        createNoopLogger(),
+      );
      const id = (created as { provider: { id: string } }).provider.id;

-      const result = deleteProvider(db, id);
+      const result = deleteProvider(db, id, createNoopLogger());
      expect("error" in result).toBe(false);

      const after = getProvider(db, id);
@@ -143,7 +192,7 @@ describe("供应商数据访问层", () => {

  test("删除不存在的供应商返回 404", () => {
    withDb((db) => {
-      const result = deleteProvider(db, "nonexistent");
+      const result = deleteProvider(db, "nonexistent", createNoopLogger());
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(404);
    });
@@ -151,20 +200,28 @@ describe("供应商数据访问层", () => {

  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",
-      });
+      createProvider(
+        db,
+        { apiKey: "sk", baseUrl: "https://a.com", name: "默认类型", type: "openai-compatible" },
+        createNoopLogger(),
+      );
+      const result = createProvider(
+        db,
+        {
+          apiKey: "sk2",
+          baseUrl: "https://b.com",
+          name: "显式默认",
+          type: "openai-compatible",
+        },
+        createNoopLogger(),
+      );
      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" });
+      createProvider(db, { apiKey: "sk", baseUrl: "https://a.com", name: "选项", type: "openai" }, createNoopLogger());

      const options = listProviderOptions(db);
      expect(options.length).toBe(1);
--- a/tests/server/routes/chat.test.ts
+++ b/tests/server/routes/chat.test.ts
@@ -11,6 +11,7 @@ import { createNoopLogger } from "../../../src/server/logger";
 import { createMigratedMemoryTestDatabase } from "../../helpers";

 const MODE: RuntimeMode = "test";
+const LOG = createNoopLogger();

 void mock.module("ai", () => ({
  createAgentUIStreamResponse: (opts: {
@@ -49,65 +50,73 @@ void mock.module("ai", () => ({

 async function createConversationViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleCreateConversation: h } = await import("../../../src/server/routes/chat/create");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function deleteConversationViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleDeleteConversation: h } = await import("../../../src/server/routes/chat/delete");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function getConversationViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleGetConversation: h } = await import("../../../src/server/routes/chat/get");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function listConversationsViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleListConversations: h } = await import("../../../src/server/routes/chat/list");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function listMessagesViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleListMessages: h } = await import("../../../src/server/routes/chat/messages");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function patchConversationViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleUpdateConversation: h } = await import("../../../src/server/routes/chat/update");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 function seedModel(db: Database, providerId: string, modelName = "GPT-4o", modelId = "gpt-4o"): string {
-  const result = createModel(db, {
-    capabilities: ["text"],
-    modelId,
-    name: modelName,
-    providerId,
-  });
+  const result = createModel(
+    db,
+    {
+      capabilities: ["text"],
+      modelId,
+      name: modelName,
+      providerId,
+    },
+    LOG,
+  );
  if ("error" in result) throw new Error(result.error);
  return result.model.id;
 }

 function seedProject(db: Database, name = "测试项目"): string {
-  const result = createProject(db, { description: "测试", name });
+  const result = createProject(db, { description: "测试", name }, LOG);
  if ("error" in result) throw new Error(result.error);
  return result.project.id;
 }

 function seedProvider(db: Database, name = "测试供应商"): string {
-  const result = createProvider(db, {
-    apiKey: "sk-test",
-    baseUrl: "https://api.test.com/v1",
-    name,
-    type: "openai",
-  });
+  const result = createProvider(
+    db,
+    {
+      apiKey: "sk-test",
+      baseUrl: "https://api.test.com/v1",
+      name,
+      type: "openai",
+    },
+    LOG,
+  );
  if ("error" in result) throw new Error(result.error);
  return result.provider.id;
 }

 async function sendChatViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleSendChat: h } = await import("../../../src/server/routes/chat/send");
-  return h(req, db, MODE, createNoopLogger());
+  return h(req, db, MODE, LOG);
 }

 describe("聊天 API 路由", () => {
--- a/tests/server/routes/models.test.ts
+++ b/tests/server/routes/models.test.ts
@@ -4,40 +4,46 @@ import { describe, expect, mock, test } from "bun:test";

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

+import { createNoopLogger } from "../../../src/server/logger";
 import { createMigratedMemoryTestDatabase } from "../../helpers";

 const MODE: RuntimeMode = "test";
+const LOG = createNoopLogger();

 async function createModelViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleCreateModel: h } = await import("../../../src/server/routes/models/create");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 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,
-  });
+  const result = createModel(
+    db,
+    {
+      capabilities: ["text"],
+      modelId: pName.toLowerCase().replace(/[^a-z0-9-]/g, "-"),
+      name: pName,
+      providerId: pid,
+    },
+    LOG,
+  );
  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);
+  return h(req, db, MODE, LOG);
 }

 async function getModelViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleGetModel: h } = await import("../../../src/server/routes/models/get");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function listModelsViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleListModels: h } = await import("../../../src/server/routes/models/list");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 import { createModel } from "../../../src/server/db/models";
@@ -51,24 +57,28 @@ void mock.module("ai", () => ({
 }));

 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",
-  });
+  const result = createProvider(
+    db,
+    {
+      apiKey: "sk-test",
+      baseUrl: "https://api.test.com/v1",
+      name: name ?? "TestProvider",
+      type: "openai",
+    },
+    LOG,
+  );
  if ("error" in result) throw new Error(result.error);
  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);
+  return h(req, db, MODE, LOG);
 }

 async function updateModelViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleUpdateModel: h } = await import("../../../src/server/routes/models/update");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function withRouteDb(callback: (db: Database) => Promise<void>): Promise<void> {
--- a/tests/server/routes/projects.test.ts
+++ b/tests/server/routes/projects.test.ts
@@ -4,50 +4,52 @@ import { describe, expect, test } from "bun:test";

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

+import { createNoopLogger } from "../../../src/server/logger";
 import { createMigratedMemoryTestDatabase } from "../../helpers";

 const MODE: RuntimeMode = "test";
+const LOG = createNoopLogger();

 async function archiveProjectViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleArchiveProject: h } = await import("../../../src/server/routes/projects/archive");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 // Inline imports for actual route handler tests (each handler is in separate file)
 async function createProjectViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleCreateProject: h } = await import("../../../src/server/routes/projects/create");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 function createTestProject(db: Database, name = "测试项目"): Project {
-  const result = createProject(db, { name });
+  const result = createProject(db, { name }, LOG);
  if ("error" in result) throw new Error(result.error);
  return result.project;
 }

 async function deleteProjectViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleDeleteProject: h } = await import("../../../src/server/routes/projects/delete");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function getProjectViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleGetProject: h } = await import("../../../src/server/routes/projects/get");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function listProjectsViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleListProjects: h } = await import("../../../src/server/routes/projects/list");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function restoreProjectViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleRestoreProject: h } = await import("../../../src/server/routes/projects/restore");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 async function updateProjectViaHandler(req: Request, db: Database): Promise<Response> {
  const { handleUpdateProject: h } = await import("../../../src/server/routes/projects/update");
-  return h(req, db, MODE);
+  return h(req, db, MODE, LOG);
 }

 // Need db/projects for setup
@@ -135,7 +137,7 @@ describe("项目 API 路由", () => {
  test("POST /api/projects/:id/restore 恢复项目", async () => {
    await withRouteDb(async (db) => {
      const project = createTestProject(db, "恢复路由");
-      archiveProject(db, project.id);
+      archiveProject(db, project.id, LOG);

      const req = new Request(`http://localhost/api/projects/${project.id}/restore`, { method: "POST" });
      const res = await restoreProjectViaHandler(req, db);
@@ -148,7 +150,7 @@ describe("项目 API 路由", () => {
  test("DELETE /api/projects/:id 永久删除已归档项目", async () => {
    await withRouteDb(async (db) => {
      const project = createTestProject(db, "删除路由");
-      archiveProject(db, project.id);
+      archiveProject(db, project.id, LOG);

      const req = new Request(`http://localhost/api/projects/${project.id}`, { method: "DELETE" });
      const res = await deleteProjectViaHandler(req, db);
--- a/tests/server/routes/providers.test.ts
+++ b/tests/server/routes/providers.test.ts
@@ -6,9 +6,11 @@ import type { Provider, ProviderOption, RuntimeMode } from "../../../src/shared/

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

 const MODE: RuntimeMode = "test";
+const LOG = createNoopLogger();

 void mock.module("ai", () => ({
  createProviderRegistry: () => ({
@@ -18,48 +20,52 @@ void mock.module("ai", () => ({

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

 function createTestProvider(db: Database, name = "测试供应商", baseUrl = "https://api.test.com/v1"): Provider {
-  const result = createProvider(db, {
-    apiKey: "sk-test",
-    baseUrl,
-    name,
-    type: "openai",
-  });
+  const result = createProvider(
+    db,
+    {
+      apiKey: "sk-test",
+      baseUrl,
+      name,
+      type: "openai",
+    },
+    LOG,
+  );
  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);
+  return h(req, db, MODE, LOG);
 }

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

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

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

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

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

 async function withProviderServer(
@@ -182,12 +188,16 @@ describe("供应商 API 路由", () => {
  test("DELETE /api/providers/:id 存在关联模型时返回 409", async () => {
    await withRouteDb(async (db) => {
      const provider = createTestProvider(db, "有关联模型");
-      const modelResult = createModel(db, {
-        capabilities: ["text"],
-        modelId: "gpt-4o",
-        name: "GPT-4o",
-        providerId: provider.id,
-      });
+      const modelResult = createModel(
+        db,
+        {
+          capabilities: ["text"],
+          modelId: "gpt-4o",
+          name: "GPT-4o",
+          providerId: provider.id,
+        },
+        LOG,
+      );
      if ("error" in modelResult) throw new Error(modelResult.error);

      const req = new Request(`http://localhost/api/providers/${provider.id}`, { method: "DELETE" });
--- a/tests/web/components/query-client-logging.test.tsx
+++ b/tests/web/components/query-client-logging.test.tsx
@@ -0,0 +1,103 @@
+import { MutationCache, QueryCache, QueryClient, QueryClientProvider, useQuery } from "@tanstack/react-query";
+import { render } from "@testing-library/react";
+import { describe, expect, test } from "bun:test";
+import { createElement, useRef } from "react";
+
+import { useCreateProject } from "../../../src/web/hooks/use-projects";
+import { installFetchMock, jsonResponse } from "../test-utils";
+
+describe("QueryClient MutationCache onError", () => {
+  test("mutation 错误触发 MutationCache onError 回调", async () => {
+    installFetchMock(() => jsonResponse({ error: "项目名称已存在" }, { status: 409 }));
+
+    const errors: string[] = [];
+    const queryClient = new QueryClient({
+      defaultOptions: { queries: { retry: false } },
+      mutationCache: new MutationCache({
+        onError: (error: Error) => {
+          errors.push(error.message);
+        },
+      }),
+    });
+
+    function TestComponent({ onResult }: { onResult: (mutate: () => void) => void }) {
+      const { mutate } = useCreateProject();
+      const called = useRef(false);
+
+      if (!called.current) {
+        called.current = true;
+        onResult(() => {
+          mutate(
+            { name: "test" },
+            {
+              // eslint-disable-next-line @typescript-eslint/no-empty-function
+              onError: () => {},
+            },
+          );
+        });
+      }
+
+      return null;
+    }
+
+    render(
+      createElement(
+        QueryClientProvider,
+        { client: queryClient },
+        createElement(TestComponent, { onResult: (fn) => fn() }),
+      ),
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toBe("项目名称已存在");
+  });
+});
+
+describe("QueryClient QueryCache onError", () => {
+  test("query 错误触发 QueryCache onError 回调", async () => {
+    installFetchMock(() => new Response("broken", { status: 500 }));
+
+    const errors: string[] = [];
+    const queryClient = new QueryClient({
+      defaultOptions: { queries: { retry: false } },
+      queryCache: new QueryCache({
+        onError: (error: Error) => {
+          errors.push(error.message);
+        },
+      }),
+    });
+
+    function TestComponent({ onResult }: { onResult: (trigger: () => void) => void }) {
+      const called = useRef(false);
+
+      useQuery({
+        queryFn: () => Promise.reject(new Error("test query error")),
+        queryKey: ["test-query-error"],
+      });
+
+      if (!called.current) {
+        called.current = true;
+        onResult(() => {
+          // no-op trigger
+        });
+      }
+
+      return null;
+    }
+
+    render(
+      createElement(
+        QueryClientProvider,
+        { client: queryClient },
+        createElement(TestComponent, { onResult: (fn) => fn() }),
+      ),
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toBe("test query error");
+  });
+});
--- a/tests/web/hooks/on-success-logging.test.tsx
+++ b/tests/web/hooks/on-success-logging.test.tsx
@@ -0,0 +1,400 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { render } from "@testing-library/react";
+import { describe, expect, mock, test } from "bun:test";
+import { createElement, useRef } from "react";
+
+import {
+  useCreateModel,
+  useDeleteModel,
+  useTestModelConnection,
+  useUpdateModel,
+} from "../../../src/web/hooks/use-models";
+import {
+  useArchiveProject,
+  useCreateProject,
+  useDeleteProject,
+  useRestoreProject,
+  useUpdateProject,
+} from "../../../src/web/hooks/use-projects";
+import {
+  useCreateProvider,
+  useDeleteProvider,
+  useTestProviderConfig,
+  useUpdateProvider,
+} from "../../../src/web/hooks/use-providers";
+import { installFetchMock, jsonResponse } from "../test-utils";
+
+const MODEL = {
+  autoAdapt: true,
+  capabilities: ["text"] as string[],
+  createdAt: "2024-01-01T00:00:00.000Z",
+  customApiKey: null,
+  customBaseUrl: null,
+  description: "测试模型",
+  id: "m1",
+  modelId: "gpt-4",
+  name: "测试模型",
+  providerId: "prov-1",
+  updatedAt: "2024-01-01T00:00:00.000Z",
+};
+
+const PROJECT = {
+  archivedAt: null,
+  createdAt: "2024-01-01T00:00:00.000Z",
+  description: "测试",
+  id: "p1",
+  name: "测试项目",
+  status: "active" as const,
+  updatedAt: "2024-01-01T00:00:00.000Z",
+};
+
+const PROVIDER = {
+  createdAt: "2024-01-01T00:00:00.000Z",
+  id: "prov-1",
+  name: "测试供应商",
+  type: "openai" as const,
+  updatedAt: "2024-01-01T00:00:00.000Z",
+};
+
+function getLogMessages(spy: ReturnType<typeof mock>) {
+  return spy.mock.calls.map((c) => c[0] as string).filter((s) => s.includes("[Alfred:INFO]"));
+}
+
+function makeQueryClient() {
+  return new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+}
+
+function setupModelFetches(result: unknown) {
+  installFetchMock((call) => {
+    if (call.method === "DELETE") return new Response(null, { status: 204 });
+    if (call.url.includes("test")) return jsonResponse({ modelTestResponse: { message: "ok", ok: true } });
+    return jsonResponse({ model: result }, { status: 201 });
+  });
+}
+
+function setupProjectFetches(result: unknown) {
+  installFetchMock((call) => {
+    if (call.method === "DELETE") return new Response(null, { status: 204 });
+    if (call.url.includes("archive")) return jsonResponse({ project: result });
+    if (call.url.includes("restore")) return jsonResponse({ project: result });
+    return jsonResponse({ project: result }, { status: 201 });
+  });
+}
+
+function setupProviderFetches(result: unknown) {
+  installFetchMock((call) => {
+    if (call.method === "DELETE") return new Response(null, { status: 204 });
+    if (call.url.includes("test")) return jsonResponse({ providerTestResponse: { message: "ok", ok: true } });
+    return jsonResponse({ provider: result }, { status: 201 });
+  });
+}
+
+function spyConsoleLog() {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const spy = mock((..._args: any[]) => {});
+  const orig = console.log;
+  console.log = spy;
+  return { orig, restore: () => (console.log = orig), spy };
+}
+
+describe("useProjects onSuccess 日志", () => {
+  const qc = makeQueryClient();
+
+  test("create onSuccess", async () => {
+    setupProjectFetches(PROJECT);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useCreateProject();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate({ name: "x" }));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/项目创建成功/);
+    restore();
+  });
+
+  test("update onSuccess", async () => {
+    setupProjectFetches(PROJECT);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useUpdateProject();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate({ data: { name: "y" }, id: "p1" }));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/项目更新成功/);
+    restore();
+  });
+
+  test("delete onSuccess", async () => {
+    setupProjectFetches(PROJECT);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useDeleteProject();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate("p1"));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/项目删除成功/);
+    restore();
+  });
+
+  test("archive onSuccess", async () => {
+    setupProjectFetches(PROJECT);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useArchiveProject();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate("p1"));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/项目归档成功/);
+    restore();
+  });
+
+  test("restore onSuccess", async () => {
+    setupProjectFetches(PROJECT);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useRestoreProject();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate("p1"));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/项目恢复成功/);
+    restore();
+  });
+});
+
+describe("useModels onSuccess 日志", () => {
+  const qc = makeQueryClient();
+
+  test("create onSuccess", async () => {
+    setupModelFetches(MODEL);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useCreateModel();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate({ capabilities: ["text"], modelId: "gpt-4", name: "x", providerId: "p1" }));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/模型创建成功/);
+    restore();
+  });
+
+  test("update onSuccess", async () => {
+    setupModelFetches(MODEL);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useUpdateModel();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate({ data: { name: "y" }, id: "m1" }));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/模型更新成功/);
+    restore();
+  });
+
+  test("delete onSuccess", async () => {
+    setupModelFetches(MODEL);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useDeleteModel();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate("m1"));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/模型删除成功/);
+    restore();
+  });
+
+  test("test onSuccess", async () => {
+    setupModelFetches(MODEL);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useTestModelConnection();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate({ modelId: "gpt-4", providerId: "p1" }));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    restore();
+    // useTestModelConnection has no onSuccess logger
+    const infoCalls = spy.mock.calls.filter((c) => typeof c[0] === "string" && c[0].includes("[Alfred:INFO]"));
+    expect(infoCalls.length).toBe(0);
+  });
+});
+
+describe("useProviders onSuccess 日志", () => {
+  const qc = makeQueryClient();
+
+  test("create onSuccess", async () => {
+    setupProviderFetches(PROVIDER);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useCreateProvider();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate({ apiKey: "k", baseUrl: "http://x", name: "x", type: "openai" }));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/供应商创建成功/);
+    restore();
+  });
+
+  test("update onSuccess", async () => {
+    setupProviderFetches(PROVIDER);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useUpdateProvider();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate({ data: { name: "y" }, id: "prov-1" }));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/供应商更新成功/);
+    restore();
+  });
+
+  test("delete onSuccess", async () => {
+    setupProviderFetches(PROVIDER);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useDeleteProvider();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate("prov-1"));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    const msgs = getLogMessages(spy);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatch(/供应商删除成功/);
+    restore();
+  });
+
+  test("test onSuccess", async () => {
+    setupProviderFetches(PROVIDER);
+    const { restore, spy } = spyConsoleLog();
+
+    function T({ onResult }: { onResult: (fn: () => void) => void }) {
+      const { mutate } = useTestProviderConfig();
+      const c = useRef(false);
+      if (!c.current) {
+        c.current = true;
+        onResult(() => mutate({ apiKey: "k", baseUrl: "http://x", name: "x", type: "openai" }));
+      }
+      return null;
+    }
+    render(createElement(QueryClientProvider, { client: qc }, createElement(T, { onResult: (fn) => fn() })));
+    await new Promise((r) => setTimeout(r, 200));
+
+    restore();
+    // useTestProviderConfig has no onSuccess logger
+    const infoMsgs = spy.mock.calls.filter((c) => typeof c[0] === "string" && String(c[0]).includes("[Alfred:INFO]"));
+    expect(infoMsgs.length).toBe(0);
+  });
+});
--- a/tests/web/utils/api.test.ts
+++ b/tests/web/utils/api.test.ts
@@ -0,0 +1,134 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { describe, expect, mock, test } from "bun:test";
+
+import { handleResponse, handleVoidResponse } from "../../../src/web/utils/api";
+
+function expectRejects(action: () => Promise<unknown>, message: string) {
+  return action().then(
+    () => {
+      throw new Error("expected rejection");
+    },
+    (error: unknown) => {
+      expect((error as Error).message).toBe(message);
+    },
+  );
+}
+
+function non200Response(body: unknown, status: number): Response {
+  return new Response(JSON.stringify(body), {
+    headers: { "Content-Type": "application/json" },
+    status,
+  });
+}
+
+function spyConsoleLog() {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const spy = mock((..._args: any[]) => {});
+  const orig = console.log;
+  console.log = spy;
+  return { orig, restore: () => (console.log = orig), spy };
+}
+
+function spyConsoleWarn() {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const spy = mock((..._args: any[]) => {});
+  const orig = console.warn;
+  console.warn = spy;
+  return { orig, restore: () => (console.warn = orig), spy };
+}
+
+describe("api.ts 日志行为", () => {
+  test("handleResponse 非 200 响应输出 warn 日志", async () => {
+    const { restore, spy } = spyConsoleWarn();
+
+    const response = non200Response({ error: "项目名称已存在" }, 409);
+    await expectRejects(() => handleResponse(response, (d) => d), "项目名称已存在");
+
+    restore();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    const msg = spy.mock.calls[0]![0] as string;
+    const data = spy.mock.calls[0]![1] as Record<string, unknown>;
+    expect(msg).toMatch(/\[Alfred:WARN\] API request failed/);
+    expect(data).toBeObject();
+    expect(data).toHaveProperty("duration");
+    expect(data).toHaveProperty("errorBody", "项目名称已存在");
+    expect(data).toHaveProperty("status", 409);
+    expect(data).toHaveProperty("url");
+  });
+
+  test("handleVoidResponse 非 200 响应输出 warn 日志", async () => {
+    const { restore, spy } = spyConsoleWarn();
+
+    const response = non200Response({ error: "服务器错误" }, 500);
+    await expectRejects(() => handleVoidResponse(response), "服务器错误");
+
+    restore();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    const msg = spy.mock.calls[0]![0] as string;
+    const data = spy.mock.calls[0]![1] as Record<string, unknown>;
+    expect(msg).toMatch(/\[Alfred:WARN\] API request failed/);
+    expect(data).toHaveProperty("duration");
+    expect(data).toHaveProperty("errorBody", "服务器错误");
+    expect(data).toHaveProperty("status", 500);
+  });
+
+  test("handleResponse 非 JSON 错误响应回退到 HTTP 状态", async () => {
+    const { restore, spy } = spyConsoleWarn();
+
+    const response = new Response("broken", { status: 503 });
+    await expectRejects(() => handleResponse(response, (d) => d), "HTTP 503");
+
+    restore();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    const data = spy.mock.calls[0]![1] as Record<string, unknown>;
+    expect(data).toHaveProperty("errorBody", "HTTP 503");
+    expect(data).toHaveProperty("status", 503);
+  });
+
+  test("handleResponse 成功响应在 DEV 模式输出 debug 日志", async () => {
+    const { restore, spy } = spyConsoleLog();
+
+    (import.meta.env as Record<string, unknown>)["DEV"] = true;
+
+    const response = new Response(JSON.stringify({ ok: true }), {
+      headers: { "Content-Type": "application/json" },
+      status: 200,
+    });
+    await handleResponse(response, (d) => d);
+
+    (import.meta.env as Record<string, unknown>)["DEV"] = undefined;
+    restore();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    const msg = spy.mock.calls[0]![0] as string;
+    const data = spy.mock.calls[0]![1] as Record<string, unknown>;
+    expect(msg).toMatch(/\[Alfred:DEBUG\] API request/);
+    expect(data).toBeObject();
+    expect(data).toHaveProperty("duration");
+    expect(data).toHaveProperty("status", 200);
+    expect(data).toHaveProperty("url");
+  });
+
+  test("handleVoidResponse 成功响应在 DEV 模式输出 debug 日志", async () => {
+    const { restore, spy } = spyConsoleLog();
+
+    (import.meta.env as Record<string, unknown>)["DEV"] = true;
+
+    const response = new Response(null, { status: 204 });
+    await handleVoidResponse(response);
+
+    (import.meta.env as Record<string, unknown>)["DEV"] = undefined;
+    restore();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    const msg = spy.mock.calls[0]![0] as string;
+    const data = spy.mock.calls[0]![1] as Record<string, unknown>;
+    expect(msg).toMatch(/\[Alfred:DEBUG\] API request/);
+    expect(data).toHaveProperty("duration");
+    expect(data).toHaveProperty("status", 204);
+    expect(data).toHaveProperty("url");
+  });
+});