@allbluecn/web-app 0.6.3 → 0.7.1

package/src/server/ai-gateway/__tests__/run-store.test.ts

@@ -0,0 +1,378 @@
+// @vitest-environment node
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    chatRun: {
+      upsert: vi.fn(),
+      update: vi.fn(),
+      findUnique: vi.fn(),
+      findFirst: vi.fn(),
+      findMany: vi.fn(),
+    },
+  },
+}));
+
+vi.mock("@tanstack/ai", () => ({
+  defineRunStore: vi.fn((store) => store),
+}));
+
+import { prisma } from "@allbluecn/database";
+
+const mockPrisma = prisma as unknown as {
+  chatRun: {
+    upsert: ReturnType<typeof vi.fn>;
+    update: ReturnType<typeof vi.fn>;
+    findUnique: ReturnType<typeof vi.fn>;
+    findFirst: ReturnType<typeof vi.fn>;
+    findMany: ReturnType<typeof vi.fn>;
+  };
+};
+
+describe("runStore", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockPrisma.chatRun.findUnique.mockResolvedValue(null);
+    mockPrisma.chatRun.findFirst.mockResolvedValue(null);
+    mockPrisma.chatRun.findMany.mockResolvedValue([]);
+  });
+
+  it("createOrResume creates a new run with status=running", async () => {
+    const createdRow = {
+      id: "run1",
+      threadId: "thread1",
+      userId: "user1",
+      status: "running",
+      startedAt: new Date(1000),
+      finishedAt: null,
+      detachedSince: null,
+      usage: null,
+      error: null,
+    };
+    mockPrisma.chatRun.upsert.mockResolvedValue(createdRow);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    const record = await store.createOrResume({
+      runId: "run1",
+      threadId: "thread1",
+      startedAt: 1000,
+    });
+
+    expect(mockPrisma.chatRun.upsert).toHaveBeenCalledWith({
+      where: { id: "run1" },
+      create: {
+        id: "run1",
+        threadId: "thread1",
+        userId: "user1",
+        status: "running",
+        startedAt: new Date(1000),
+      },
+      update: {},
+    });
+    expect(record).toMatchObject({
+      runId: "run1",
+      threadId: "thread1",
+      status: "running",
+      startedAt: 1000,
+    });
+  });
+
+  it("createOrResume is idempotent for existing run", async () => {
+    const existingRow = {
+      id: "run1",
+      threadId: "thread1",
+      userId: "user1",
+      status: "running",
+      startedAt: new Date(5000),
+      finishedAt: null,
+      detachedSince: null,
+      usage: null,
+      error: null,
+    };
+    mockPrisma.chatRun.upsert.mockResolvedValue(existingRow);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    const record = await store.createOrResume({
+      runId: "run1",
+      threadId: "thread1",
+      startedAt: 9999,
+    });
+
+    expect(mockPrisma.chatRun.upsert).toHaveBeenCalledWith(
+      expect.objectContaining({
+        create: expect.objectContaining({
+          startedAt: new Date(9999),
+        }),
+        update: {},
+      }),
+    );
+    expect(record).toMatchObject({
+      runId: "run1",
+      startedAt: 5000,
+    });
+  });
+
+  it("update modifies status and finishedAt", async () => {
+    const existingRow = {
+      id: "run1",
+      threadId: "thread1",
+      userId: "user1",
+      status: "running",
+      startedAt: new Date(1000),
+      finishedAt: null,
+      detachedSince: null,
+      usage: null,
+      error: null,
+    };
+    mockPrisma.chatRun.findUnique.mockResolvedValue(existingRow);
+    mockPrisma.chatRun.update.mockResolvedValue({} as any);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    await store.update("run1", { status: "completed", finishedAt: 2000 });
+
+    expect(mockPrisma.chatRun.findUnique).toHaveBeenCalledWith({
+      where: { id: "run1" },
+    });
+    expect(mockPrisma.chatRun.update).toHaveBeenCalledWith({
+      where: { id: "run1" },
+      data: {
+        status: "completed",
+        finishedAt: new Date(2000),
+      },
+    });
+  });
+
+  it("update no-ops for unknown runId without throwing", async () => {
+    mockPrisma.chatRun.findUnique.mockResolvedValue(null);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    await expect(store.update("unknown", { status: "completed" })).resolves.toBe(
+      undefined,
+    );
+
+    expect(mockPrisma.chatRun.findUnique).toHaveBeenCalledWith({
+      where: { id: "unknown" },
+    });
+    expect(mockPrisma.chatRun.update).not.toHaveBeenCalled();
+  });
+
+  it("get returns known run", async () => {
+    const row = {
+      id: "run1",
+      threadId: "thread1",
+      userId: "user1",
+      status: "completed",
+      startedAt: new Date(1000),
+      finishedAt: new Date(2000),
+      detachedSince: null,
+      usage: { input: 100, output: 200 },
+      error: null,
+    };
+    mockPrisma.chatRun.findUnique.mockResolvedValue(row);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    const record = await store.get("run1");
+
+    expect(mockPrisma.chatRun.findUnique).toHaveBeenCalledWith({
+      where: { id: "run1" },
+    });
+    expect(record).toMatchObject({
+      runId: "run1",
+      threadId: "thread1",
+      status: "completed",
+      startedAt: 1000,
+      finishedAt: 2000,
+      usage: { input: 100, output: 200 },
+    });
+  });
+
+  it("get returns null for unknown runId", async () => {
+    mockPrisma.chatRun.findUnique.mockResolvedValue(null);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    const record = await store.get("nonexistent");
+
+    expect(mockPrisma.chatRun.findUnique).toHaveBeenCalledWith({
+      where: { id: "nonexistent" },
+    });
+    expect(record).toBeNull();
+  });
+
+  it("findActiveRun returns latest running run for thread", async () => {
+    const runningRow = {
+      id: "run2",
+      threadId: "thread1",
+      userId: "user1",
+      status: "running",
+      startedAt: new Date(3000),
+      finishedAt: null,
+      detachedSince: null,
+      usage: null,
+      error: null,
+    };
+    mockPrisma.chatRun.findFirst.mockResolvedValue(runningRow);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    const record = await store.findActiveRun("thread1");
+
+    expect(mockPrisma.chatRun.findFirst).toHaveBeenCalledWith({
+      where: {
+        threadId: "thread1",
+        userId: "user1",
+        status: { in: ["running", "interrupted"] },
+      },
+      orderBy: { startedAt: "desc" },
+    });
+    expect(record).toMatchObject({
+      runId: "run2",
+      status: "running",
+      startedAt: 3000,
+    });
+  });
+
+  it("findActiveRun returns null when no active run", async () => {
+    mockPrisma.chatRun.findFirst.mockResolvedValue(null);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    const record = await store.findActiveRun("thread1");
+
+    expect(record).toBeNull();
+  });
+
+  it("listByThread returns runs in ascending startedAt order", async () => {
+    const rows = [
+      {
+        id: "run1",
+        threadId: "thread1",
+        userId: "user1",
+        status: "completed",
+        startedAt: new Date(1000),
+        finishedAt: new Date(1500),
+        detachedSince: null,
+        usage: null,
+        error: null,
+      },
+      {
+        id: "run2",
+        threadId: "thread1",
+        userId: "user1",
+        status: "running",
+        startedAt: new Date(2000),
+        finishedAt: null,
+        detachedSince: null,
+        usage: null,
+        error: null,
+      },
+    ];
+    mockPrisma.chatRun.findMany.mockResolvedValue(rows);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    const records = await store.listByThread?.("thread1");
+
+    expect(mockPrisma.chatRun.findMany).toHaveBeenCalledWith({
+      where: { threadId: "thread1", userId: "user1" },
+      orderBy: { startedAt: "asc" },
+    });
+    expect(records).toHaveLength(2);
+    expect(records![0]).toMatchObject({ runId: "run1", startedAt: 1000 });
+    expect(records![1]).toMatchObject({ runId: "run2", startedAt: 2000 });
+  });
+
+  it("update serializes error to JSON", async () => {
+    const existingRow = {
+      id: "run1",
+      threadId: "thread1",
+      userId: "user1",
+      status: "running",
+      startedAt: new Date(1000),
+      finishedAt: null,
+      detachedSince: null,
+      usage: null,
+      error: null,
+    };
+    mockPrisma.chatRun.findUnique.mockResolvedValue(existingRow);
+    mockPrisma.chatRun.update.mockResolvedValue({} as any);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    await store.update("run1", {
+      error: { message: "timeout", code: "ETIMEDOUT" },
+    });
+
+    expect(mockPrisma.chatRun.update).toHaveBeenCalledWith({
+      where: { id: "run1" },
+      data: {
+        error: JSON.stringify({ message: "timeout", code: "ETIMEDOUT" }),
+      },
+    });
+  });
+
+  it("rowToRecord parses error JSON from DB", async () => {
+    const row = {
+      id: "run1",
+      threadId: "thread1",
+      userId: "user1",
+      status: "failed",
+      startedAt: new Date(1000),
+      finishedAt: new Date(2000),
+      detachedSince: null,
+      usage: null,
+      error: JSON.stringify({ message: "fail", code: "EFAIL" }),
+    };
+    mockPrisma.chatRun.findUnique.mockResolvedValue(row);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    const record = await store.get("run1");
+
+    expect(record).toMatchObject({
+      runId: "run1",
+      status: "failed",
+      finishedAt: 2000,
+      error: { message: "fail", code: "EFAIL" },
+    });
+  });
+
+  it("listReclaimable returns detached running runs past TTL", async () => {
+    const row = {
+      id: "run1",
+      threadId: "thread1",
+      userId: "user1",
+      status: "running",
+      startedAt: new Date(1000),
+      finishedAt: null,
+      detachedSince: new Date(5000),
+      usage: null,
+      error: null,
+    };
+    mockPrisma.chatRun.findMany.mockResolvedValue([row]);
+
+    const store = (await import("../persistence/run-store")).runStore("user1");
+    const records = await store.listReclaimable?.({ now: 10000, ttlMs: 6000 });
+
+    expect(mockPrisma.chatRun.findMany).toHaveBeenCalledWith({
+      where: {
+        userId: "user1",
+        status: "running",
+        detachedSince: { lte: expect.any(Date) },
+      },
+    });
+    expect(records).toHaveLength(1);
+    expect(records![0]).toMatchObject({ runId: "run1", detachedSince: 5000 });
+  });
+});

