@allbluecn/web-app 0.12.0 → 0.12.2

package/src/server/ai-gateway/middlewares/rate-limit.ts

@@ -15,15 +15,15 @@
 // 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 type { ChatMiddleware } from "@tanstack/ai"
+import { defineChatMiddleware } from "@tanstack/ai"
 import type { AppContext } from "../types"
 
 const counters = new Map<string, { count: number; resetAt: number }>()
 const LIMIT = 30
 const WINDOW = 60_000
 
-export const rateLimitMiddleware: ChatMiddleware<AppContext> = {
-  name: "rate-limit",
+export const rateLimitMiddleware = defineChatMiddleware<AppContext>({
+  name: "ai-rate-limit",
   onBeforeToolCall(ctx, _hookCtx) {
     const userId = ctx.context.userId
     const now = Date.now()
@@ -37,4 +37,4 @@ export const rateLimitMiddleware: ChatMiddleware<AppContext> = {
       return { type: "abort", reason: `Rate limit exceeded: ${LIMIT} tool calls/min` }
     }
   },
-}
+})

package/src/server/ai-gateway/middlewares/tool-budget.ts

@@ -0,0 +1,50 @@
+// 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 { defineChatMiddleware } from "@tanstack/ai"
+
+const MAX_TOTAL_TOOL_CALLS = 40
+const MAX_PER_TURN = 10
+
+/**
+ * 工厂函数：每次 chat() 调用创建独立实例（闭包计数器随 run 生命周期）。
+ * 单例会导致不同 run 之间计数污染，因此禁止直接使用返回值。
+ */
+export function createToolBudgetMiddleware() {
+  let turnCount = 0
+  return defineChatMiddleware({
+    name: "ai-tool-budget",
+    onIteration() {
+      turnCount = 0
+    },
+    onBeforeToolCall(_ctx, _hookCtx) {
+      if (turnCount >= MAX_PER_TURN) {
+        return {
+          type: "skip",
+          result: {
+            error: "Tool budget exceeded: per-turn limit reached (10 calls).",
+            hint: "Stop issuing tool calls and finish your response.",
+          },
+        }
+      }
+      turnCount += 1
+    },
+    onShouldContinue(_ctx, state) {
+      return state.toolCallCount < MAX_TOTAL_TOOL_CALLS
+    },
+  })
+}

package/src/server/ai-gateway/middlewares/usage-log.ts

