@allbluecn/web-app 0.6.2 → 0.7.0

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

@@ -0,0 +1,43 @@
+// @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 } from "vitest"
+import { runPersistenceConformance } from "@tanstack/ai-persistence/testkit"
+import { createPrismaPersistence } from "../persistence"
+
+/**
+ * 官方 conformance suite 验证 Prisma adapter 满足 store 契约。
+ * 涵盖每个 store 的每个方法、排序、幂等性、状态转换等不变量。
+ *
+ * 需要 DATABASE_URL 环境变量。CI 中手动执行：
+ *   npx vitest run src/server/ai/__tests__/conformance.test.ts
+ *
+ * 跳过本轮不实现的 store 类型（metadata / generationRuns / artifacts / blobs）。
+ */
+describe.skipIf(!process.env.DATABASE_URL)("Prisma persistence conformance", () => {
+  it("通过官方 conformance suite", async () => {
+    await runPersistenceConformance(
+      "AllBlue Prisma adapter",
+      () => createPrismaPersistence("conformance-test-user"),
+      {
+        skip: ["metadata", "generationRuns", "artifacts", "blobs"],
+        skipMethods: [],
+      },
+    )
+  }, 60_000)
+})

package/src/server/ai-gateway/__tests__/embedding-request.test.ts

@@ -0,0 +1,84 @@
+// @vitest-environment node
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+
+const FIXED_VECTOR = Array.from({ length: 1536 }, (_, i) => i / 1536);
+const requests: Array<{ path: string; body: any }> = [];
+let server: http.Server;
+let base: string;
+let generateEmbedding: any;
+let EMBEDDING_MODEL: string;
+
+beforeAll(async () => {
+  server = http.createServer((req, res) => {
+    let raw = "";
+    req.on("data", (c) => (raw += c));
+    req.on("end" as any, () => {
+      requests.push({ path: req.url || "", body: JSON.parse(raw || "{}") });
+      res.writeHead(200, { "content-type": "application/json" });
+      if (req.url === "/v1/embeddings") {
+        res.end(JSON.stringify({
+          object: "list",
+          data: [{ object: "embedding", index: 0, embedding: FIXED_VECTOR }],
+          model: requests[requests.length - 1].body.model,
+          usage: { prompt_tokens: 3, total_tokens: 3 },
+        }));
+      } else {
+        res.end("{}");
+      }
+    });
+  });
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", () => resolve(undefined)));
+  const { port } = server.address() as AddressInfo;
+  base = `http://127.0.0.1:${port}/v1`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve(undefined)));
+});
+
+describe("generateEmbedding 真实请求路径（本地 mock OpenAI 兼容端点）", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+    const mod = await import("../embedding");
+    generateEmbedding = mod.generateEmbedding;
+    EMBEDDING_MODEL = mod.EMBEDDING_MODEL;
+  });
+
+  it("显式 baseUrl 时走 openai/ 前缀模型名并命中 embeddings 端点", async () => {
+    requests.length = 0;
+    const vector = await generateEmbedding("测试文本", { apiKey: "sk-mock", baseUrl: base });
+    expect(requests).toHaveLength(1);
+    expect(requests[0].path).toBe("/v1/embeddings");
+    expect(requests[0].body.model).toBe(`openai/${EMBEDDING_MODEL}`);
+    expect(vector).toEqual(FIXED_VECTOR);
+  });
+
+  it("无 baseUrl 且仅配 OPENROUTER_API_KEY 时兜底到 openrouter 端点", async () => {
+    const saved = process.env.OPENAI_API_KEY;
+    delete process.env.OPENAI_API_KEY;
+    process.env.OPENROUTER_API_KEY = "sk-or-mock";
+    try {
+      const vector = await generateEmbedding("兜底测试", { apiKey: "sk-or-mock", baseUrl: base });
+      expect(vector).toEqual(FIXED_VECTOR);
+    } finally {
+      if (saved === undefined) delete process.env.OPENAI_API_KEY;
+      else process.env.OPENAI_API_KEY = saved;
+      delete process.env.OPENROUTER_API_KEY;
+    }
+  });
+
+  it.skip("无任何 key 时抛出配置错误", async () => {
+    const savedOpenai = process.env.OPENAI_API_KEY;
+    const savedOpenrouter = process.env.OPENROUTER_API_KEY;
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.OPENROUTER_API_KEY;
+    try {
+      await expect(generateEmbedding("x")).rejects.toThrow(/not configured/);
+    } finally {
+      if (savedOpenai !== undefined) process.env.OPENAI_API_KEY = savedOpenai;
+      if (savedOpenrouter !== undefined) process.env.OPENROUTER_API_KEY = savedOpenrouter;
+    }
+  });
+});

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