package/src/server/ai-gateway/__tests__/runtime.test.ts

@@ -0,0 +1,58 @@
+// @vitest-environment node
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { describe, it, expect, beforeEach } from "vitest"
+import { registerGatewayPorts, getPorts, resetGatewayPortsForTest } from "../runtime"
+
+describe("gateway runtime", () => {
+  beforeEach(() => {
+    resetGatewayPortsForTest()
+  })
+
+  it("未注册时 getPorts 抛出明确错误", () => {
+    expect(() => getPorts()).toThrowError(/\[ai-gateway\] ports 未注册/)
+  })
+
+  const fullPorts = {
+    keyCipher: { decrypt: (k: string) => k },
+    accessPolicy: { requireFeature: async () => undefined },
+    auth: { getSession: async () => null },
+    remoteAuth: { read: async () => null },
+    webSearch: { search: async () => ({ results: [] }) },
+    infra: {
+      ragSearch: async () => [],
+      indexDocumentEmbeddings: async () => 0,
+      resolveKnowledgeAiConfig: async () => null,
+      deleteEmbeddings: async () => undefined,
+    },
+  }
+
+  it("注册后 getPorts 返回注册的实现", () => {
+    const cipher = { decrypt: (k: string) => k }
+    registerGatewayPorts({ ...fullPorts, keyCipher: cipher } as never)
+    expect(getPorts().keyCipher).toBe(cipher)
+  })
+
+  it("重复注册幂等覆盖", () => {
+    const a = { decrypt: (k: string) => k }
+    const b = { decrypt: (k: string) => k }
+    registerGatewayPorts({ ...fullPorts, keyCipher: a } as never)
+    registerGatewayPorts({ keyCipher: b } as never)
+    expect(getPorts().keyCipher).toBe(b)
+  })
+})