@@ -0,0 +1,158 @@
+// 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 { prisma } from '@allbluecn/database'
+import { defineChatMiddleware } from '@tanstack/ai'
+import type { AppContext } from '../types'
+
+/** 计量维度。`sandbox` 与 ResourceRegistry.sandboxMinutesMonthly 的聚合条件对齐。 */
+export type AiUsageActivity = 'chat' | 'sandbox'
+
+export interface WriteAiUsageLogInput {
+  workspaceId: string | null
+  userId: string
+  activity?: AiUsageActivity | null
+  provider: string
+  model: string
+  inputTokens?: number
+  outputTokens?: number
+  success?: boolean
+  errorMessage?: string | null
+  durationMs?: number | null
+}
+
+const MAX_ERROR_MESSAGE = 500
+
+/**
+ * AiUsageLog 的唯一写入点。任何失败都降级为 null（计量不能反过来打断 chat 流），
+ * 调用方不依赖返回值。
+ */
+export async function writeAiUsageLog(
+  input: WriteAiUsageLogInput,
+): Promise<string | null> {
+  try {
+    const row = await prisma.aiUsageLog.create({
+      data: {
+        workspaceId: input.workspaceId,
+        userId: input.userId,
+        activity: input.activity ?? null,
+        provider: input.provider,
+        model: input.model,
+        inputTokens: input.inputTokens ?? 0,
+        outputTokens: input.outputTokens ?? 0,
+        success: input.success ?? true,
+        durationMs: input.durationMs ?? null,
+        ...(input.errorMessage
+          ? { errorMessage: input.errorMessage.slice(0, MAX_ERROR_MESSAGE) }
+          : {}),
+      },
+      select: { id: true },
+    })
+    return row.id
+  } catch (e) {
+    console.warn('[AI] 用量落库失败:', e instanceof Error ? e.message : String(e))
+    return null
+  }
+}
+
+/**
+ * 计量归属解析：客户端传来的 workspaceId 不可信（IDOR），必须校验成员关系；
+ * 未传或校验失败时回落到本人拥有的第一个工作区。无工作区的用户返回 null——
+ * workspaceId 列可空，计量照常落库（配额按 userId 计，不因缺工作区而漏记）。
+ */
+export async function resolveUsageWorkspaceId(
+  userId: string,
+  requested?: string,
+): Promise<string | null> {
+  if (requested) {
+    const member = await prisma.workspaceMember.findUnique({
+      where: { workspaceId_userId: { workspaceId: requested, userId } },
+      select: { workspaceId: true },
+    })
+    if (member) return member.workspaceId
+    console.warn('[AI] workspaceId 非当前用户成员，用量归属回落本人工作区', requested)
+  }
+  const owned = await prisma.workspace.findFirst({
+    where: { ownerId: userId },
+    select: { id: true },
+  })
+  return owned?.id ?? null
+}
+
+export interface UsageLogMiddlewareOptions {
+  /** 计量维度，缺省 'chat'。 */
+  activity?: AiUsageActivity | null
+}
+
+/**
+ * 工厂函数：每次 chat() 调用一个实例（与 tool-budget 同一约定）。
+ *
+ * 只在终态钩子写入——官方契约保证 onFinish / onAbort / onError 每轮恰好一个，
+ * 因此天然不会重复记账。`duration` 由框架给出（含工具调用耗时，沙箱工具跑在
+ * 流内），所以分钟配额的 `durationMs` 覆盖的是「本轮 chat 的墙钟时长」而非沙箱
+ * 实例存活时长：一次长跑的多轮对话会计多次，这是有意的近似，不是漏记。
+ *
+ * `costUsd` 恒为 null：OSS 仓没有单价表，BYOK 档实际成本取决于用户自己的 key，
+ * 猜一个数字只会污染 admin 的成本视图。
+ */
+export function createUsageLogMiddleware(options: UsageLogMiddlewareOptions = {}) {
+  const build = (
+    ctx: { context: AppContext },
+    info: {
+      duration: number
+      success: boolean
+      errorMessage?: string
+      usage?: { promptTokens?: number; completionTokens?: number }
+    },
+  ): WriteAiUsageLogInput => ({
+    workspaceId: ctx.context.workspaceId ?? null,
+    userId: ctx.context.userId,
+    activity: options.activity ?? 'chat',
+    provider: ctx.context.provider ?? 'unknown',
+    model: ctx.context.model ?? 'unknown',
+    inputTokens: info.usage?.promptTokens,
+    outputTokens: info.usage?.completionTokens,
+    success: info.success,
+    errorMessage: info.errorMessage ?? null,
+    durationMs: info.duration,
+  })
+
+  // 终态钩子的签名要求 void；行 id 对调用方无意义，这里剥掉返回值，
+  // 同时保留可 await 的 promise（测试与调用方都能等到写入完成）。
+  const record = (input: WriteAiUsageLogInput): Promise<void> =>
+    writeAiUsageLog(input).then(() => undefined)
+
+  return defineChatMiddleware<AppContext>({
+    name: 'ai-usage-log',
+    onFinish(ctx, { duration, usage }) {
+      return record(build(ctx, { duration, success: true, usage }))
+    },
+    onAbort(ctx, { duration }) {
+      // 用户主动停止不是错误：admin 的告警按 success=false 统计失败率。
+      return record(build(ctx, { duration, success: true }))
+    },
+    onError(ctx, { error, duration }) {
+      return record(
+        build(ctx, {
+          duration,
+          success: false,
+          errorMessage: error instanceof Error ? error.message : String(error),
+        }),
+      )
+    },
+  })
+}

package/src/server/ai-gateway/model-fetch.ts

@@ -32,13 +32,14 @@ type AdapterKind =
   | "grok"
   | "openrouter"
   | "ollama"
