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" });