mirror of
https://github.com/hicccc77/WeFlow.git
synced 2026-05-24 07:36:46 +00:00
802 lines
28 KiB
TypeScript
802 lines
28 KiB
TypeScript
import https from 'https'
|
||
import http from 'http'
|
||
import { URL } from 'url'
|
||
import groupSummaryPrompt from '../../shared/groupSummaryPrompt.json'
|
||
import { ConfigService } from './config'
|
||
import { chatService, type Message } from './chatService'
|
||
import { wcdbService } from './wcdbService'
|
||
import {
|
||
groupSummaryRecordService,
|
||
type GroupSummaryLog,
|
||
type GroupSummaryRecord,
|
||
type GroupSummaryRecordFilters,
|
||
type GroupSummaryRecordListResult,
|
||
type GroupSummaryRecordSummary,
|
||
type GroupSummaryTopic,
|
||
type GroupSummaryTriggerType
|
||
} from './groupSummaryRecordService'
|
||
|
||
const API_TIMEOUT_MS = 90_000
|
||
const API_TEMPERATURE = 0.4
|
||
const MIN_SUMMARY_MESSAGES = 5
|
||
const MAX_MANUAL_RANGE_SECONDS = 48 * 60 * 60
|
||
const MAX_MESSAGES_PER_SUMMARY = 3000
|
||
const SUMMARY_CURSOR_BATCH_SIZE = 360
|
||
const DEFAULT_GROUP_SUMMARY_SYSTEM_PROMPT = String(groupSummaryPrompt.defaultSystemPrompt || '').trim()
|
||
const SUMMARY_CONFIG_KEYS = new Set([
|
||
'aiGroupSummaryEnabled',
|
||
'aiGroupSummaryIntervalHours',
|
||
'aiGroupSummarySystemPrompt',
|
||
'aiGroupSummaryFilterMode',
|
||
'aiGroupSummaryFilterList',
|
||
'aiModelApiBaseUrl',
|
||
'aiModelApiKey',
|
||
'aiModelApiModel',
|
||
'aiInsightApiBaseUrl',
|
||
'aiInsightApiKey',
|
||
'aiInsightApiModel',
|
||
'dbPath',
|
||
'decryptKey',
|
||
'myWxid'
|
||
])
|
||
|
||
interface SharedAiModelConfig {
|
||
apiBaseUrl: string
|
||
apiKey: string
|
||
model: string
|
||
}
|
||
|
||
interface GroupSummaryTriggerResult {
|
||
success: boolean
|
||
message: string
|
||
recordId?: string
|
||
record?: GroupSummaryRecordSummary
|
||
skipped?: boolean
|
||
skippedReason?: string
|
||
}
|
||
|
||
interface GroupSummaryDayTriggerResult {
|
||
success: boolean
|
||
message: string
|
||
generated: number
|
||
skipped: number
|
||
records: GroupSummaryRecordSummary[]
|
||
}
|
||
|
||
class ApiRequestError extends Error {
|
||
statusCode?: number
|
||
responseBody?: string
|
||
|
||
constructor(message: string, statusCode?: number, responseBody?: string) {
|
||
super(message)
|
||
this.name = 'ApiRequestError'
|
||
this.statusCode = statusCode
|
||
this.responseBody = responseBody
|
||
}
|
||
}
|
||
|
||
function buildApiUrl(baseUrl: string, path: string): string {
|
||
const base = baseUrl.replace(/\/+$/, '')
|
||
const suffix = path.startsWith('/') ? path : `/${path}`
|
||
return `${base}${suffix}`
|
||
}
|
||
|
||
function normalizeSessionIdList(value: unknown): string[] {
|
||
if (!Array.isArray(value)) return []
|
||
return Array.from(new Set(value.map((item) => String(item || '').trim()).filter(Boolean)))
|
||
}
|
||
|
||
function normalizeIntervalHours(value: unknown): number {
|
||
const allowed = new Set([1, 2, 4, 8, 12, 24])
|
||
const numeric = Math.floor(Number(value) || 4)
|
||
return allowed.has(numeric) ? numeric : 4
|
||
}
|
||
|
||
function getStartOfDaySeconds(date: Date = new Date()): number {
|
||
const next = new Date(date)
|
||
next.setHours(0, 0, 0, 0)
|
||
return Math.floor(next.getTime() / 1000)
|
||
}
|
||
|
||
function clampText(value: unknown, maxLength: number): string {
|
||
const text = String(value || '').replace(/\s+/g, ' ').trim()
|
||
if (text.length <= maxLength) return text
|
||
return `${text.slice(0, Math.max(0, maxLength - 1))}…`
|
||
}
|
||
|
||
function stripJsonFence(value: string): string {
|
||
const text = String(value || '').trim()
|
||
const fenced = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)
|
||
if (fenced) return fenced[1].trim()
|
||
const firstBrace = text.indexOf('{')
|
||
const lastBrace = text.lastIndexOf('}')
|
||
if (firstBrace >= 0 && lastBrace > firstBrace) {
|
||
return text.slice(firstBrace, lastBrace + 1).trim()
|
||
}
|
||
return text
|
||
}
|
||
|
||
function shouldFallbackJsonMode(error: unknown): boolean {
|
||
const statusCode = (error as ApiRequestError)?.statusCode
|
||
if (statusCode === 400 || statusCode === 404 || statusCode === 422) return true
|
||
const text = `${(error as Error)?.message || ''}\n${(error as ApiRequestError)?.responseBody || ''}`.toLowerCase()
|
||
return text.includes('response_format') || text.includes('json_object') || text.includes('json mode')
|
||
}
|
||
|
||
function formatTimestamp(createTime: number): string {
|
||
const ms = createTime > 1_000_000_000_000 ? createTime : createTime * 1000
|
||
const date = new Date(ms)
|
||
const year = date.getFullYear()
|
||
const month = String(date.getMonth() + 1).padStart(2, '0')
|
||
const day = String(date.getDate()).padStart(2, '0')
|
||
const hours = String(date.getHours()).padStart(2, '0')
|
||
const minutes = String(date.getMinutes()).padStart(2, '0')
|
||
const seconds = String(date.getSeconds()).padStart(2, '0')
|
||
return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`
|
||
}
|
||
|
||
function callChatCompletions(
|
||
apiBaseUrl: string,
|
||
apiKey: string,
|
||
model: string,
|
||
messages: Array<{ role: string; content: string }>,
|
||
options?: { responseFormatJson?: boolean }
|
||
): Promise<string> {
|
||
return new Promise((resolve, reject) => {
|
||
const endpoint = buildApiUrl(apiBaseUrl, '/chat/completions')
|
||
let urlObj: URL
|
||
try {
|
||
urlObj = new URL(endpoint)
|
||
} catch {
|
||
reject(new Error(`无效的 API URL: ${endpoint}`))
|
||
return
|
||
}
|
||
|
||
const payload: Record<string, unknown> = {
|
||
model,
|
||
messages,
|
||
temperature: API_TEMPERATURE,
|
||
stream: false
|
||
}
|
||
if (options?.responseFormatJson) {
|
||
payload.response_format = { type: 'json_object' }
|
||
}
|
||
|
||
const body = JSON.stringify(payload)
|
||
const requestOptions = {
|
||
hostname: urlObj.hostname,
|
||
port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
|
||
path: urlObj.pathname + urlObj.search,
|
||
method: 'POST' as const,
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
'Content-Length': Buffer.byteLength(body).toString(),
|
||
Authorization: `Bearer ${apiKey}`
|
||
}
|
||
}
|
||
|
||
const requestFn = urlObj.protocol === 'https:' ? https.request : http.request
|
||
const req = requestFn(requestOptions, (res) => {
|
||
let data = ''
|
||
res.on('data', (chunk) => { data += chunk })
|
||
res.on('end', () => {
|
||
try {
|
||
if (res.statusCode && res.statusCode >= 400) {
|
||
reject(new ApiRequestError(`API 请求失败 (${res.statusCode}): ${data.slice(0, 200)}`, res.statusCode, data))
|
||
return
|
||
}
|
||
const parsed = JSON.parse(data)
|
||
const content = parsed?.choices?.[0]?.message?.content
|
||
if (typeof content === 'string' && content.trim()) {
|
||
resolve(content.trim())
|
||
} else {
|
||
reject(new Error(`API 返回格式异常: ${data.slice(0, 200)}`))
|
||
}
|
||
} catch {
|
||
reject(new Error(`JSON 解析失败: ${data.slice(0, 200)}`))
|
||
}
|
||
})
|
||
})
|
||
|
||
req.setTimeout(API_TIMEOUT_MS, () => {
|
||
req.destroy()
|
||
reject(new Error('API 请求超时'))
|
||
})
|
||
req.on('error', reject)
|
||
req.write(body)
|
||
req.end()
|
||
})
|
||
}
|
||
|
||
function parseTopics(rawOutput: string): GroupSummaryTopic[] {
|
||
const parsed = JSON.parse(stripJsonFence(rawOutput)) as unknown
|
||
if (!parsed || typeof parsed !== 'object') {
|
||
throw new Error('模型输出格式异常：JSON 根节点不是对象')
|
||
}
|
||
const source = parsed as Record<string, unknown>
|
||
const rawTopics = Array.isArray(source.topics) ? source.topics : []
|
||
const topics = rawTopics.map((item, index) => {
|
||
const topic = item && typeof item === 'object' ? item as Record<string, unknown> : {}
|
||
const participantsRaw = Array.isArray(topic.participants) ? topic.participants : []
|
||
const keyPointsRaw = Array.isArray(topic.key_points)
|
||
? topic.key_points
|
||
: (Array.isArray(topic.keyPoints) ? topic.keyPoints : [])
|
||
return {
|
||
title: clampText(topic.title || `话题 ${index + 1}`, 48) || `话题 ${index + 1}`,
|
||
participants: participantsRaw.map((value) => clampText(value, 24)).filter(Boolean).slice(0, 12),
|
||
keyPoints: keyPointsRaw.map((value) => clampText(value, 120)).filter(Boolean).slice(0, 8),
|
||
conclusion: clampText(topic.conclusion, 180) || '无明确结论'
|
||
}
|
||
}).filter((topic) => topic.title || topic.keyPoints.length > 0 || topic.conclusion)
|
||
|
||
if (topics.length === 0) {
|
||
throw new Error('模型输出格式异常：topics 为空')
|
||
}
|
||
return topics
|
||
}
|
||
|
||
function buildSummaryText(topics: GroupSummaryTopic[]): string {
|
||
return topics.map((topic) => {
|
||
const participants = topic.participants.length > 0 ? topic.participants.join('、') : '未明确'
|
||
const keyPoints = topic.keyPoints.length > 0 ? topic.keyPoints.join('；') : '无'
|
||
return `【${topic.title}】参与者：${participants}。关键/矛盾点：${keyPoints}。结论：${topic.conclusion}`
|
||
}).join('\n')
|
||
}
|
||
|
||
function fallbackTopicFromRaw(rawOutput: string): GroupSummaryTopic {
|
||
return {
|
||
title: '未归类总结',
|
||
participants: [],
|
||
keyPoints: [clampText(rawOutput, 500)],
|
||
conclusion: '模型未按固定 JSON 格式返回，请查看完整日志。'
|
||
}
|
||
}
|
||
|
||
class GroupSummaryService {
|
||
private config: ConfigService
|
||
private started = false
|
||
private scanTimer: NodeJS.Timeout | null = null
|
||
private processing = false
|
||
private pendingAutoRun = false
|
||
private dbConnected = false
|
||
|
||
constructor() {
|
||
this.config = ConfigService.getInstance()
|
||
}
|
||
|
||
start(): void {
|
||
if (this.started) return
|
||
this.started = true
|
||
void this.refreshConfiguration('startup')
|
||
}
|
||
|
||
stop(): void {
|
||
this.started = false
|
||
this.clearTimers()
|
||
this.processing = false
|
||
this.pendingAutoRun = false
|
||
this.dbConnected = false
|
||
}
|
||
|
||
async handleConfigChanged(key: string): Promise<void> {
|
||
const normalizedKey = String(key || '').trim()
|
||
if (!SUMMARY_CONFIG_KEYS.has(normalizedKey)) return
|
||
if (normalizedKey === 'aiGroupSummarySystemPrompt') return
|
||
if (normalizedKey === 'dbPath' || normalizedKey === 'decryptKey' || normalizedKey === 'myWxid') {
|
||
this.dbConnected = false
|
||
groupSummaryRecordService.clearRuntimeCache()
|
||
}
|
||
await this.refreshConfiguration(`config:${normalizedKey}`)
|
||
}
|
||
|
||
handleConfigCleared(): void {
|
||
this.clearTimers()
|
||
this.processing = false
|
||
this.pendingAutoRun = false
|
||
this.dbConnected = false
|
||
groupSummaryRecordService.clearRuntimeCache()
|
||
}
|
||
|
||
listRecords(filters?: GroupSummaryRecordFilters): GroupSummaryRecordListResult {
|
||
return groupSummaryRecordService.listRecords(filters || {})
|
||
}
|
||
|
||
getRecord(id: string): { success: boolean; record?: GroupSummaryRecord; error?: string } {
|
||
return groupSummaryRecordService.getRecord(id)
|
||
}
|
||
|
||
async triggerManual(params: {
|
||
sessionId: string
|
||
displayName?: string
|
||
avatarUrl?: string
|
||
startTime: number
|
||
endTime: number
|
||
}): Promise<GroupSummaryTriggerResult> {
|
||
if (!this.isEnabled()) {
|
||
return { success: false, message: '请先在设置中开启「AI 群聊总结」' }
|
||
}
|
||
const sessionId = String(params?.sessionId || '').trim()
|
||
if (!sessionId.endsWith('@chatroom')) {
|
||
return { success: false, message: 'AI 群聊总结仅支持群聊' }
|
||
}
|
||
const startTime = this.normalizeTimestampSeconds(params?.startTime)
|
||
const endTime = this.normalizeTimestampSeconds(params?.endTime)
|
||
if (startTime <= 0 || endTime <= startTime) {
|
||
return { success: false, message: '请选择有效的总结时段' }
|
||
}
|
||
if (endTime - startTime > MAX_MANUAL_RANGE_SECONDS) {
|
||
return { success: false, message: '手动总结时段不能超过 48 小时' }
|
||
}
|
||
|
||
const displayName = String(params?.displayName || sessionId).trim() || sessionId
|
||
const avatarUrl = String(params?.avatarUrl || '').trim() || undefined
|
||
return this.generateSummaryForPeriod({
|
||
sessionId,
|
||
displayName,
|
||
avatarUrl,
|
||
periodStart: startTime,
|
||
periodEnd: endTime,
|
||
triggerType: 'manual'
|
||
})
|
||
}
|
||
|
||
async triggerDay(params: {
|
||
sessionId: string
|
||
displayName?: string
|
||
avatarUrl?: string
|
||
date: string
|
||
}): Promise<GroupSummaryDayTriggerResult> {
|
||
if (!this.isEnabled()) {
|
||
return { success: false, message: '请先在设置中开启「AI 群聊总结」', generated: 0, skipped: 0, records: [] }
|
||
}
|
||
const sessionId = String(params?.sessionId || '').trim()
|
||
if (!sessionId.endsWith('@chatroom')) {
|
||
return { success: false, message: 'AI 群聊总结仅支持群聊', generated: 0, skipped: 0, records: [] }
|
||
}
|
||
const dayRange = this.parseLocalDateDayRange(params?.date)
|
||
if (!dayRange) {
|
||
return { success: false, message: '请选择有效日期', generated: 0, skipped: 0, records: [] }
|
||
}
|
||
const todayStart = getStartOfDaySeconds(new Date())
|
||
if (dayRange.start > todayStart) {
|
||
return { success: false, message: '不能总结未来日期', generated: 0, skipped: 0, records: [] }
|
||
}
|
||
|
||
const now = Math.floor(Date.now() / 1000)
|
||
const effectiveEnd = dayRange.start === todayStart ? Math.min(dayRange.end, now) : dayRange.end
|
||
const periods = this.getIntervalPeriods(dayRange.start, effectiveEnd, false)
|
||
if (periods.length === 0) {
|
||
return { success: true, message: '当前日期暂无已完成的总结时段', generated: 0, skipped: 0, records: [] }
|
||
}
|
||
|
||
const displayName = String(params?.displayName || sessionId).trim() || sessionId
|
||
const avatarUrl = String(params?.avatarUrl || '').trim() || undefined
|
||
return this.generateSummariesForPeriods({
|
||
sessionId,
|
||
displayName,
|
||
avatarUrl,
|
||
periods,
|
||
triggerType: 'manual'
|
||
})
|
||
}
|
||
|
||
private async refreshConfiguration(_reason: string): Promise<void> {
|
||
if (!this.started) return
|
||
this.clearTimers()
|
||
if (!this.isEnabled()) return
|
||
await this.queueDueAutoSummaries()
|
||
this.scheduleNextAutoRun()
|
||
}
|
||
|
||
private isEnabled(): boolean {
|
||
return this.config.get('aiGroupSummaryEnabled') === true
|
||
}
|
||
|
||
private clearTimers(): void {
|
||
if (this.scanTimer !== null) {
|
||
clearTimeout(this.scanTimer)
|
||
this.scanTimer = null
|
||
}
|
||
}
|
||
|
||
private scheduleNextAutoRun(): void {
|
||
if (!this.started || !this.isEnabled()) return
|
||
const intervalHours = normalizeIntervalHours(this.config.get('aiGroupSummaryIntervalHours'))
|
||
const now = Math.floor(Date.now() / 1000)
|
||
const dayStart = getStartOfDaySeconds(new Date())
|
||
const intervalSeconds = intervalHours * 60 * 60
|
||
const elapsed = Math.max(0, now - dayStart)
|
||
const nextBoundary = dayStart + (Math.floor(elapsed / intervalSeconds) + 1) * intervalSeconds
|
||
const delayMs = Math.max(1_000, (nextBoundary - now) * 1000 + 1_000)
|
||
|
||
this.scanTimer = setTimeout(async () => {
|
||
this.scanTimer = null
|
||
await this.queueDueAutoSummaries()
|
||
this.scheduleNextAutoRun()
|
||
}, delayMs)
|
||
}
|
||
|
||
private async ensureConnected(): Promise<boolean> {
|
||
if (this.dbConnected) return true
|
||
const result = await chatService.connect()
|
||
this.dbConnected = result.success === true
|
||
return this.dbConnected
|
||
}
|
||
|
||
private getSharedAiModelConfig(): SharedAiModelConfig {
|
||
const apiBaseUrl = String(
|
||
this.config.get('aiModelApiBaseUrl')
|
||
|| this.config.get('aiInsightApiBaseUrl')
|
||
|| ''
|
||
).trim()
|
||
const apiKey = String(
|
||
this.config.get('aiModelApiKey')
|
||
|| this.config.get('aiInsightApiKey')
|
||
|| ''
|
||
).trim()
|
||
const model = String(
|
||
this.config.get('aiModelApiModel')
|
||
|| this.config.get('aiInsightApiModel')
|
||
|| 'gpt-4o-mini'
|
||
).trim() || 'gpt-4o-mini'
|
||
return { apiBaseUrl, apiKey, model }
|
||
}
|
||
|
||
private getAutoScopeSessionIds(): string[] {
|
||
return normalizeSessionIdList(this.config.get('aiGroupSummaryFilterList'))
|
||
.filter((sessionId) => sessionId.endsWith('@chatroom'))
|
||
}
|
||
|
||
private normalizeTimestampSeconds(value: unknown): number {
|
||
const numeric = Number(value || 0)
|
||
if (!Number.isFinite(numeric) || numeric <= 0) return 0
|
||
let normalized = Math.floor(numeric)
|
||
while (normalized > 10000000000) {
|
||
normalized = Math.floor(normalized / 1000)
|
||
}
|
||
return normalized
|
||
}
|
||
|
||
private parseLocalDateDayRange(value: unknown): { start: number; end: number } | null {
|
||
const text = String(value || '').trim()
|
||
const match = text.match(/^(\d{4})-(\d{2})-(\d{2})$/)
|
||
if (!match) return null
|
||
const year = Number(match[1])
|
||
const month = Number(match[2])
|
||
const day = Number(match[3])
|
||
const start = new Date(year, month - 1, day, 0, 0, 0, 0)
|
||
if (
|
||
!Number.isFinite(start.getTime()) ||
|
||
start.getFullYear() !== year ||
|
||
start.getMonth() !== month - 1 ||
|
||
start.getDate() !== day
|
||
) {
|
||
return null
|
||
}
|
||
const end = new Date(start)
|
||
end.setDate(end.getDate() + 1)
|
||
return {
|
||
start: Math.floor(start.getTime() / 1000),
|
||
end: Math.floor(end.getTime() / 1000)
|
||
}
|
||
}
|
||
|
||
private getIntervalPeriods(startTime: number, endTime: number, includePartial: boolean): Array<{ start: number; end: number }> {
|
||
const intervalHours = normalizeIntervalHours(this.config.get('aiGroupSummaryIntervalHours'))
|
||
const intervalSeconds = intervalHours * 60 * 60
|
||
const periods: Array<{ start: number; end: number }> = []
|
||
for (let start = startTime; start < endTime; start += intervalSeconds) {
|
||
const end = Math.min(start + intervalSeconds, endTime)
|
||
if (!includePartial && end - start < intervalSeconds) continue
|
||
if (end > start) periods.push({ start, end })
|
||
}
|
||
return periods
|
||
}
|
||
|
||
private getCompletedPeriodsToday(): Array<{ start: number; end: number }> {
|
||
const dayStart = getStartOfDaySeconds(new Date())
|
||
const now = Math.floor(Date.now() / 1000)
|
||
return this.getIntervalPeriods(dayStart, now, false)
|
||
}
|
||
|
||
private async queueDueAutoSummaries(): Promise<void> {
|
||
if (!this.started || !this.isEnabled()) return
|
||
if (this.processing) {
|
||
this.pendingAutoRun = true
|
||
return
|
||
}
|
||
this.processing = true
|
||
try {
|
||
do {
|
||
this.pendingAutoRun = false
|
||
await this.runDueAutoSummariesOnce()
|
||
} while (this.pendingAutoRun && this.started && this.isEnabled())
|
||
} finally {
|
||
this.processing = false
|
||
}
|
||
}
|
||
|
||
private async runDueAutoSummariesOnce(): Promise<void> {
|
||
if (!this.started || !this.isEnabled()) return
|
||
try {
|
||
const { apiBaseUrl, apiKey } = this.getSharedAiModelConfig()
|
||
if (!apiBaseUrl || !apiKey) return
|
||
const scopeSessionIds = this.getAutoScopeSessionIds()
|
||
if (scopeSessionIds.length === 0) return
|
||
if (!await this.ensureConnected()) return
|
||
|
||
const contacts = (await chatService.enrichSessionsContactInfo(scopeSessionIds).catch(() => null))?.contacts || {}
|
||
|
||
const periods = this.getCompletedPeriodsToday()
|
||
for (const period of periods) {
|
||
for (const sessionId of scopeSessionIds) {
|
||
if (!this.started || !this.isEnabled()) return
|
||
if (!sessionId) continue
|
||
if (groupSummaryRecordService.hasAutoRecord(sessionId, period.start, period.end)) continue
|
||
await this.generateSummaryForPeriod({
|
||
sessionId,
|
||
displayName: contacts[sessionId]?.displayName || sessionId,
|
||
avatarUrl: contacts[sessionId]?.avatarUrl,
|
||
periodStart: period.start,
|
||
periodEnd: period.end,
|
||
triggerType: 'auto'
|
||
})
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.warn('[GroupSummaryService] 自动总结失败:', error)
|
||
}
|
||
}
|
||
|
||
private async readMessagesInPeriod(sessionId: string, startTime: number, endTime: number): Promise<Message[]> {
|
||
if (!await this.ensureConnected()) {
|
||
throw new Error('数据库连接失败，请先在“数据库连接”页完成配置')
|
||
}
|
||
const cursorResult = await wcdbService.openMessageCursorLite(
|
||
sessionId,
|
||
SUMMARY_CURSOR_BATCH_SIZE,
|
||
true,
|
||
startTime,
|
||
endTime
|
||
)
|
||
if (!cursorResult.success || !cursorResult.cursor) {
|
||
throw new Error(cursorResult.error || '打开消息游标失败')
|
||
}
|
||
|
||
const cursor = cursorResult.cursor
|
||
const messages: Message[] = []
|
||
try {
|
||
let hasMore = true
|
||
while (hasMore && messages.length < MAX_MESSAGES_PER_SUMMARY) {
|
||
const batch = await wcdbService.fetchMessageBatch(cursor)
|
||
if (!batch.success) {
|
||
throw new Error(batch.error || '读取消息失败')
|
||
}
|
||
hasMore = batch.hasMore === true
|
||
const rows = Array.isArray(batch.rows) ? batch.rows as Record<string, any>[] : []
|
||
if (rows.length === 0) {
|
||
if (!hasMore) break
|
||
continue
|
||
}
|
||
const mapped = chatService.mapRowsToMessagesForApi(rows, sessionId)
|
||
for (const message of mapped) {
|
||
const createTime = Number(message.createTime || 0)
|
||
if (createTime < startTime || createTime > endTime) continue
|
||
messages.push(message)
|
||
if (messages.length >= MAX_MESSAGES_PER_SUMMARY) break
|
||
}
|
||
}
|
||
} finally {
|
||
await wcdbService.closeMessageCursor(cursor).catch(() => {})
|
||
}
|
||
|
||
return messages.sort((a, b) => {
|
||
if (a.createTime !== b.createTime) return a.createTime - b.createTime
|
||
if (a.sortSeq !== b.sortSeq) return a.sortSeq - b.sortSeq
|
||
return a.localId - b.localId
|
||
})
|
||
}
|
||
|
||
private normalizeMessageText(message: Message): string {
|
||
const parsedContent = String(message.parsedContent || '').replace(/\s+/g, ' ').trim()
|
||
const quotedContent = String(message.quotedContent || '').replace(/\s+/g, ' ').trim()
|
||
const quotedSender = String(message.quotedSender || '').replace(/\s+/g, ' ').trim()
|
||
let text = parsedContent
|
||
if (quotedContent) {
|
||
const quote = quotedSender ? `${quotedSender}：${quotedContent}` : quotedContent
|
||
text = text && text !== '[引用消息]' ? `${text} [引用 ${quote}]` : `[引用 ${quote}]`
|
||
}
|
||
if (!text) {
|
||
text = String(message.linkTitle || message.fileName || message.appMsgDesc || '').replace(/\s+/g, ' ').trim()
|
||
}
|
||
if (!text) return ''
|
||
if (/^<\?xml|^<msg\b|^<appmsg\b|^<img\b|^<emoji\b/i.test(text)) return ''
|
||
return text
|
||
}
|
||
|
||
private async buildTranscript(sessionId: string, messages: Message[]): Promise<{ transcript: string; readableMessages: Message[] }> {
|
||
const readableMessages = messages.filter((message) => this.normalizeMessageText(message))
|
||
const senderIds = Array.from(new Set(
|
||
readableMessages
|
||
.map((message) => String(message.senderUsername || '').trim())
|
||
.filter(Boolean)
|
||
))
|
||
const contacts = senderIds.length > 0
|
||
? (await chatService.enrichSessionsContactInfo(senderIds).catch(() => null))?.contacts || {}
|
||
: {}
|
||
const myWxid = String(this.config.getMyWxidCleaned() || '').trim()
|
||
|
||
const lines = readableMessages.map((message) => {
|
||
const senderUsername = String(message.senderUsername || '').trim()
|
||
const senderName = message.isSend === 1 || (senderUsername && myWxid && senderUsername === myWxid)
|
||
? '我'
|
||
: (contacts[senderUsername]?.displayName || senderUsername || '未知成员')
|
||
return `${formatTimestamp(message.createTime)} ${senderName}：${this.normalizeMessageText(message)}`
|
||
})
|
||
|
||
return {
|
||
transcript: lines.join('\n'),
|
||
readableMessages
|
||
}
|
||
}
|
||
|
||
private async generateSummaryForPeriod(params: {
|
||
sessionId: string
|
||
displayName: string
|
||
avatarUrl?: string
|
||
periodStart: number
|
||
periodEnd: number
|
||
triggerType: GroupSummaryTriggerType
|
||
}): Promise<GroupSummaryTriggerResult> {
|
||
const { apiBaseUrl, apiKey, model } = this.getSharedAiModelConfig()
|
||
if (!apiBaseUrl || !apiKey) {
|
||
return { success: false, message: '请先填写通用 AI 模型配置（API 地址和 Key）' }
|
||
}
|
||
|
||
try {
|
||
const messages = await this.readMessagesInPeriod(params.sessionId, params.periodStart, params.periodEnd)
|
||
const { transcript, readableMessages } = await this.buildTranscript(params.sessionId, messages)
|
||
if (readableMessages.length < MIN_SUMMARY_MESSAGES) {
|
||
return {
|
||
success: true,
|
||
skipped: true,
|
||
skippedReason: 'message_count_too_low',
|
||
message: `该时段可总结消息少于 ${MIN_SUMMARY_MESSAGES} 条，已跳过`
|
||
}
|
||
}
|
||
|
||
const customPrompt = String(this.config.get('aiGroupSummarySystemPrompt') || '').trim()
|
||
const systemPrompt = customPrompt || DEFAULT_GROUP_SUMMARY_SYSTEM_PROMPT
|
||
const userPrompt = `群聊：${params.displayName}
|
||
总结时段：${formatTimestamp(params.periodStart)} 至 ${formatTimestamp(params.periodEnd)}
|
||
消息数量：${readableMessages.length}
|
||
|
||
群聊记录：
|
||
${transcript}
|
||
|
||
请只输出指定 JSON。`
|
||
const endpoint = buildApiUrl(apiBaseUrl, '/chat/completions')
|
||
const requestMessages = [
|
||
{ role: 'system', content: systemPrompt },
|
||
{ role: 'user', content: userPrompt }
|
||
]
|
||
|
||
let rawOutput = ''
|
||
let responseFormatJson = true
|
||
let responseFormatFallback = false
|
||
let responseFormatFallbackReason = ''
|
||
const startedAt = Date.now()
|
||
try {
|
||
rawOutput = await callChatCompletions(apiBaseUrl, apiKey, model, requestMessages, { responseFormatJson: true })
|
||
} catch (error) {
|
||
if (!shouldFallbackJsonMode(error)) throw error
|
||
responseFormatJson = false
|
||
responseFormatFallback = true
|
||
responseFormatFallbackReason = (error as Error).message || 'response_format 不受支持'
|
||
rawOutput = await callChatCompletions(apiBaseUrl, apiKey, model, requestMessages)
|
||
}
|
||
|
||
let topics: GroupSummaryTopic[]
|
||
let finalSummary: string
|
||
try {
|
||
topics = parseTopics(rawOutput)
|
||
finalSummary = buildSummaryText(topics)
|
||
} catch {
|
||
topics = [fallbackTopicFromRaw(rawOutput)]
|
||
finalSummary = buildSummaryText(topics)
|
||
}
|
||
|
||
const log: GroupSummaryLog = {
|
||
endpoint,
|
||
model,
|
||
temperature: API_TEMPERATURE,
|
||
triggerType: params.triggerType,
|
||
periodStart: params.periodStart,
|
||
periodEnd: params.periodEnd,
|
||
messageCount: messages.length,
|
||
readableMessageCount: readableMessages.length,
|
||
systemPrompt,
|
||
userPrompt,
|
||
rawOutput,
|
||
finalSummary,
|
||
durationMs: Date.now() - startedAt,
|
||
createdAt: Date.now(),
|
||
responseFormatJson,
|
||
responseFormatFallback,
|
||
responseFormatFallbackReason,
|
||
parsedTopics: topics
|
||
}
|
||
|
||
const record = groupSummaryRecordService.addRecord({
|
||
sessionId: params.sessionId,
|
||
displayName: params.displayName,
|
||
avatarUrl: params.avatarUrl,
|
||
triggerType: params.triggerType,
|
||
periodStart: params.periodStart,
|
||
periodEnd: params.periodEnd,
|
||
messageCount: messages.length,
|
||
readableMessageCount: readableMessages.length,
|
||
topics,
|
||
summaryText: finalSummary,
|
||
rawOutput,
|
||
log
|
||
})
|
||
|
||
return { success: true, message: '群聊总结已生成', recordId: record.id, record }
|
||
} catch (error) {
|
||
return { success: false, message: `生成失败：${(error as Error).message || String(error)}` }
|
||
}
|
||
}
|
||
|
||
private async generateSummariesForPeriods(params: {
|
||
sessionId: string
|
||
displayName: string
|
||
avatarUrl?: string
|
||
periods: Array<{ start: number; end: number }>
|
||
triggerType: GroupSummaryTriggerType
|
||
}): Promise<GroupSummaryDayTriggerResult> {
|
||
const records: GroupSummaryRecordSummary[] = []
|
||
let skipped = 0
|
||
let failed = 0
|
||
let firstError = ''
|
||
|
||
for (const period of params.periods) {
|
||
const result = await this.generateSummaryForPeriod({
|
||
sessionId: params.sessionId,
|
||
displayName: params.displayName,
|
||
avatarUrl: params.avatarUrl,
|
||
periodStart: period.start,
|
||
periodEnd: period.end,
|
||
triggerType: params.triggerType
|
||
})
|
||
if (result.success && result.record) {
|
||
records.push(result.record)
|
||
continue
|
||
}
|
||
if (result.success && result.skipped) {
|
||
skipped += 1
|
||
continue
|
||
}
|
||
failed += 1
|
||
if (!firstError) firstError = result.message
|
||
}
|
||
|
||
const generated = records.length
|
||
const parts = [`生成 ${generated} 段`, `跳过 ${skipped} 段`]
|
||
if (failed > 0) parts.push(`失败 ${failed} 段`)
|
||
const message = failed > 0 && generated === 0 && skipped === 0
|
||
? (firstError || '群聊总结生成失败')
|
||
: `群聊总结完成：${parts.join('，')}`
|
||
|
||
return {
|
||
success: generated > 0 || skipped > 0 || failed === 0,
|
||
message,
|
||
generated,
|
||
skipped,
|
||
records
|
||
}
|
||
}
|
||
}
|
||
|
||
export const groupSummaryService = new GroupSummaryService()
|