+  | "mistral"
 
 const REQUEST_TIMEOUT_MS = 30_000
 
 /**
  * 从 provider API 获取可用模型 id 列表（用于「获取模型列表」刷新）。
  * 按 adapterKind 构造请求并解析返回体：
- *   - OpenAI 兼容系（openai/openai-compatible/groq/grok）：GET {base}/v1/models → data[].id
+ *   - OpenAI 兼容系（openai/openai-compatible/groq/grok/mistral）：GET {base}/v1/models → data[].id
  *   - anthropic：GET {base}/v1/models（x-api-key）→ data[].id
  *   - gemini：GET {base}/v1beta/models?key= → models[].name（去掉 models/ 前缀）
  *   - openrouter：GET {base}/models → data[].id
@@ -78,7 +79,8 @@ async function runFetch(
     case "openai":
     case "openai-compatible":
     case "groq":
-    case "grok": {
+    case "grok":
+    case "mistral": {
       const res = await fetch(`${ensureV1(base)}/models`, {
         headers: { Authorization: `Bearer ${apiKey}` },
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),

package/src/server/ai-gateway/persistence/index.ts

@@ -16,19 +16,21 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 import { defineAIPersistence } from "@tanstack/ai-persistence"
-import type { ChatWithInterruptsPersistence } from "@tanstack/ai-persistence"
+import type { ChatPersistence } from "@tanstack/ai-persistence"
 import { messageStore } from "./message-store"
 import { runStore } from "./run-store"
 import { interruptStore } from "./interrupt-store"
+import { metadataStore } from "./metadata-store"
 
 export function createPrismaPersistence(
   userId: string,
-): ChatWithInterruptsPersistence {
+): ChatPersistence {
   return defineAIPersistence({
     stores: {
       messages: messageStore(userId),
       runs: runStore(userId),
       interrupts: interruptStore(userId),
+      metadata: metadataStore(),
     },
   })
 }

package/src/server/ai-gateway/persistence/interrupt-store.ts

@@ -25,21 +25,55 @@ export function interruptStore(userId: string): InterruptStore {
       const kind = (payload._kind as string) ?? "generic";
       const toolName = (payload._toolName as string) ?? null;
 
-      await prisma.chatInterrupt.create({
-        data: {
-          id: record.interruptId,
-          runId: record.runId,
+      // ChatInterrupt FK 链到 ChatRun FK 链到 ChatThread，而 testkit 与业务调用方
+      // 都可能直接 create interrupt 不预建 parent。此处幂等保障 parent 存在
+      // （与 run-store.createOrResume 的 thread upsert 模式一致）：update 分支
+      // 空对象，已存在的 run/thread 原样返回，不重置状态（防把已 completed 的
+      // run 错误拉回 running）。
+      await prisma.chatThread.upsert({
+        where: { id: record.threadId },
+        create: { id: record.threadId, userId },
+        update: {},
+      });
+      await prisma.chatRun.upsert({
+        where: { id: record.runId },
+        create: {
+          id: record.runId,
           threadId: record.threadId,
           userId,
-          kind,
-          toolName,
-          state: "pending",
-          payload: payload as Prisma.InputJsonValue,
-          resolvedAt: null,
+          status: "running",
+          startedAt: new Date(),
         },
-      }).catch(() => {
-        /* insert-if-absent: duplicate interruptId is a no-op */
+        update: {},
       });
