@allbluecn/web-app 0.4.21 → 0.5.0

package/src/routes/_nav/settings/notifications/route.lazy.tsx

@@ -17,7 +17,7 @@
 
 import { createLazyFileRoute } from '@tanstack/react-router'
 import { useTranslation } from 'react-i18next'
-import { NotificationPreferences } from '@/components/notifications/notification-preferences'
+import { SettingsNotifications } from '@/components/notifications/settings-notifications'
 
 export const Route = createLazyFileRoute('/_nav/settings/notifications')({
   component: NotificationsSettingsPage,
@@ -25,13 +25,14 @@ export const Route = createLazyFileRoute('/_nav/settings/notifications')({
 
 function NotificationsSettingsPage() {
   const { t } = useTranslation('notifications')
+
   return (
     <div className="flex flex-col gap-6 p-6">
-      <div className="flex flex-col gap-1">
-        <h1 className="text-xl font-semibold">{t('preferences.title')}</h1>
-        <p className="text-sm text-muted-foreground">{t('preferences.description')}</p>
+      <div>
+        <h2 className="text-lg font-semibold">{t('settings.title')}</h2>
+        <p className="text-sm text-muted-foreground">{t('settings.description')}</p>
       </div>
-      <NotificationPreferences />
+      <SettingsNotifications />
     </div>
   )
 }

package/src/routes/api/notifications/stream.ts

@@ -21,6 +21,7 @@ import type { StreamChunk } from '@tanstack/ai'
 import { prisma } from '@allbluecn/database'
 import { getCurrentSession } from '@/lib/session'
 import { notificationBus } from '@/server/notifications/event-bus'
+import { deliverDueDigests } from '@/server/notifications/notification-service'
 import type { NotificationSseValue } from '@allbluecn/shared'
 
 export const Route = createFileRoute('/api/notifications/stream')({
@@ -60,6 +61,9 @@ export const Route = createFileRoute('/api/notifications/stream')({
               value: { kind: 'unread_snapshot', count },
             } as unknown as StreamChunk
 
+            // 连接建立时检查到期 digest 摘要（fire-and-forget，摘要经 bus 实时推送）
+            void deliverDueDigests(userId)
+
             while (!abortController.signal.aborted) {
               if (queue.length === 0) {
                 await new Promise<void>((resolve) => {

package/src/server/ai-ports.ts

@@ -26,7 +26,7 @@ import { deleteEmbeddings } from "@/lib/pgvector"
 import {
   indexDocumentEmbeddings as knowledgeIndexDocumentEmbeddings,
   resolveAiConfig as resolveKnowledgeAiConfigRaw,
-} from "@/server/serverFns/knowledge-index"
+} from "@/server/serverFns/knowledge-index-utils"
 import type { AiConfig } from "@allbluecn/ai-gateway"
 import { registerGatewayPorts, registerProServiceResolver } from "@allbluecn/ai-gateway"
 import { getProService } from "@/server/pro-services"

package/src/server/knowledge-public/github-sync.ts

@@ -36,7 +36,7 @@ const HEADERS: HeadersInit = {
 function isAllowedGitHubUrl(url: string): boolean {
   try {
     const parsed = new URL(url)
-    return ['github.com', 'www.github.com'].includes(parsed.hostname)
+    return ['github.com', 'www.github.com', 'api.github.com'].includes(parsed.hostname)
       && ['https:', 'http:'].includes(parsed.protocol)
   } catch {
     return false

package/src/server/notifications/__tests__/notification-service.test.ts

@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@allbluecn/database', () => ({
+  prisma: {
+    notificationPreference: {
+      findUnique: vi.fn(),
+      create: vi.fn(),
+    },
+    notification: {
+      create: vi.fn(),
+      findFirst: vi.fn(),
+      findMany: vi.fn(),
+      count: vi.fn(),
+    },
+  },
+  Prisma: {},
+}))
+
+vi.mock('@/server/notifications/event-bus', () => ({
+  notificationBus: {
+    emit: vi.fn(),
+    subscribe: vi.fn(),
+  },
+}))
+
+import { prisma } from '@allbluecn/database'
+import { notificationBus } from '@/server/notifications/event-bus'
+import { createNotification, deliverDueDigests } from '../notification-service'
+
+const mockedFindUnique = prisma.notificationPreference.findUnique as ReturnType<typeof vi.fn>
+const mockedCreatePref = prisma.notificationPreference.create as ReturnType<typeof vi.fn>
+const mockedNotifCreate = prisma.notification.create as ReturnType<typeof vi.fn>
+const mockedNotifFindFirst = prisma.notification.findFirst as ReturnType<typeof vi.fn>
+const mockedNotifFindMany = prisma.notification.findMany as ReturnType<typeof vi.fn>
+const mockedNotifCount = prisma.notification.count as ReturnType<typeof vi.fn>
+const mockedEmit = notificationBus.emit as ReturnType<typeof vi.fn>
+
+const realtimePrefs = {
+  userId: 'u1',
+  categories: {
+    team: 'realtime',
+    collaboration: 'realtime',
+    system: 'realtime',
+    billing: 'realtime',
+    security: 'realtime',
+  },
+  dndEnabled: false,
+  dndStart: '22:00',
+  dndEnd: '08:00',
+}
+
+const createdNotification = {
+  id: 'n1',
+  category: 'team',
+  type: 'invite',
+  title: 't',
+  body: null,
+  link: null,
+  readAt: null,
+  createdAt: new Date('2026-08-29T10:00:00Z'),
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mockedFindUnique.mockResolvedValue(realtimePrefs)
+  mockedCreatePref.mockResolvedValue(null)
+  mockedNotifCreate.mockResolvedValue(createdNotification)
+})
+
+describe('createNotification frequency 判定', () => {
+  it('off 类别完全不投递（不入库）', async () => {
+    mockedFindUnique.mockResolvedValue({
+      ...realtimePrefs,
+      categories: { ...realtimePrefs.categories, team: 'off' },
+    })
+    await createNotification({ userId: 'u1', category: 'team', type: 'invite', title: 't' })
+    expect(mockedNotifCreate).not.toHaveBeenCalled()
+    expect(mockedEmit).not.toHaveBeenCalled()
+  })
+
+  it('realtime 类别入库并实时推送', async () => {
+    await createNotification({ userId: 'u1', category: 'team', type: 'invite', title: 't' })
+    expect(mockedNotifCreate).toHaveBeenCalledTimes(1)
+    expect(mockedEmit).toHaveBeenCalledTimes(1)
+    expect(mockedEmit).toHaveBeenCalledWith('u1', {
+      kind: 'notification',
+      notification: expect.objectContaining({ id: 'n1' }),
+    })
+  })
+
+  it('digest-daily 类别仅入库不推送', async () => {
+    mockedFindUnique.mockResolvedValue({
+      ...realtimePrefs,
+      categories: { ...realtimePrefs.categories, team: 'digest-daily' },
+    })
+    await createNotification({ userId: 'u1', category: 'team', type: 'invite', title: 't' })
+    expect(mockedNotifCreate).toHaveBeenCalledTimes(1)
+    expect(mockedEmit).not.toHaveBeenCalled()
+  })
+
+  it('force 绕过 off 判定并强制推送', async () => {
+    mockedFindUnique.mockResolvedValue({
+      ...realtimePrefs,
+      categories: { ...realtimePrefs.categories, team: 'off' },
+    })
+    await createNotification({ userId: 'u1', category: 'team', type: 'digest.daily', title: 't', force: true })
+    expect(mockedNotifCreate).toHaveBeenCalledTimes(1)
+    expect(mockedEmit).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('deliverDueDigests', () => {
+  const digestPrefs = {
+    userId: 'u1',
+    categories: {
+      team: 'digest-daily',
+      collaboration: 'realtime',
+      system: 'off',
+      billing: 'digest-weekly',
+      security: 'realtime',
+    },
+    dndEnabled: false,
+    dndStart: '22:00',
+    dndEnd: '08:00',
+  }
+
+  it('到期且有积压时生成摘要并实时推送', async () => {
+    mockedFindUnique.mockResolvedValue(digestPrefs)
+    mockedNotifFindFirst.mockResolvedValue({
+      createdAt: new Date(Date.now() - 25 * 60 * 60 * 1000),
+    })
+    mockedNotifCount.mockResolvedValue(4)
+    mockedNotifFindMany.mockResolvedValue([{ title: 'a' }, { title: 'b' }, { title: 'c' }])
+    mockedNotifCreate.mockResolvedValue({ ...createdNotification, type: 'digest.daily' })
+
+    await deliverDueDigests('u1')
+
+    // team(daily) 到期生成摘要并推送；billing(weekly) 距水位线 25h < 7d 未到期
+    expect(mockedEmit).toHaveBeenCalledTimes(1)
+    const teamDigest = mockedNotifCreate.mock.calls.find(
+      (c) => c[0]?.data?.type === 'digest.daily'
+    )
+    expect(teamDigest).toBeDefined()
+    expect(teamDigest![0].data.title).toContain('今日团队协作有 4 条新通知')
+    expect(teamDigest![0].data.body).toContain('等 4 条通知')
+  })
+
+  it('未到期（24h 内已有摘要）跳过', async () => {
+    mockedFindUnique.mockResolvedValue(digestPrefs)
+    mockedNotifFindFirst.mockResolvedValue({ createdAt: new Date(Date.now() - 2 * 60 * 60 * 1000) })
+
+    await deliverDueDigests('u1')
+
+    expect(mockedNotifCount).not.toHaveBeenCalled()
+    expect(mockedNotifCreate).not.toHaveBeenCalled()
+  })
+
+  it('到期但无积压通知跳过', async () => {
+    mockedFindUnique.mockResolvedValue(digestPrefs)
+    mockedNotifFindFirst.mockResolvedValue({
+      createdAt: new Date(Date.now() - 25 * 60 * 60 * 1000),
+    })
+    mockedNotifCount.mockResolvedValue(0)
+
+    await deliverDueDigests('u1')
+
+    expect(mockedNotifCreate).not.toHaveBeenCalled()
+    expect(mockedEmit).not.toHaveBeenCalled()
+  })
+
+  it('weekly 频率 7 天内已有摘要跳过', async () => {
+    mockedFindUnique.mockResolvedValue({
+      ...digestPrefs,
+      categories: { ...digestPrefs.categories, billing: 'digest-weekly', team: 'realtime' },
+    })
+    mockedNotifFindFirst.mockResolvedValue({ createdAt: new Date(Date.now() - 6 * 24 * 60 * 60 * 1000) })
+
+    await deliverDueDigests('u1')
+
+    expect(mockedNotifCount).not.toHaveBeenCalled()
+    expect(mockedNotifCreate).not.toHaveBeenCalled()
+  })
+
+  it('无 digest 类别直接返回', async () => {
+    await deliverDueDigests('u1')
+    expect(mockedNotifFindFirst).not.toHaveBeenCalled()
+  })
+})

package/src/server/notifications/notification-service.ts

@@ -1,15 +1,19 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 import { prisma } from '@allbluecn/database'
 import type {
-  CategoryPreferences,
+  CategoryFrequencies,
   NotificationCategory,
   NotificationItem,
   NotificationPreferences,
 } from '@allbluecn/shared'
-import { isInDndWindow, DEFAULT_CATEGORIES } from '@allbluecn/shared'
+import {
+  isInDndWindow,
+  normalizeCategoryFrequencies,
+  DEFAULT_CATEGORIES,
+} from '@allbluecn/shared'
 import { notificationBus } from './event-bus'
 
-export { DEFAULT_CATEGORIES, isInDndWindow } from '@allbluecn/shared'
+export { DEFAULT_CATEGORIES, isInDndWindow, normalizeCategoryFrequencies } from '@allbluecn/shared'
 
 export interface CreateNotificationInput {
   userId: string
@@ -18,13 +22,36 @@ export interface CreateNotificationInput {
   title: string
   body?: string
   link?: string
+  /** 绕过 frequency 判定并强制实时推送（仅 digest 摘要生成使用） */
+  force?: boolean
+}
+
+/** 服务端直出的类别中文名（与 zh locale tabs 保持一致） */
+const CATEGORY_LABELS: Record<NotificationCategory, string> = {
+  team: '团队协作',
+  collaboration: '内容协作',
+  system: '系统公告',
+  billing: '账单订阅',
+  security: '安全告警',
+}
+
+const DIGEST_TYPE: Record<'digest-daily' | 'digest-weekly', string> = {
+  'digest-daily': 'digest.daily',
+  'digest-weekly': 'digest.weekly',
+}
+
+const DIGEST_MIN_INTERVAL_MS: Record<'digest-daily' | 'digest-weekly', number> = {
+  'digest-daily': 24 * 60 * 60 * 1000,
+  'digest-weekly': 7 * 24 * 60 * 60 * 1000,
 }
 
+const DIGEST_SUMMARY_ITEMS = 3
+
 export async function getOrCreatePreferences(userId: string): Promise<NotificationPreferences> {
   const existing = await prisma.notificationPreference.findUnique({ where: { userId } })
   if (existing) {
     return {
-      categories: { ...DEFAULT_CATEGORIES, ...(existing.categories as object) } as CategoryPreferences,
+      categories: normalizeCategoryFrequencies(existing.categories),
       dndEnabled: existing.dndEnabled,
       dndStart: existing.dndStart,
       dndEnd: existing.dndEnd,
@@ -52,35 +79,118 @@ export async function getOrCreatePreferences(userId: string): Promise<Notificati
   return defaults
 }
 
-/** fire-and-forget：任何失败只记日志不抛出，不阻断业务主流程 */
+async function insertNotification(
+  input: CreateNotificationInput
+): Promise<NotificationItem | null> {
+  const created = await prisma.notification.create({
+    data: {
+      userId: input.userId,
+      category: input.category,
+      type: input.type,
+      title: input.title,
+      body: input.body,
+      link: input.link,
+    },
+  })
+  return {
+    id: created.id,
+    category: created.category as NotificationCategory,
+    type: created.type,
+    title: created.title,
+    body: created.body,
+    link: created.link,
+    readAt: created.readAt ? created.readAt.toISOString() : null,
+    createdAt: created.createdAt.toISOString(),
+  }
+}
+
+/**
+ * fire-and-forget：任何失败只记日志不抛出，不阻断业务主流程。
+ * frequency 判定：off 不投递；realtime 入库 + 实时推送；digest-* 仅入库（由 deliverDueDigests 汇总推送）。
+ */
 export async function createNotification(input: CreateNotificationInput): Promise<void> {
   try {
     const prefs = await getOrCreatePreferences(input.userId)
-    if (!prefs.categories[input.category]) return
+    const frequency = prefs.categories[input.category]
+    if (!input.force && frequency === 'off') return
 
-    const created = await prisma.notification.create({
-      data: {
-        userId: input.userId,
-        category: input.category,
-        type: input.type,
-        title: input.title,
-        body: input.body,
-        link: input.link,
-      },
-    })
+    const item = await insertNotification(input)
+    if (!item) return
 
-    const item: NotificationItem = {
-      id: created.id,
-      category: created.category as NotificationCategory,
-      type: created.type,
-      title: created.title,
-      body: created.body,
-      link: created.link,
-      readAt: created.readAt ? created.readAt.toISOString() : null,
-      createdAt: created.createdAt.toISOString(),
+    if (input.force || frequency === 'realtime') {
+      notificationBus.emit(input.userId, { kind: 'notification', notification: item })
     }
-    notificationBus.emit(input.userId, { kind: 'notification', notification: item })
   } catch (e) {
     console.error('[notifications] create failed:', e instanceof Error ? e.message : 'unknown')
   }
-}
+}
+
+function formatDigestBody(titles: string[], total: number): string {
+  const lines = titles.slice(0, DIGEST_SUMMARY_ITEMS).map((t) => `· ${t}`)
+  if (total > DIGEST_SUMMARY_ITEMS) {
+    lines.push(`等 ${total} 条通知`)
+  }
+  return lines.join('\n')
+}
+
+/**
+ * 检查并投递到期的 digest（摘要）通知。在用户建立 SSE 连接时调用（fire-and-forget）：
+ * 以同类别最近一条同频率摘要的 createdAt 为水位线，积压通知数 > 0 且距上次摘要超过
+ * 频率周期时，按类别生成一条摘要通知并实时推送。
+ */
+export async function deliverDueDigests(userId: string): Promise<void> {
+  try {
+    const prefs = await getOrCreatePreferences(userId)
+    const digestCats = (Object.keys(prefs.categories) as NotificationCategory[]).filter(
+      (c) => prefs.categories[c] === 'digest-daily' || prefs.categories[c] === 'digest-weekly'
+    )
+    for (const category of digestCats) {
+      const frequency = prefs.categories[category] as 'digest-daily' | 'digest-weekly'
+      const type = DIGEST_TYPE[frequency]
+
+      const lastDigest = await prisma.notification.findFirst({
+        where: { userId, category, type },
+        orderBy: { createdAt: 'desc' },
+        select: { createdAt: true },
+      })
+      if (lastDigest && Date.now() - lastDigest.createdAt.getTime() < DIGEST_MIN_INTERVAL_MS[frequency]) {
+        continue
+      }
+
+      const since = lastDigest?.createdAt ?? new Date(0)
+      const pendingCount = await prisma.notification.count({
+        where: {
+          userId,
+          category,
+          type: { not: { startsWith: 'digest.' } },
+          createdAt: { gt: since },
+        },
+      })
+      if (pendingCount === 0) continue
+
+      const pending = await prisma.notification.findMany({
+        where: {
+          userId,
+          category,
+          type: { not: { startsWith: 'digest.' } },
+          createdAt: { gt: since },
+        },
+        orderBy: { createdAt: 'desc' },
+        select: { title: true },
+        take: DIGEST_SUMMARY_ITEMS,
+      })
+
+      const periodLabel = frequency === 'digest-daily' ? '今日' : '本周'
+      await createNotification({
+        userId,
+        category,
+        type,
+        title: `${periodLabel}${CATEGORY_LABELS[category]}有 ${pendingCount} 条新通知`,
+        body: formatDigestBody(pending.map((n) => n.title), pendingCount),
+        force: true,
+      })
+    }
+  } catch (e) {
+    console.error('[notifications] digest failed:', e instanceof Error ? e.message : 'unknown')
+  }
+}

package/src/server/serverFns/__tests__/knowledge-index.test.ts

@@ -0,0 +1,178 @@
+// 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, vi, beforeEach } from 'vitest'
+
+vi.mock('@tanstack/react-start', () => ({
+  createServerFn: (config: any) => {
+    const api: any = {
+      _validator: undefined,
+      validator(schema: any) {
+        this._validator = schema
+        return this
+      },
+      handler(fn: Function) {
+        return async (args: any) => fn({ data: args?.data })
+      },
+    }
+    return api
+  },
+}))
+
+vi.mock('@tanstack/react-start/server', () => ({
+  getRequest: vi.fn(),
+}))
+
+const m = vi.hoisted(() => ({
+  knowledgeBase: { findUnique: vi.fn(), findFirst: vi.fn() },
+  user: { findUnique: vi.fn() },
+  aiProvider: { findUnique: vi.fn() },
+  resolveDefaultProviderConfig: vi.fn(),
+}))
+
+vi.mock('@allbluecn/database', () => ({
+  prisma: {
+    knowledgeBase: m.knowledgeBase,
+    knowledgeDocument: { findMany: vi.fn() },
+    user: m.user,
+    aiProvider: m.aiProvider,
+  },
+}))
+
+vi.mock('@allbluecn/ai-gateway', () => ({
+  generateEmbedding: vi.fn(),
+  chunkText: vi.fn((t: string) => [t]),
+  resolveDefaultProviderConfig: (...args: unknown[]) => m.resolveDefaultProviderConfig(...args),
+}))
+
+vi.mock('@/server/auth-helpers', () => ({
+  requireAuth: vi.fn(),
+}))
+
+vi.mock('@/lib/pgvector', () => ({
+  insertEmbedding: vi.fn(),
+  deleteEmbeddings: vi.fn(),
+}))
+
+import { extractText, resolveAiConfig } from '../knowledge-index-utils'
+
+const KB = { id: 'kb-1', userId: 'user-1' }
+
+describe('resolveAiConfig', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    m.knowledgeBase.findUnique.mockResolvedValue(KB)
+    m.aiProvider.findUnique.mockResolvedValue(null)
+    m.resolveDefaultProviderConfig.mockResolvedValue(null)
+    m.user.findUnique.mockResolvedValue(null)
+  })
+
+  it('新表配置优先：adapterKind 支持 embedding 且 baseUrl 为空时补 AiProvider.defaultBaseUrl', async () => {
+    m.resolveDefaultProviderConfig.mockResolvedValue({
+      providerId: 'openrouter',
+      adapterKind: 'openrouter',
+      apiKey: 'sk-or-user-key',
+      baseUrl: null,
+      model: 'openai/gpt-4o-mini',
+    })
+    m.aiProvider.findUnique.mockResolvedValue({
+      defaultBaseUrl: 'https://openrouter.ai/api/v1',
+    })
+
+    await expect(resolveAiConfig('kb-1')).resolves.toEqual({
+      apiKey: 'sk-or-user-key',
+      baseUrl: 'https://openrouter.ai/api/v1',
+    })
+  })
+
+  it('新表配置的 baseUrl 非空时直接采用，不回落 defaultBaseUrl', async () => {
+    m.resolveDefaultProviderConfig.mockResolvedValue({
+      providerId: 'openai',
+      adapterKind: 'openai',
+      apiKey: 'sk-user-key',
+      baseUrl: 'https://my-proxy.example.com/v1',
+      model: 'gpt-4o',
+    })
+    m.aiProvider.findUnique.mockResolvedValue({
+      defaultBaseUrl: 'https://api.openai.com/v1',
+    })
+
+    await expect(resolveAiConfig('kb-1')).resolves.toEqual({
+      apiKey: 'sk-user-key',
+      baseUrl: 'https://my-proxy.example.com/v1',
+    })
+  })
+
+  it('adapterKind 不支持 embedding 时回落到旧 User.aiApiKey', async () => {
+    m.resolveDefaultProviderConfig.mockResolvedValue({
+      providerId: 'anthropic',
+      adapterKind: 'anthropic',
+      apiKey: 'sk-ant-user-key',
+      baseUrl: 'https://api.anthropic.com',
+      model: 'claude-sonnet-4-5',
+    })
+    m.user.findUnique.mockResolvedValue({
+      aiApiKey: 'sk-or-legacy',
+      aiProvider: 'openrouter',
+    })
+
+    await expect(resolveAiConfig('kb-1')).resolves.toEqual({
+      apiKey: 'sk-or-legacy',
+      baseUrl: 'https://openrouter.ai/api/v1',
+    })
+  })
+
+  it('新表无配置且旧字段有效（openrouter）时补 OpenRouter 端点', async () => {
+    m.user.findUnique.mockResolvedValue({
+      aiApiKey: 'sk-or-legacy',
+      aiProvider: 'openrouter',
+    })
+
+    await expect(resolveAiConfig('kb-1')).resolves.toEqual({
+      apiKey: 'sk-or-legacy',
+      baseUrl: 'https://openrouter.ai/api/v1',
+    })
+  })
+
+  it('旧字段是占位符时返回空对象（交给 generateEmbedding 走 env 兜底）', async () => {
+    m.user.findUnique.mockResolvedValue({
+      aiApiKey: 'sk-or-your-api-key-here',
+      aiProvider: 'openrouter',
+    })
+
+    await expect(resolveAiConfig('kb-1')).resolves.toEqual({})
+    // 新表无有效配置 → 旧字段是占位符 → 不再查 AiProvider 补端点
+    expect(m.aiProvider.findUnique).not.toHaveBeenCalled()
+  })
+
+  it('知识库不存在时返回空对象且不查询任何配置', async () => {
+    m.knowledgeBase.findUnique.mockResolvedValue(null)
+
+    await expect(resolveAiConfig('missing')).resolves.toEqual({})
+    expect(m.resolveDefaultProviderConfig).not.toHaveBeenCalled()
+    expect(m.user.findUnique).not.toHaveBeenCalled()
+  })
+})
+
+describe('extractText', () => {
+  it('优先返回 markdown，其次剥离 html 标签', () => {
+    expect(extractText({ markdown: '# 标题' })).toBe('# 标题')
+    expect(extractText({ html: '<p>正文</p>' })).toBe('正文')
+    expect(extractText({})).toBe('')
+    expect(extractText(null)).toBe('')
+  })
+})