@allbluecn/web-app 0.19.2 → 0.19.4

package/src/server/ai-gateway/middlewares/logger.ts

@@ -17,6 +17,7 @@
 
 import { defineChatMiddleware } from "@tanstack/ai"
 import type { AppContext } from "../types"
+import { redactSecretsForLog } from "../log-redact"
 
 export const loggerMiddleware = defineChatMiddleware<AppContext>({
   name: "ai-logger",
@@ -30,6 +31,8 @@ export const loggerMiddleware = defineChatMiddleware<AppContext>({
     console.log(`[AI] finish requestId=${ctx.requestId}`)
   },
   onError(ctx, { error }) {
-    console.error(`[AI] error requestId=${ctx.requestId}:`, error)
+    // 脱敏后再落日志：HTTP 层错误常把完整 URL（含 gemini ?key= / sk- 密钥）嵌进
+    // message，日志聚合后成为第二泄露面
+    console.error(`[AI] error requestId=${ctx.requestId}:`, redactSecretsForLog(error))
   },
 })

package/src/server/ai-gateway/middlewares/plan-approval.ts

@@ -16,6 +16,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 import { defineChatMiddleware } from "@tanstack/ai";
+import type { z } from "zod";
 import type { AppContext } from "../types";
 import {
   planApprovalInterrupt,
@@ -24,6 +25,12 @@ import {
 
 const PLAN_SUBMIT_TOOL_NAME = "plan_submit";
 
+/** 校验失败时的占位审批 payload（满足 planApprovalPayloadSchema：title+steps）。 */
+const FALLBACK_PAYLOAD: { title: string; steps: Array<{ content: string }> } = {
+  title: "（计划参数无法解析，请拒绝并要求模型重新提交）",
+  steps: [],
+};
+
 /**
  * 工厂函数：每次 chat() 调用创建独立实例，闭包 Set 记录已 raise 过的 toolCallId，
  * 防止 resume 时同一 tool call 被二次触发 interrupt。tool-budget.ts 也是这个模式。
@@ -54,30 +61,42 @@ export function createPlanApprovalMiddleware() {
       if (planCalls.length === 0) return undefined;
 
       const interrupts = planCalls.map((tc) => {
-        let parsed: unknown;
+        // 不变式（审计 2026-10-25 A3x-2 🟡）：plan_submit 必须经过人。
+        // JSON 非法 / schema 校验失败时**仍然 raise interrupt**（降级 payload），
+        // 而非 return null 跳过审批——后者会让该 tool call 不进审批流程直接
+        // 执行。参数是 LLM 可控的：「过工具校验但故意过不了审批 schema」的
+        // 构造（或未来工具校验放宽）会把审批门整个绕掉。降级审批被批准后，
+        // 工具侧仍会以原始 arguments 执行并因校验失败报错（无害），拒绝则
+        // 走既有 cancel 路径——人工闸门在任何形态下都成立。
+        let payload: z.infer<typeof planApprovalPayloadSchema>
         try {
-          parsed = JSON.parse(tc.function.arguments.trim() || "{}");
+          const parsed: unknown = JSON.parse(tc.function.arguments.trim() || "{}");
+          const check = planApprovalPayloadSchema.safeParse(parsed);
+          if (!check.success) {
+            console.warn(
+              `[AI] plan_submit payload 未通过 schema 校验，降级为占位审批 (toolCall=${tc.id})`,
+              check.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", "),
+            );
+            payload = FALLBACK_PAYLOAD;
+          } else {
+            payload = check.data;
+          }
         } catch (err) {
           console.warn(
-            `[AI] plan_submit arguments 非合法 JSON，跳过审批 (toolCall=${tc.id})`,
+            `[AI] plan_submit arguments 非合法 JSON，降级为占位审批 (toolCall=${tc.id})`,
             err instanceof Error ? err.message : "unknown",
           );
-          return null;
-        }
-        const check = planApprovalPayloadSchema.safeParse(parsed);
-        if (!check.success) {
-          console.warn(
-            `[AI] plan_submit payload 未通过 schema 校验，跳过审批 (toolCall=${tc.id})`,
-            check.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", "),
-          );
-          return null;
+          payload = FALLBACK_PAYLOAD;
         }
         raisedToolCallIds.add(tc.id);
         return planApprovalInterrupt.interrupt({
           key: tc.id,
           reason: "plan_approval",
-          message: `需要审批执行计划${check.data.title ? `：${check.data.title}` : ""}`,
-          payload: check.data,
+          message:
+            payload === FALLBACK_PAYLOAD
+              ? "计划参数无法解析，请人工确认后再执行"
+              : `需要审批执行计划${payload.title ? `：${payload.title}` : ""}`,
+          payload,
         });
       }).filter((r): r is NonNullable<typeof r> => r !== null);
 

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

@@ -18,15 +18,30 @@
 import { defineChatMiddleware } from "@tanstack/ai"
 import type { AppContext } from "../types"
 
+// 边界声明（审计 2026-10-25 A3x-2 🟡）：与 server/lib/rate-limit.ts 同类约束——
+// 计数器为进程内存态，多实例部署不共享，实际阈值 = LIMIT × 实例数；多实例部署
+// 落地前不得把本限流视为安全唯一防线（服务端鉴权与配额硬校验不可省）。
 const counters = new Map<string, { count: number; resetAt: number }>()
 const LIMIT = 30
 const WINDOW = 60_000
+/** 过期条目惰性清扫周期：按墙钟触发一次全表清扫，防 Map 只增不减。 */
+const SWEEP_INTERVAL = 5 * 60_000
+let lastSweepAt = Date.now()
+
+function sweepExpired(now: number): void {
+  if (now - lastSweepAt < SWEEP_INTERVAL) return
+  lastSweepAt = now
+  for (const [key, entry] of counters) {
+    if (now > entry.resetAt) counters.delete(key)
+  }
+}
 
 export const rateLimitMiddleware = defineChatMiddleware<AppContext>({
   name: "ai-rate-limit",
   onBeforeToolCall(ctx, _hookCtx) {
     const userId = ctx.context.userId
     const now = Date.now()
+    sweepExpired(now)
     let entry = counters.get(userId)
     if (!entry || now > entry.resetAt) {
       entry = { count: 0, resetAt: now + WINDOW }

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

@@ -37,6 +37,22 @@ export interface WriteAiUsageLogInput {
 
 const MAX_ERROR_MESSAGE = 500
 
+/**
+ * errorMessage 模式脱敏（审计 2026-10-25 A3x-2 ⚪）：provider/adapter 异常
+ * message 可能携带 baseUrl、请求参数甚至 key 片段进入 AiUsageLog（admin 可见）。
+ * 写库前对常见密钥形态做掩码；截断仍在脱敏之后（先抹再截，防截断边界切出
+ * 半个明文 key）。
+ */
+function maskSecretPatterns(message: string): string {
+  return message
+    .replace(/sk-[A-Za-z0-9_-]{6,}/g, "sk-***")
+    .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{6,}/gi, "Bearer ***")
+    .replace(
+      /((?:api[-_]?key|token|key|secret)['"]?\s*[:=]\s*['"]?)[A-Za-z0-9._~+/=-]{6,}/gi,
+      "$1***",
+    )
+}
+
 /**
  * AiUsageLog 的唯一写入点。任何失败都降级为 null（计量不能反过来打断 chat 流），
  * 调用方不依赖返回值。
@@ -57,7 +73,7 @@ export async function writeAiUsageLog(
         success: input.success ?? true,
         durationMs: input.durationMs ?? null,
         ...(input.errorMessage
-          ? { errorMessage: input.errorMessage.slice(0, MAX_ERROR_MESSAGE) }
+          ? { errorMessage: maskSecretPatterns(input.errorMessage).slice(0, MAX_ERROR_MESSAGE) }
           : {}),
       },
       select: { id: true },

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

@@ -99,6 +99,9 @@ async function runFetch(
       return extractDataIds(await asJson(res))
     }
     case "gemini": {
+      // key 经 `?key=` 查询串携带是 Gemini 官方协议形态（无 header 替代通道）；
+      // 已知代价：完整 URL（含 key）会进入中间代理 / 访问日志。SSRF 面
+      // （assertFetchableUrl + redirect:"error" + 超时）已闭环，无需改动。
       const res = await fetch(
         `${base}/v1beta/models?key=${encodeURIComponent(apiKey)}`,
         { redirect: "error", signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) },

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

@@ -30,6 +30,18 @@ export function interruptStore(userId: string): InterruptStore {
       // （与 run-store.createOrResume 的 thread upsert 模式一致）：update 分支
       // 空对象，已存在的 run/thread 原样返回，不重置状态（防把已 completed 的
       // run 错误拉回 running）。
+      // 归属校验（审计 2026-10-25 persistence【疑似】证实）：threadId 由请求侧
+      // 提供，他人 thread 上创建 run/interrupt 行会污染对方线程。他人 thread
+      // 显式抛错，不静默通过（与 run-store.createOrResume 同口径）。
+      const existingThread = await prisma.chatThread.findUnique({
+        where: { id: record.threadId },
+        select: { userId: true },
+      });
+      if (existingThread && existingThread.userId !== userId) {
+        throw new Error(
+          `chat thread ${record.threadId} does not belong to user ${userId}`,
+        );
+      }
       await prisma.chatThread.upsert({
         where: { id: record.threadId },
         create: { id: record.threadId, userId },
@@ -76,38 +88,28 @@ export function interruptStore(userId: string): InterruptStore {
       }
     },
 
+    // resolve/cancel/get/commitBatch 补 userId 行级过滤（审计 2026-10-25 A3x-2 🟠，
+    // 与 list 系列同口径）：interruptId 一旦可由客户端面传入（审批回调等），
+    // 裸 id 操作即构成水平越权（替他人批准 plan_submit / 读他人 interrupt
+    // payload）。存在性 no-op 语义由 updateMany 的 count=0 / findFirst null
+    // 保留；find-then-update 的存在性预检删除（审计 🟡：预检冗余且构成
+    // TOCTOU 竞态窗口，单条 updateMany 天然原子）。
     async resolve(interruptId, response) {
-      const existing = await prisma.chatInterrupt.findUnique({
-        where: { id: interruptId },
-      });
-      if (!existing) return;
-
-      const updateData: {
-        state: string;
-        resolvedAt: Date;
-        resolution: Prisma.InputJsonValue | typeof Prisma.DbNull;
-      } = {
-        state: "resolved",
-        resolvedAt: new Date(),
-        resolution: response
-          ? ({ response } as Prisma.InputJsonValue)
-          : Prisma.DbNull,
-      };
-
-      await prisma.chatInterrupt.update({
-        where: { id: interruptId },
-        data: updateData,
+      await prisma.chatInterrupt.updateMany({
+        where: { id: interruptId, userId },
+        data: {
+          state: "resolved",
+          resolvedAt: new Date(),
+          resolution: response
+            ? ({ response } as Prisma.InputJsonValue)
+            : Prisma.DbNull,
+        },
       });
     },
 
     async cancel(interruptId) {
-      const existing = await prisma.chatInterrupt.findUnique({
-        where: { id: interruptId },
-      });
-      if (!existing) return;
-
-      await prisma.chatInterrupt.update({
-        where: { id: interruptId },
+      await prisma.chatInterrupt.updateMany({
+        where: { id: interruptId, userId },
         data: {
           state: "cancelled",
           resolvedAt: new Date(),
@@ -116,8 +118,8 @@ export function interruptStore(userId: string): InterruptStore {
     },
 
     async get(interruptId) {
-      const row = await prisma.chatInterrupt.findUnique({
-        where: { id: interruptId },
+      const row = await prisma.chatInterrupt.findFirst({
+        where: { id: interruptId, userId },
       });
       return row ? rowToRecord(row) : null;
     },
@@ -160,11 +162,14 @@ export function interruptStore(userId: string): InterruptStore {
     // 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.
+    // 审计 2026-10-25 A3x-2 🟠：按 userId 过滤（updateMany），命中 0 行（不
+    // 存在或属他人）视为批次失败显式抛错，保持「部分审批不可能静默通过」的
+    // 契约不因过滤放宽。
     async commitBatch(entries) {
-      await prisma.$transaction(
+      const results = await prisma.$transaction(
         entries.map((entry) =>
-          prisma.chatInterrupt.update({
-            where: { id: entry.interruptId },
+          prisma.chatInterrupt.updateMany({
+            where: { id: entry.interruptId, userId },
             data: {
               state: entry.status,
               resolvedAt: new Date(),
@@ -179,6 +184,11 @@ export function interruptStore(userId: string): InterruptStore {
           }),
         ),
       );
+      if (results.some((r) => r.count === 0)) {
+        throw new Error(
+          "commitBatch: one or more interrupts missing or not owned by the current user",
+        );
+      }
     },
   });
 }

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

@@ -66,6 +66,18 @@ export function messageStore(userId: string): MessageStore {
       threadId: string,
       messages: Array<ModelMessage>,
     ): Promise<void> {
+      // 归属校验（审计 2026-10-25 persistence【疑似】证实）：threadId 由请求侧
+      // 提供，若已存在的 thread 属他人，直接追加消息会把 A 的对话写进 B 的线程
+      // （loadThread/deleteMany 有 userId 过滤，但 createMany 没有——污染面）。
+      // 与 run-store.createOrResume 同口径：他人 thread 显式抛错，不静默通过。
+      const existing = await prisma.chatThread.findUnique({
+        where: { id: threadId },
+        select: { userId: true },
+      });
+      if (existing && existing.userId !== userId) {
+        throw new Error(`chat thread ${threadId} does not belong to user ${userId}`);
+      }
+
       // ChatMessage FK 到 ChatThread；业务调用方与 testkit 都可能直接
       // saveThread 不预建 thread。此处幂等保障 thread 存在（与 run-store /
       // interrupt-store 的 upsert 模式一致），update 分支空对象不重置 title。
@@ -75,15 +87,6 @@ export function messageStore(userId: string): MessageStore {
         update: {},
       });
 
-      await prisma.chatMessage.deleteMany({
-        where: { threadId, thread: { userId } },
-      });
-
-      if (messages.length === 0) {
-        await updateThreadUpdated(threadId);
-        return;
-      }
-
       const data = messages.map((m, idx) => ({
         id: m.id ?? generateId(`msg-${idx}`),
         threadId,
@@ -96,7 +99,24 @@ export function messageStore(userId: string): MessageStore {
         createdAt: new Date(Date.now() + idx),
       })) as unknown as Prisma.ChatMessageCreateManyInput[];
 
-      await prisma.chatMessage.createMany({ data });
+      // 事务化（审计 2026-10-25 A3x-2 🟡）：deleteMany 与 createMany 两步写之间
+      // 进程崩溃 / DB 抖动会让旧消息已删、新消息未写——线程历史全失。数组形式
+      // $transaction 全或无；空消息数组只保留 delete 步骤（createMany 空数组
+      // 会被 Prisma 校验拒绝）。
+      await prisma.$transaction([
+        prisma.chatMessage.deleteMany({
+          where: { threadId, thread: { userId } },
+        }),
+        ...(messages.length > 0
+          ? [prisma.chatMessage.createMany({ data })]
+          : []),
+      ]);
+
+      if (messages.length === 0) {
+        await updateThreadUpdated(threadId);
+        return;
+      }
+
       await maybeAutoTitle(threadId, userId, messages);
       await updateThreadUpdated(threadId);
     },

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

@@ -53,10 +53,21 @@ export function metadataStore(): MetadataStore {
 
     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.
+      // valid no-op, not an error the caller has to handle. 审计 2026-10-25
+      // A3x-2 🟡：只对 P2025（记录不存在）吞错——连接失败、权限错误等必须
+      // 上抛（对比 interrupt-store 对 P2002 的精确区分），否则真实故障被
+      // 静默吞掉无从排查。
       await prisma.chatPersistenceMeta
         .delete({ where: { namespace_key: { namespace, key } } })
-        .catch(() => {});
+        .catch((err) => {
+          if (
+            err instanceof Prisma.PrismaClientKnownRequestError &&
+            err.code === "P2025"
+          ) {
+            return;
+          }
+          throw err;
+        });
     },
   });
 }

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

@@ -82,7 +82,14 @@ export function chatRunStore(userId?: string): RunStore {
     },
 
     async update(runId, patch) {
-      const row = await prisma.chatRun.findUnique({ where: { id: runId } });
+      // owning 变体补 userId 过滤（审计 2026-10-25 A3x-2 🟠）：带 userId 构造
+      // 时 update/get 必须与 findActiveRun/listByThread 同口径，否则传入他人
+      // runId 可改他人 run 状态（status/cancelRequested）。查无（不存在或属
+      // 他人）按既有「行不存在静默返回」语义处理。全局变体（reaper cron /
+      // cancel serverFn）不带 ownership，行为不变（调用方自校验契约见文件头）。
+      const row = ownership
+        ? await prisma.chatRun.findFirst({ where: { id: runId, ...ownership } })
+        : await prisma.chatRun.findUnique({ where: { id: runId } });
       if (!row) return;
 
       // 用 `'field' in patch` 而非 truthy 判断：testkit 与 reaper 用
@@ -113,7 +120,10 @@ export function chatRunStore(userId?: string): RunStore {
     },
 
     async get(runId) {
-      const row = await prisma.chatRun.findUnique({ where: { id: runId } });
+      // 同 update：owning 变体按 userId 过滤，全局变体裸 id（调用方自校验）。
+      const row = ownership
+        ? await prisma.chatRun.findFirst({ where: { id: runId, ...ownership } })
+        : await prisma.chatRun.findUnique({ where: { id: runId } });
       return row ? rowToRecord(row) : null;
     },
 
@@ -156,6 +166,18 @@ export function runStore(userId: string): RunStore {
   return chatRunStore(userId);
 }
 
+/**
+ * error 列 JSON.parse 容错（审计 2026-10-25 A3x-2 🟡）：历史非 JSON 值 / 人工
+ * 改写值会让整条 run 记录列表化失败——降级为 `{ message: raw }`（RunError 形态）。
+ */
+function parseRunError(raw: string): { message: string; code?: string } {
+  try {
+    return JSON.parse(raw) as { message: string; code?: string };
+  } catch {
+    return { message: raw };
+  }
+}
+
 function rowToRecord(row: {
   id: string;
   threadId: string;
@@ -175,7 +197,7 @@ function rowToRecord(row: {
     status: row.status as RunStatus,
     startedAt: row.startedAt.getTime(),
     ...(row.finishedAt ? { finishedAt: row.finishedAt.getTime() } : {}),
-    ...(row.error ? { error: JSON.parse(row.error) } : {}),
+    ...(row.error ? { error: parseRunError(row.error) } : {}),
     ...(row.usage ? { usage: row.usage as RunRecord["usage"] } : {}),
     ...(row.detachedSince ? { detachedSince: row.detachedSince.getTime() } : {}),
     ...(row.sandboxKey ? { sandboxKey: row.sandboxKey } : {}),

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

@@ -19,7 +19,7 @@
 // 现有散落提示词的迁移见设计文档 P2 收编映射表。
 // PROMPT_KEYS 是 PromptKey 联合类型的来源，必须与 builtin.ts 的
 // PROMPT_DEFINITIONS 保持同步——prompt-builtin.test.ts 有漂移哨兵断言。
-import "./builtin"
+// （无 side-effect 导入：builtin.ts 是纯转发层，registry.ts 已显式引用。）
 
 export { TIPTAP_ACTION_INSTRUCTIONS } from "./builtin"
 

package/src/server/ai-gateway/prompts/registry.ts

@@ -135,6 +135,28 @@ function formatNow(now = new Date()): string {
   return `${y}-${pad(m)}-${pad(d)} ${y}年${m}月${d}日`
 }
 
+/**
+ * 用户可控插值值收敛（审计 2026-10-25 A3x-2 ⚪）：userName/workspaceName 会经
+ * interpolateTemplate 嵌入本人会话的系统提示词（自注入面，影响限本人）。
+ * 收敛长度 + 折叠控制字符/换行，降低「用户名伪装成系统指令分行注入」的形态；
+ * 不做语义过滤（提示词注入的根因防线在 llm-fence / 输出护栏，不在此处）。
+ */
+const PROMPT_VAR_MAX_LEN = 100
+
+function clampPromptVar(value: string): string {
+  // 控制字符（C0 + DEL）折叠为空格：不用 \u0000-\u001f 正则类（no-control-regex），
+  // 逐码点过滤；随后把连续空白（含换行/制表）折叠为单空格并去首尾。
+  let collapsed = ""
+  for (const ch of value) {
+    const code = ch.codePointAt(0) ?? 0
+    collapsed += code < 0x20 || code === 0x7f ? " " : ch
+  }
+  collapsed = collapsed.replace(/\s+/g, " ").trim()
+  return collapsed.length > PROMPT_VAR_MAX_LEN
+    ? collapsed.slice(0, PROMPT_VAR_MAX_LEN)
+    : collapsed
+}
+
 async function resolveBuiltinVars(
   opts?: ResolvePromptOptions,
 ): Promise<Record<string, string>> {
@@ -142,7 +164,7 @@ async function resolveBuiltinVars(
     now: formatNow(),
     locale: "zh",
   }
-  if (opts?.workspaceName) vars.workspaceName = opts.workspaceName
+  if (opts?.workspaceName) vars.workspaceName = clampPromptVar(opts.workspaceName)
   if (!opts?.userId) return vars
 
   // 未提供 userId（调用方契约错误）不注入 userName：模板引用则严格抛错，
@@ -154,7 +176,7 @@ async function resolveBuiltinVars(
       where: { id: opts.userId },
       select: { username: true },
     })
-    if (user?.username) vars.userName = user.username
+    if (user?.username) vars.userName = clampPromptVar(user.username)
   } catch (e) {
     console.warn(
       `[AI] prompt userName lookup failed for userId ${opts.userId}:`,

package/src/server/ai-gateway/prompts/seed.ts

@@ -15,9 +15,8 @@
 // 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 "./builtin"
 import { listBuiltinPrompts } from "./registry"
-import { prisma, type Prisma } from "@allbluecn/database"
+import { prisma, Prisma } from "@allbluecn/database"
 
 /** Prisma Json 字段不接受强类型数组（缺 index signature），统一 cast */
 function toJson(value: unknown): Prisma.InputJsonValue {
@@ -35,16 +34,27 @@ export async function ensurePromptSeeded(): Promise<void> {
   const existingKeys = new Set(existing.map((r) => r.key))
   const missing = listBuiltinPrompts().filter((p) => !existingKeys.has(p.key))
   if (missing.length > 0) {
-    await prisma.systemPromptTemplate.createMany({
-      data: missing.map((p) => ({
-        key: p.key,
-        name: p.name,
-        description: p.description ?? null,
-        sections: toJson(p.sections),
-        variables: toJson(p.variables),
-        isProtected: p.isProtected,
-      })),
-    })
+    try {
+      await prisma.systemPromptTemplate.createMany({
+        data: missing.map((p) => ({
+          key: p.key,
+          name: p.name,
+          description: p.description ?? null,
+          sections: toJson(p.sections),
+          variables: toJson(p.variables),
+          isProtected: p.isProtected,
+        })),
+      })
+    } catch (err) {
+      // 并发 seed 竞态（审计 2026-10-25 A3x-2 🟡）：`seeded` 标志无跨请求锁，
+      // 两个进程/请求同时通过 findMany（都看到缺 key）→ 后者 createMany 撞
+      // 唯一约束。P2002 = 对端已补种，视为成功；其余错误照常上抛。
+      if (
+        !(err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2002")
+      ) {
+        throw err
+      }
+    }
   }
   seeded = true
 }

package/src/server/ai-gateway/provider-router.ts

@@ -30,6 +30,34 @@ function maskKey(key: string | null | undefined): string {
   return `${key.slice(0, 3)}…${key.slice(-4)}`
 }
 
+/**
+ * 「configs + providers 预取」单一来源（审计 2026-10-25 A3x-2 🔵：两个 resolve
+ * 函数逐行近似的 findMany×2 + Map 构建收敛此处，DB-01 优化注释改一处即两处生效）。
+ * 查询次数恒为 2（原 1+N）。
+ */
+async function loadUserProviderIndex(userId: string) {
+  const configs = await prisma.aiProviderConfig.findMany({
+    where: { userId, enabled: true },
+    orderBy: { updatedAt: "desc" },
+    select: { providerId: true, models: true, apiKey: true, baseUrl: true },
+  })
+  if (configs.length === 0) {
+    return { configs, providerById: new Map() }
+  }
+  const providers = await prisma.aiProvider.findMany({
+    where: { providerId: { in: configs.map((c) => c.providerId) } },
+    select: { providerId: true, adapterKind: true, models: true, isLocal: true },
+  })
+  return { configs, providerById: new Map(providers.map((p) => [p.providerId, p])) }
+}
+
+/** 从 provider 行取预设模型 id 列表（Json 字段容错）。 */
+function presetModelIds(models: unknown): string[] {
+  return Array.isArray(models)
+    ? (models as Array<{ id: string }>).map((m) => m.id)
+    : []
+}
+
 /**
  * 根据用户选择的 model 反查所属 enabled provider 配置。
  * LobeChat 模式：用户从合并模型列表选 model，系统路由到对应 provider。
@@ -44,30 +72,16 @@ export async function resolveAiConfigForModel(
   userId: string,
   model: string,
 ): Promise<ResolvedProviderConfig | null> {
-  // DB-01：每次 AI 调用的热路径——provider 元数据一次 findMany in 预取（原逐 config findUnique，
-  // N configs = N+1 次串行查询，且无 select 整行返回）。查询次数 before: 1+N → after: 2（常数）
-  const configs = await prisma.aiProviderConfig.findMany({
-    where: { userId, enabled: true },
-    orderBy: { updatedAt: "desc" },
-    select: { providerId: true, models: true, apiKey: true, baseUrl: true },
-  })
+  const { configs, providerById } = await loadUserProviderIndex(userId)
   if (configs.length === 0) return null
 
-  const providers = await prisma.aiProvider.findMany({
-    where: { providerId: { in: configs.map((c) => c.providerId) } },
-    select: { providerId: true, adapterKind: true, models: true, isLocal: true },
-  })
-  const providerById = new Map(providers.map((p) => [p.providerId, p]))
-
   for (const cfg of configs) {
     const provider = providerById.get(cfg.providerId)
     // admin 已删除 AiProvider：跳过（用户配置孤儿，无法路由）
     if (!provider) continue
 
     const enabledModels = Array.isArray(cfg.models) ? (cfg.models as string[]) : []
-    const presetModels = Array.isArray(provider.models)
-      ? (provider.models as Array<{ id: string }>).map((m) => m.id)
-      : []
+    const presetModels = presetModelIds(provider.models)
     const matches =
       enabledModels.includes(model) ||
       (enabledModels.length === 0 && presetModels.includes(model))
@@ -96,21 +110,9 @@ export async function resolveAiConfigForModel(
 export async function resolveDefaultProviderConfig(
   userId: string,
 ): Promise<ResolvedProviderConfig | null> {
-  // DB-01：同 resolveAiConfigForModel——provider 元数据一次 findMany in 预取 + select。
-  // 查询次数 before: 1+N → after: 2（常数）
-  const configs = await prisma.aiProviderConfig.findMany({
-    where: { userId, enabled: true },
-    orderBy: { updatedAt: "desc" },
-    select: { providerId: true, models: true, apiKey: true, baseUrl: true },
-  })
+  const { configs, providerById } = await loadUserProviderIndex(userId)
   if (configs.length === 0) return null
 
-  const providers = await prisma.aiProvider.findMany({
-    where: { providerId: { in: configs.map((c) => c.providerId) } },
-    select: { providerId: true, adapterKind: true, models: true, isLocal: true },
-  })
-  const providerById = new Map(providers.map((p) => [p.providerId, p]))
-
   for (const cfg of configs) {
     const apiKey = cfg.apiKey ? getPorts().keyCipher.decrypt(cfg.apiKey) : null
     if (!apiKey) continue
@@ -118,9 +120,7 @@ export async function resolveDefaultProviderConfig(
     if (!provider) continue
 
     const enabledModels = Array.isArray(cfg.models) ? (cfg.models as string[]) : []
-    const presetModels = Array.isArray(provider.models)
-      ? (provider.models as Array<{ id: string }>).map((m) => m.id)
-      : []
+    const presetModels = presetModelIds(provider.models)
     const model = enabledModels[0] ?? presetModels[0]
     if (!model) continue