+
+      try {
+        await prisma.chatInterrupt.create({
+          data: {
+            id: record.interruptId,
+            runId: record.runId,
+            threadId: record.threadId,
+            userId,
+            kind,
+            toolName,
+            state: "pending",
+            payload: payload as Prisma.InputJsonValue,
+            requestedAt: new Date(record.requestedAt),
+            resolvedAt: null,
+          },
+        });
+      } catch (err) {
+        // insert-if-absent：只对 unique constraint 冲突（P2002 duplicate id）
+        // 做 no-op；其他错误（FK 违反 P2003、连接失败等）必须抛出，否则
+        // 数据静默丢失——persistence conformance 套件会因 FK 吞错全挂。
+        if (
+          err instanceof Prisma.PrismaClientKnownRequestError &&
+          err.code === "P2002"
+        ) {
+          return;
+        }
+        throw err;
+      }
     },
 
     async resolve(interruptId, response) {
@@ -91,7 +125,7 @@ export function interruptStore(userId: string): InterruptStore {
     async list(threadId) {
       const rows = await prisma.chatInterrupt.findMany({
         where: { threadId, userId },
-        orderBy: { createdAt: "asc" },
+        orderBy: { requestedAt: "asc" },
       });
       return rows.map(rowToRecord);
     },
@@ -99,7 +133,7 @@ export function interruptStore(userId: string): InterruptStore {
     async listPending(threadId) {
       const rows = await prisma.chatInterrupt.findMany({
         where: { threadId, userId, state: "pending" },
-        orderBy: { createdAt: "asc" },
+        orderBy: { requestedAt: "asc" },
       });
       return rows.map(rowToRecord);
     },
@@ -107,7 +141,7 @@ export function interruptStore(userId: string): InterruptStore {
     async listByRun(runId) {
       const rows = await prisma.chatInterrupt.findMany({
         where: { runId, userId },
-        orderBy: { createdAt: "asc" },
+        orderBy: { requestedAt: "asc" },
       });
       return rows.map(rowToRecord);
     },
@@ -115,10 +149,37 @@ export function interruptStore(userId: string): InterruptStore {
     async listPendingByRun(runId) {
       const rows = await prisma.chatInterrupt.findMany({
         where: { runId, userId, state: "pending" },
-        orderBy: { createdAt: "asc" },
+        orderBy: { requestedAt: "asc" },
       });
       return rows.map(rowToRecord);
     },
+
+    // Batch terminal writes. Prisma's array-form $transaction is all-or-
+    // nothing: any missing id (P2025) or other write failure rolls the whole
+    // batch back and rethrows, so a partial approval can never slip through
+    // unnoticed. The contract intentionally does NOT swallow errors here —
+    // callers (resolveInterrupts) need to surface a failed batch rather than
+    // report a resolution that never landed.
+    async commitBatch(entries) {
+      await prisma.$transaction(
+        entries.map((entry) =>
+          prisma.chatInterrupt.update({
+            where: { id: entry.interruptId },
+            data: {
+              state: entry.status,
+              resolvedAt: new Date(),
+              ...(entry.status === "resolved" && entry.response != null
+                ? {
+                    resolution: {
+                      response: entry.response,
+                    } as Prisma.InputJsonValue,
+                  }
+                : {}),
+            },
+          }),
+        ),
+      );
+    },
   });
 }
 
@@ -127,6 +188,7 @@ function rowToRecord(row: {
   runId: string;
   threadId: string;
   state: string;
+  requestedAt: Date;
   createdAt: Date;
   resolvedAt?: Date | null;
   payload: unknown;
@@ -137,7 +199,7 @@ function rowToRecord(row: {
     runId: row.runId,
     threadId: row.threadId,
     status: row.state as "pending" | "resolved" | "cancelled",
-    requestedAt: row.createdAt.getTime(),
+    requestedAt: (row.requestedAt ?? row.createdAt).getTime(),
     payload: (row.payload ?? {}) as Record<string, unknown>,
   };
 

package/src/server/ai-gateway/persistence/message-store.ts

@@ -16,6 +16,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 import { defineMessageStore, type MessageStore } from "@tanstack/ai-persistence";
+import { generateId } from "@tanstack/ai-utils";
 import { prisma, Prisma } from "@allbluecn/database";
 import type { ModelMessage } from "@tanstack/ai";
 
@@ -34,15 +35,14 @@ export function messageStore(userId: string): MessageStore {
       });
 
       return rows.map((row) => {
-        const content = Array.isArray(row.parts) && row.parts.length > 0
-          ? row.parts
-          : row.content;
         return {
-          id: row.id,
           role: row.role as "user" | "assistant" | "tool",
-          content,
-          parts: Array.isArray(row.parts) ? row.parts : undefined,
-          ...(row.thinking ? { thinking: row.thinking } : {}),
+          content: row.content ?? "",
+          ...(Array.isArray(row.parts) && row.parts.length > 0
+            ? { toolCalls: row.parts }
+            : {}),
+          ...(row.thinking ? { thinking: parseThinking(row.thinking) } : {}),
+          ...(row.toolCallId ? { toolCallId: row.toolCallId } : {}),
         } as ModelMessage;
       });
     },
@@ -51,6 +51,15 @@ export function messageStore(userId: string): MessageStore {
       threadId: string,
       messages: Array<ModelMessage>,
     ): Promise<void> {
+      // ChatMessage FK 到 ChatThread；业务调用方与 testkit 都可能直接
+      // saveThread 不预建 thread。此处幂等保障 thread 存在（与 run-store /
+      // interrupt-store 的 upsert 模式一致），update 分支空对象不重置 title。
+      await prisma.chatThread.upsert({
+        where: { id: threadId },
+        create: { id: threadId, userId },
+        update: {},
+      });
+
       await prisma.chatMessage.deleteMany({
         where: { threadId, thread: { userId } },
       });
@@ -61,15 +70,14 @@ export function messageStore(userId: string): MessageStore {
       }
 
       const data = messages.map((m, idx) => ({
-        id: m.id ?? generateId(idx),
+        id: m.id ?? generateId(`msg-${idx}`),
         threadId,
         role: m.role,
-        content: extractContentString(m),
-        parts: Array.isArray(m.content)
-          ? (m.content as unknown as Prisma.InputJsonValue)
-          : null,
-        thinking: m.thinking ? m.thinking.map((t) => t.content).join("\n") : null,
+        content: m.content ?? null,
+        parts: m.toolCalls ? (m.toolCalls as unknown as Prisma.InputJsonValue) : null,
+        thinking: m.thinking ? JSON.stringify(m.thinking) : null,
         citations: null,
+        toolCallId: m.toolCallId ?? null,
         createdAt: new Date(Date.now() + idx),
       })) as unknown as Prisma.ChatMessageCreateManyInput[];
 
@@ -95,30 +103,21 @@ async function updateThreadUpdated(threadId: string): Promise<void> {
 }
 
 /**
- * Collapse a message's content into a plain string for storage.
+ * Parse a stored `thinking` column back to the ModelMessage shape.
  *
- * - `string` → as-is
- * - `null` → empty string
- * - array of ContentPart → join text parts, ignore images/audio/etc.
+ * New format (this file): JSON string of an array of `{content, signature?}`.
+ * Legacy format (pre-2026-09-14): a single string with the contents joined by
+ * `"\n"`. We degrade gracefully — a legacy string becomes a one-element array —
+ * so existing conversations keep working without a data migration.
  */
-function extractContentString(m: ModelMessage): string {
-  if (typeof m.content === "string") return m.content;
-  if (m.content === null) return "";
-  if (Array.isArray(m.content)) {
-    return m.content
-      .filter(
-        (p: unknown): p is { type: "text"; content: string } =>
-          typeof p === "object" &&
-          p !== null &&
-          (p as { type?: string }).type === "text" &&
-          typeof (p as { content?: string }).content === "string",
-      )
-      .map((p) => p.content)
-      .join("");
+function parseThinking(
+  raw: string,
+): Array<{ content: string; signature?: string }> {
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return parsed;
+  } catch {
+    // fall through to legacy handling
   }
-  return "";
-}
-
-function generateId(idx: number): string {
-  return `msg_${Date.now()}_${idx}_${Math.random().toString(36).slice(2, 8)}`;
+  return [{ content: raw }];
 }

package/src/server/ai-gateway/persistence/metadata-store.ts

@@ -0,0 +1,62 @@
+// 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 { defineMetadataStore, type MetadataStore } from "@tanstack/ai-persistence";
+import { prisma, Prisma } from "@allbluecn/database";
+
+/**
+ * Global MetadataStore backed by Prisma's ChatPersistenceMeta table.
+ *
+ * Unlike the other stores, this one is NOT user-scoped: the `(namespace, key)`
+ * composite identity carries its own isolation contract, and the middleware
+ * that consumes it (compaction, ChatProjection) is responsible for baking a
+ * tenant-scoped key into the namespace — typically `compaction/<threadId>`.
+ *
+ * Composite uniqueness is enforced by the `chat_persistence_meta_namespace_key_key`
+ * unique index, so `set` uses `upsert` and `get` uses `findUnique` on the
+ * `namespace_key` compound key.
+ */
+export function metadataStore(): MetadataStore {
+  return defineMetadataStore({
+    async get(namespace, key) {
+      const row = await prisma.chatPersistenceMeta.findUnique({
+        where: { namespace_key: { namespace, key } },
+      });
+      return row ? (row.value as unknown) : null;
+    },
+
+    async set(namespace, key, value) {
+      await prisma.chatPersistenceMeta.upsert({
+        where: { namespace_key: { namespace, key } },
+        create: {
+          namespace,
+          key,
+          value: value as unknown as Prisma.InputJsonValue,
+        },
+        update: { value: value as unknown as Prisma.InputJsonValue },
+      });
+    },
+
+    async delete(namespace, key) {
+      // The contract says "do nothing when it is absent" — a missing row is a
+      // valid no-op, not an error the caller has to handle.
+      await prisma.chatPersistenceMeta
+        .delete({ where: { namespace_key: { namespace, key } } })
+        .catch(() => {});
+    },
+  });
+}