package/src/server/ai-gateway/__tests__/story-prompt.test.ts

@@ -0,0 +1,34 @@
+// @vitest-environment node
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { describe, it, expect } from "vitest"
+import { buildStorySystemPrompt } from "../story-prompt"
+
+describe("buildStorySystemPrompt labelHint", () => {
+  it("有标签时包含收束与 2-4 字规则", () => {
+    const p = buildStorySystemPrompt({ taskType: "create", requirement: "x", availableLabels: ["性能"] })
+    expect(p).toContain("优先从可用标签中选用")
+    expect(p).toContain("2-4 个汉字")
+    expect(p).toContain("性能")
+  })
+
+  it("无标签时禁止输出 labelNames", () => {
+    const p = buildStorySystemPrompt({ taskType: "create", requirement: "x" })
+    expect(p).toContain("不要输出 labelNames 字段")
+  })
+})

package/src/server/ai-gateway/__tests__/tools-select.test.ts

@@ -0,0 +1,103 @@
+// @vitest-environment node
+import { describe, it, expect } from "vitest"
+import { AGENT_TOOL_KEYS, selectTools } from "../tools/select"
+
+type MockTool = { name: string; value: string }
+
+const allTools: MockTool[] = [
+  { name: "knowledge_search", value: "ks" },
+  { name: "document_action", value: "da" },
+  { name: "user_data_query", value: "ud" },
+  { name: "web_search", value: "ws" },
+  { name: "reindex_knowledge_base", value: "rk" },
+  { name: "delete_project", value: "dp" },
+]
+
+describe("AGENT_TOOL_KEYS", () => {
+  it("包含所有已注册的 agent 工具", () => {
+    expect(AGENT_TOOL_KEYS).toContain("knowledge_search")
+    expect(AGENT_TOOL_KEYS).toContain("document_action")
+    expect(AGENT_TOOL_KEYS).toContain("user_data_query")
+    expect(AGENT_TOOL_KEYS).toContain("web_search")
+    expect(AGENT_TOOL_KEYS).toContain("reindex_knowledge_base")
+    expect(AGENT_TOOL_KEYS).toContain("delete_project")
+  })
+
+  it("恰好包含 6 个工具", () => {
+    expect(AGENT_TOOL_KEYS.length).toBe(6)
+  })
+})
+
+describe("selectTools", () => {
+  it("缺省 allowedKeys 时返回全量工具", () => {
+    const result = selectTools(allTools)
+    expect(result).toHaveLength(6)
+    expect(result).toEqual(allTools)
+  })
+
+  it("空数组 allowedKeys 时返回全量工具", () => {
+    const result = selectTools(allTools, [])
+    expect(result).toHaveLength(6)
+    expect(result.map((t) => t.name)).toEqual(allTools.map((t) => t.name))
+  })
+
+  it("白名单过滤只保留匹配的工具（delete_project 除外）", () => {
+    const result = selectTools(allTools, ["knowledge_search", "web_search"])
+    expect(result.map((t) => t.name)).toEqual(["knowledge_search", "web_search", "delete_project"])
+  })
+
+  it("delete_project 永留：即使不在白名单中也包含", () => {
+    const result = selectTools(allTools, ["knowledge_search"])
+    expect(result).toHaveLength(2)
+    expect(result.map((t) => t.name)).toEqual(["knowledge_search", "delete_project"])
+  })
+
+  it("delete_project 在白名单中正常包含", () => {
+    const result = selectTools(allTools, ["knowledge_search", "delete_project"])
+    expect(result).toHaveLength(2)
+    expect(result.map((t) => t.name)).toEqual(["knowledge_search", "delete_project"])
+  })
+
+  it("未知工具 key 被丢弃，不报错", () => {
+    const result = selectTools(allTools, ["knowledge_search", "nonexistent_tool"])
+    expect(result).toHaveLength(2)
+    expect(result.map((t) => t.name)).toEqual(["knowledge_search", "delete_project"])
+  })
+
+  it("白名单全为空结果时仍保留 delete_project", () => {
+    const result = selectTools(allTools, ["nonexistent_a", "nonexistent_b"])
+    expect(result).toHaveLength(1)
+    expect(result[0].name).toBe("delete_project")
+  })
+
+  it("输入为空数组时返回空数组", () => {
+    const result = selectTools([] as MockTool[])
+    expect(result).toEqual([])
+  })
+
+  it("不修改原始数组（返回新数组）", () => {
+    const original = [...allTools]
+    selectTools(allTools, ["knowledge_search"])
+    expect(allTools).toEqual(original)
+  })
+
+  it("同步执行，不返回 Promise", () => {
+    const result = selectTools(allTools, ["web_search"])
+    expect(result).not.toBeInstanceOf(Promise)
+    expect(Array.isArray(result)).toBe(true)
+  })
+
+  it("保持原始顺序", () => {
+    const result = selectTools(allTools, ["web_search", "knowledge_search"])
+    expect(result.map((t) => t.name)).toEqual(["knowledge_search", "web_search", "delete_project"])
+  })
+
+  it("别名 google_search 可匹配 web_search 白名单", () => {
+    const geminiTools: MockTool[] = [
+      { name: "google_search", value: "gs" },
+      { name: "knowledge_search", value: "ks" },
+    ]
+    const result = selectTools(geminiTools, ["web_search", "knowledge_search"])
+    expect(result.map((t) => t.name)).toEqual(["google_search", "knowledge_search"])
+  })
+})