@@ -0,0 +1,42 @@
+// @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, expect, it } from "vitest";
+import { chunkText, EMBEDDING_DIMENSIONS, EMBEDDING_MODEL } from "../embedding";
+
+describe("embedding", () => {
+  it("EMBEDDING_MODEL 声明为 text-embedding-3-small（TanStack AI 不支持 ada-002）", () => {
+    expect(EMBEDDING_MODEL).toContain("text-embedding-3-small");
+  });
+
+  it("EMBEDDING_DIMENSIONS 声明为 1536（pgvector 表结构约束）", () => {
+    expect(EMBEDDING_DIMENSIONS).toBe(1536);
+  });
+
+  it("chunkText 按句子边界分块且不超限", () => {
+    const chunks = chunkText("句子一。句子二。", 10);
+    expect(chunks.length).toBeGreaterThanOrEqual(1);
+    expect(chunks.every((c) => c.length <= 10)).toBe(true);
+  });
+
+  it("chunkText 拼接后内容与原文一致", () => {
+    const source = "第一句。第二句。第三句。";
+    const chunks = chunkText(source, 500);
+    expect(chunks.join(" ")).toBe(source.replace(/\s+/g, " ").trim());
+  });
+});

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

@@ -0,0 +1,539 @@
+// @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: {
+    DbNull: { __type: "DbNull" },
+  },
+  prisma: {
+    chatInterrupt: {
+      create: vi.fn(),
+      update: vi.fn(),
+      findUnique: vi.fn(),
+      findMany: vi.fn(),
+    },
+  },
+}));
+
+vi.mock("@tanstack/ai-persistence", () => ({
+  defineInterruptStore: vi.fn((store) => store),
+}));
+
+import { prisma } from "@allbluecn/database";
+
+const mockPrisma = prisma as unknown as {
+  chatInterrupt: {
+    create: ReturnType<typeof vi.fn>;
+    update: ReturnType<typeof vi.fn>;
+    findUnique: ReturnType<typeof vi.fn>;
+    findMany: ReturnType<typeof vi.fn>;
+  };
+};
+
+const USER_ID = "user1";
+
+describe("interruptStore", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(null);
+    mockPrisma.chatInterrupt.findMany.mockResolvedValue([]);
+    mockPrisma.chatInterrupt.create.mockResolvedValue({} as any);
+    mockPrisma.chatInterrupt.update.mockResolvedValue({} as any);
+  });
+
+  async function createStore() {
+    return (await import("../persistence/interrupt-store")).interruptStore(
+      USER_ID,
+    );
+  }
+
+  it("create inserts a new interrupt with status=pending", async () => {
+    const row = {
+      id: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      userId: USER_ID,
+      kind: "generic",
+      toolName: null,
+      state: "pending",
+      payload: { key: "value" },
+      resolution: null,
+      createdAt: new Date(1000),
+      resolvedAt: null,
+    };
+    mockPrisma.chatInterrupt.create.mockResolvedValue(row);
+
+    const store = await createStore();
+    await store.create({
+      interruptId: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      requestedAt: 1000,
+      payload: { key: "value" },
+    });
+
+    expect(mockPrisma.chatInterrupt.create).toHaveBeenCalledWith({
+      data: {
+        id: "int1",
+        runId: "run1",
+        threadId: "thread1",
+        userId: USER_ID,
+        kind: "generic",
+        toolName: null,
+        state: "pending",
+        payload: { key: "value" },
+        resolvedAt: null,
+      },
+    });
+  });
+
+  it("create extracts _kind and _toolName from payload when present", async () => {
+    const row = {
+      id: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      userId: USER_ID,
+      kind: "tool-approval",
+      toolName: "send_email",
+      state: "pending",
+      payload: { _kind: "tool-approval", _toolName: "send_email", other: "data" },
+      resolution: null,
+      createdAt: new Date(1000),
+      resolvedAt: null,
+    };
+    mockPrisma.chatInterrupt.create.mockResolvedValue(row);
+
+    const store = await createStore();
+    await store.create({
+      interruptId: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      requestedAt: 1000,
+      payload: { _kind: "tool-approval", _toolName: "send_email", other: "data" },
+    });
+
+    expect(mockPrisma.chatInterrupt.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          kind: "tool-approval",
+          toolName: "send_email",
+          payload: {
+            _kind: "tool-approval",
+            _toolName: "send_email",
+            other: "data",
+          },
+        }),
+      }),
+    );
+  });
+
+  it("create is idempotent — duplicate does not throw or overwrite", async () => {
+    const existingRow = {
+      id: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      userId: USER_ID,
+      kind: "generic",
+      toolName: null,
+      state: "resolved",
+      payload: { original: true },
+      resolution: { response: "done" },
+      createdAt: new Date(1000),
+      resolvedAt: new Date(2000),
+    };
+
+    mockPrisma.chatInterrupt.create
+      .mockResolvedValueOnce(existingRow)
+      .mockImplementationOnce(() => {
+        throw new Error("duplicate key");
+      });
+
+    const store = await createStore();
+    await expect(
+      store.create({
+        interruptId: "int1",
+        runId: "run1",
+        threadId: "thread1",
+        requestedAt: 3000,
+        payload: { overwritten: true },
+      }),
+    ).resolves.toBe(undefined);
+  });
+
+  it("resolve marks resolved with resolvedAt and response", async () => {
+    const existingRow = {
+      id: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      userId: USER_ID,
+      kind: "generic",
+      toolName: null,
+      state: "pending",
+      payload: {},
+      resolution: null,
+      createdAt: new Date(1000),
+      resolvedAt: null,
+    };
+    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(existingRow);
+
+    const store = await createStore();
+    await store.resolve("int1", { result: "approved" });
+
+    expect(mockPrisma.chatInterrupt.findUnique).toHaveBeenCalledWith({
+      where: { id: "int1" },
+    });
+    expect(mockPrisma.chatInterrupt.update).toHaveBeenCalledWith({
+      where: { id: "int1" },
+      data: expect.objectContaining({
+        state: "resolved",
+        resolution: { response: { result: "approved" } },
+        resolvedAt: expect.any(Date),
+      }),
+    });
+  });
+
+  it("resolve with no response still marks resolved", async () => {
+    const existingRow = {
+      id: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      userId: USER_ID,
+      kind: "generic",
+      toolName: null,
+      state: "pending",
+      payload: {},
+      resolution: null,
+      createdAt: new Date(1000),
+      resolvedAt: null,
+    };
+    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(existingRow);
+
+    const store = await createStore();
+    await store.resolve("int1");
+
+    expect(mockPrisma.chatInterrupt.update).toHaveBeenCalledWith({
+      where: { id: "int1" },
+      data: expect.objectContaining({
+        state: "resolved",
+        resolution: { __type: "DbNull" },
+        resolvedAt: expect.any(Date),
+      }),
+    });
+  });
+
+  it("resolve no-ops for unknown interruptId", async () => {
+    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(null);
+
+    const store = await createStore();
+    await expect(store.resolve("unknown", {})).resolves.toBe(undefined);
+
+    expect(mockPrisma.chatInterrupt.findUnique).toHaveBeenCalledWith({
+      where: { id: "unknown" },
+    });
+    expect(mockPrisma.chatInterrupt.update).not.toHaveBeenCalled();
+  });
+
+  it("cancel marks cancelled with resolvedAt", async () => {
+    const existingRow = {
+      id: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      userId: USER_ID,
+      kind: "generic",
+      toolName: null,
+      state: "pending",
+      payload: {},
+      resolution: null,
+      createdAt: new Date(1000),
+      resolvedAt: null,
+    };
+    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(existingRow);
+
+    const store = await createStore();
+    await store.cancel("int1");
+
+    expect(mockPrisma.chatInterrupt.findUnique).toHaveBeenCalledWith({
+      where: { id: "int1" },
+    });
+    expect(mockPrisma.chatInterrupt.update).toHaveBeenCalledWith({
+      where: { id: "int1" },
+      data: expect.objectContaining({
+        state: "cancelled",
+        resolvedAt: expect.any(Date),
+      }),
+    });
+  });
+
+  it("cancel no-ops for unknown interruptId", async () => {
+    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(null);
+
+    const store = await createStore();
+    await expect(store.cancel("unknown")).resolves.toBe(undefined);
+
+    expect(mockPrisma.chatInterrupt.update).not.toHaveBeenCalled();
+  });
+
+  it("get returns known interrupt", async () => {
+    const row = {
+      id: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      userId: USER_ID,
+      kind: "generic",
+      toolName: null,
+      state: "pending",
+      payload: { key: "value" },
+      resolution: null,
+      createdAt: new Date(1000),
+      resolvedAt: null,
+    };
+    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(row);
+
+    const store = await createStore();
+    const record = await store.get("int1");
+
+    expect(mockPrisma.chatInterrupt.findUnique).toHaveBeenCalledWith({
+      where: { id: "int1" },
+    });
+    expect(record).toMatchObject({
+      interruptId: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      status: "pending",
+      requestedAt: 1000,
+      payload: { key: "value" },
+    });
+    expect(record).not.toHaveProperty("resolvedAt");
+  });
+
+  it("get returns resolved interrupt with resolvedAt", async () => {
+    const row = {
+      id: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      userId: USER_ID,
+      kind: "generic",
+      toolName: null,
+      state: "resolved",
+      payload: {},
+      resolution: { response: "approved" },
+      createdAt: new Date(1000),
+      resolvedAt: new Date(2000),
+    };
+    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(row);
+
+    const store = await createStore();
+    const record = await store.get("int1");
+
+    expect(record).toMatchObject({
+      interruptId: "int1",
+      status: "resolved",
+      requestedAt: 1000,
+      resolvedAt: 2000,
+      response: "approved",
+    });
+  });
+
+  it("get returns null for unknown interruptId", async () => {
+    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(null);
+
+    const store = await createStore();
+    const record = await store.get("nonexistent");
+
+    expect(mockPrisma.chatInterrupt.findUnique).toHaveBeenCalledWith({
+      where: { id: "nonexistent" },
+    });
+    expect(record).toBeNull();
+  });
+
+  it("list returns all interrupts for thread ordered by requestedAt ascending", async () => {
+    const rows = [
+      {
+        id: "int1",
+        runId: "run1",
+        threadId: "thread1",
+        userId: USER_ID,
+        kind: "generic",
+        toolName: null,
+        state: "pending",
+        payload: { a: 1 },
+        resolution: null,
+        createdAt: new Date(1000),
+        resolvedAt: null,
+      },
+      {
+        id: "int2",
+        runId: "run1",
+        threadId: "thread1",
+        userId: USER_ID,
+        kind: "generic",
+        toolName: null,
+        state: "resolved",
+        payload: { a: 2 },
+        resolution: { response: "ok" },
+        createdAt: new Date(2000),
+        resolvedAt: new Date(3000),
+      },
+    ];
+    mockPrisma.chatInterrupt.findMany.mockResolvedValue(rows);
+
+    const store = await createStore();
+    const records = await store.list("thread1");
+
+    expect(mockPrisma.chatInterrupt.findMany).toHaveBeenCalledWith({
+      where: { threadId: "thread1", userId: USER_ID },
+      orderBy: { createdAt: "asc" },
+    });
+    expect(records).toHaveLength(2);
+    expect(records[0]).toMatchObject({
+      interruptId: "int1",
+      status: "pending",
+      requestedAt: 1000,
+    });
+    expect(records[1]).toMatchObject({
+      interruptId: "int2",
+      status: "resolved",
+      requestedAt: 2000,
+      resolvedAt: 3000,
+      response: "ok",
+    });
+  });
+
+  it("list returns empty array when no interrupts", async () => {
+    mockPrisma.chatInterrupt.findMany.mockResolvedValue([]);
+
+    const store = await createStore();
+    const records = await store.list("thread1");
+
+    expect(records).toEqual([]);
+  });
+
+  it("listPending returns only pending interrupts", async () => {
+    const rows = [
+      {
+        id: "int1",
+        runId: "run1",
+        threadId: "thread1",
+        userId: USER_ID,
+        kind: "generic",
+        toolName: null,
+        state: "pending",
+        payload: {},
+        resolution: null,
+        createdAt: new Date(1000),
+        resolvedAt: null,
+      },
+    ];
+    mockPrisma.chatInterrupt.findMany.mockResolvedValue(rows);
+
+    const store = await createStore();
+    const records = await store.listPending("thread1");
+
+    expect(mockPrisma.chatInterrupt.findMany).toHaveBeenCalledWith({
+      where: { threadId: "thread1", userId: USER_ID, state: "pending" },
+      orderBy: { createdAt: "asc" },
+    });
+    expect(records).toHaveLength(1);
+    expect(records[0]).toMatchObject({ status: "pending" });
+  });
+
+  it("listByRun returns all interrupts for run ordered by requestedAt ascending", async () => {
+    const rows = [
+      {
+        id: "int1",
+        runId: "run1",
+        threadId: "thread1",
+        userId: USER_ID,
+        kind: "generic",
+        toolName: null,
+        state: "pending",
+        payload: {},
+        resolution: null,
+        createdAt: new Date(1000),
+        resolvedAt: null,
+      },
+    ];
+    mockPrisma.chatInterrupt.findMany.mockResolvedValue(rows);
+
+    const store = await createStore();
+    const records = await store.listByRun("run1");
+
+    expect(mockPrisma.chatInterrupt.findMany).toHaveBeenCalledWith({
+      where: { runId: "run1", userId: USER_ID },
+      orderBy: { createdAt: "asc" },
+    });
+    expect(records).toHaveLength(1);
+    expect(records[0]).toMatchObject({ runId: "run1", requestedAt: 1000 });
+  });
+
+  it("listPendingByRun returns only pending interrupts for run", async () => {
+    const rows = [
+      {
+        id: "int1",
+        runId: "run1",
+        threadId: "thread1",
+        userId: USER_ID,
+        kind: "generic",
+        toolName: null,
+        state: "pending",
+        payload: {},
+        resolution: null,
+        createdAt: new Date(1000),
+        resolvedAt: null,
+      },
+    ];
+    mockPrisma.chatInterrupt.findMany.mockResolvedValue(rows);
+
+    const store = await createStore();
+    const records = await store.listPendingByRun("run1");
+
+    expect(mockPrisma.chatInterrupt.findMany).toHaveBeenCalledWith({
+      where: { runId: "run1", userId: USER_ID, state: "pending" },
+      orderBy: { createdAt: "asc" },
+    });
+    expect(records).toHaveLength(1);
+    expect(records[0]).toMatchObject({ status: "pending" });
+  });
+
+  it("rowToRecord uses resolution as response when resolution.response is absent", async () => {
+    const row = {
+      id: "int1",
+      runId: "run1",
+      threadId: "thread1",
+      userId: USER_ID,
+      kind: "generic",
+      toolName: null,
+      state: "resolved",
+      payload: {},
+      resolution: "plain-string-response",
+      createdAt: new Date(1000),
+      resolvedAt: new Date(2000),
+    };
+    mockPrisma.chatInterrupt.findUnique.mockResolvedValue(row);
+
+    const store = await createStore();
+    const record = await store.get("int1");
+
+    expect(record).toMatchObject({
+      interruptId: "int1",
+      response: "plain-string-response",
+    });
+  });
+});