package/src/server/ai-gateway/__tests__/unified-router.test.ts

@@ -0,0 +1,124 @@
+// @vitest-environment node
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock("../runtime", () => ({
+  getPorts: () => ({
+    remoteAuth: { read: async () => null },
+    accessPolicy: { requireFeature: async () => {} },
+  }),
+}))
+
+vi.mock('../provider-router', () => ({
+  resolveAiConfigForModel: vi.fn(),
+  resolveDefaultProviderConfig: vi.fn(),
+}))
+vi.mock('../adapter', () => ({
+  resolveAiConfig: vi.fn(),
+  createProviderAdapter: vi.fn(),
+  createAdapter: vi.fn(),
+}))
+vi.mock('@allblue/pro', () => ({
+  proModule: { isAvailable: false, hostedAi: null },
+}))
+vi.mock('@allbluecn/database', () => ({ prisma: {} }))
+
+import { resolveUnifiedAiStream, NoAiAvailableError } from '../unified-router'
+import {
+  resolveAiConfigForModel,
+  resolveDefaultProviderConfig,
+} from '../provider-router'
+import {
+  resolveAiConfig,
+  createProviderAdapter,
+  createAdapter,
+} from '../adapter'
+
+const mockResolveForModel = resolveAiConfigForModel as ReturnType<typeof vi.fn>
+const mockResolveDefault = resolveDefaultProviderConfig as ReturnType<typeof vi.fn>
+const mockResolveAiConfig = resolveAiConfig as ReturnType<typeof vi.fn>
+const mockCreateProviderAdapter = createProviderAdapter as ReturnType<typeof vi.fn>
+const mockCreateAdapter = createAdapter as ReturnType<typeof vi.fn>
+
+describe('resolveUnifiedAiStream 决策树', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('BYOK 模型路由优先：指定 model 且命中 → 用 BYOK', async () => {
+    mockResolveForModel.mockResolvedValue({
+      providerId: 'openai',
+      adapterKind: 'openai',
+      apiKey: 'sk-xxx',
+      baseUrl: null,
+      model: 'gpt-4o',
+      isLocal: false,
+    })
+    mockCreateProviderAdapter.mockResolvedValue({})
+
+    const req = {
+      userId: 'u1',
+      messages: [{ role: 'user' as const, content: 'hi' }],
+      model: 'gpt-4o',
+    }
+    await resolveUnifiedAiStream(req)
+
+    expect(mockResolveForModel).toHaveBeenCalledWith('u1', 'gpt-4o')
+    expect(mockResolveDefault).not.toHaveBeenCalled()
+  })
+
+  it('BYOK 默认配置兜底：无 model，但用户有 enabled provider → 用 BYOK', async () => {
+    mockResolveForModel.mockResolvedValue(null)
+    mockResolveDefault.mockResolvedValue({
+      providerId: 'anthropic',
+      adapterKind: 'anthropic',
+      apiKey: 'sk-yyy',
+      baseUrl: null,
+      model: 'claude-sonnet-4',
+      isLocal: false,
+    })
+    mockCreateProviderAdapter.mockResolvedValue({})
+
+    const req = {
+      userId: 'u1',
+      messages: [{ role: 'user' as const, content: 'hi' }],
+    }
+    await resolveUnifiedAiStream(req)
+
+    expect(mockResolveDefault).toHaveBeenCalledWith('u1')
+  })
+
+  it('旧字段/env 兜底：新表无配置但有旧 aiApiKey → 用 BYOK（fallback）', async () => {
+    mockResolveForModel.mockResolvedValue(null)
+    mockResolveDefault.mockResolvedValue(null)
+    mockResolveAiConfig.mockResolvedValue({
+      provider: 'openrouter',
+      apiKey: 'sk-or-xxx',
+      model: 'openai/gpt-4o-mini',
+      source: 'env',
+    })
+    mockCreateAdapter.mockReturnValue({})
+
+    const req = {
+      userId: 'u1',
+      messages: [{ role: 'user' as const, content: 'hi' }],
+    }
+    await resolveUnifiedAiStream(req)
+
+    expect(mockResolveAiConfig).toHaveBeenCalledWith('u1')
+  })
+
+  it('开源版（hostedAi === null）+ 无 BYOK → 抛 NoAiAvailableError', async () => {
+    mockResolveForModel.mockResolvedValue(null)
+    mockResolveDefault.mockResolvedValue(null)
+    mockResolveAiConfig.mockResolvedValue(null)
+
+    const req = {
+      userId: 'u1',
+      messages: [{ role: 'user' as const, content: 'hi' }],
+      workspaceId: 'ws1',
+    }
+    await expect(resolveUnifiedAiStream(req)).rejects.toMatchObject({
+      name: 'NoAiAvailableError',
+    })
+  })
+})