egg_server/routes/bot/groupAgent/index.ts

import { Context } from "../../../types"
import llm from "../../../utils/llm"

/**
 * 发送群组选择器
 * @param ctx - 上下文数据，包含body和larkService
 */
const sendGroupSelector = async ({
  larkService,
  logger,
  larkCard,
  larkBody: { chatId },
}: Context.Data) => {
  const cardGender = larkCard.child("groupAgent")
  const { data: innerList } = await larkService.chat.getInnerList()
  logger.info(`Inner list: ${JSON.stringify(innerList)}`)
  // 组织群组数据
  const groups = innerList.map((v) => ({
    text: v.name,
    value: `${v.chat_id}|${v.name}`,
  }))
  larkService.message.sendCard2Chat(
    chatId,
    cardGender.genTempCard("groupSelector", { groups }) as string
  )
}

/**
 * 发送功能选择器
 * @param ctx - 上下文数据
 */
const sendFunctionSelector = async ({
  logger,
  larkCard,
  larkBody: { actionOption },
}: Context.Data) => {
  const cardGender = larkCard.child("groupAgent")
  logger.debug(`Action option: ${JSON.stringify(actionOption)}`)
  const [chatId, chatName] = (actionOption ?? "").split("|")
  if (!chatId || !chatName) {
    logger.error(
      `Invalid targetChatId or targetChatName: ${JSON.stringify(actionOption)}`
    )
    return cardGender.genErrorCard("Invalid targetChatId or targetChatName")
  }
  // 组织功能数据
  const functions = [
    {
      text: "总结消息",
      value: "summary-gpt-4o|总结消息",
    },
  ]
  return cardGender.genCard("functionSelector", {
    functions,
    chatId,
    chatName,
  })
}

/**
 * 发送时间范围选择器
 * @param ctx - 上下文数据，包含body和larkService
 */
const sendTimeScopeSelector = async ({
  logger,
  larkCard,
  larkBody: { actionOption, actionValue },
}: Context.Data) => {
  const cardGender = larkCard.child("groupAgent", false)
  logger.debug(`Action option: ${JSON.stringify(actionOption)}`)
  const [functionId, functionName] = (actionOption ?? "").split("|")
  if (!functionId || !functionName) {
    logger.error(
      `Invalid functionId or functionName: ${JSON.stringify(actionOption)}`
    )
    return cardGender.genErrorCard("Invalid functionId or functionName")
  }
  logger.debug(`Action value: ${JSON.stringify(actionValue)}`)
  const { chatId, chatName } = actionValue
  if (!chatName || !chatId) {
    logger.error(`Invalid chatName or chatId: ${JSON.stringify(actionValue)}`)
    return cardGender.genErrorCard("Invalid chatName or chatId")
  }
  return cardGender.genCard("timeScopeSelector", {
    chatId,
    chatName,
    functionId,
    functionName,
  })
}

const sendGroupReport = async ({
  larkService,
  logger,
  requestId,
  larkCard,
  larkBody: { actionValue, messageId },
}: Context.Data) => {
  const cardGender = larkCard.child("groupAgent")
  const { chatId, chatName, functionId, functionName, timeScope } = actionValue

  // 记录发送loading消息后的时间戳
  const startTime = Date.now()

  // 获取历史消息，timeScope为1、3、7，分别代表1天、3天、7天
  // 获取服务器的时区偏移量（以分钟为单位）
  const serverTimezoneOffset = new Date().getTimezoneOffset()
  // 上海时区的偏移量（UTC+8，以分钟为单位）
  const shanghaiTimezoneOffset = -8 * 60
  // 计算时间戳，调整为上海时区
  const endTimeTimestamp =
    Math.round(new Date().getTime() / 1000) +
    (shanghaiTimezoneOffset - serverTimezoneOffset) * 60
  const startTimeTimestamp = endTimeTimestamp - Number(timeScope) * 24 * 60 * 60
  // 获取群聊中的历史记录
  const { data: chatHistory } = await larkService.message.getHistory(
    chatId,
    String(startTimeTimestamp),
    String(endTimeTimestamp)
  )
  // 如果没有历史记录则返回错误消息
  if (chatHistory.length === 0) {
    logger.error("Chat history is empty")
    await larkService.message.update(
      messageId,
      cardGender.genErrorCard("未找到聊天记录")
    )
    return
  }
  logger.debug(`Chat history: ${JSON.stringify(chatHistory)}`)

  try {
    const llmRes = await llm.invoke(functionId, {
      chatHistory: JSON.stringify(chatHistory),
      time: new Date().toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" }),
    })
    // 记录大模型返回结果后的时间戳
    const endTime = Date.now()
    // 计算时间差并存储在processingTime变量中，以秒为单位
    const processingTime = ((endTime - startTime) / 1000).toFixed(2)
    logger.info(`LLM takes time: ${processingTime}s, result: ${llmRes}`)
    // 更新消息卡片
    await larkService.message.update(
      messageId,
      cardGender.genCard("resultReport", {
        chatName,
        functionName,
        llmRes,
        timeScope,
        requestId,
        processingTime,
      })
    )
  } catch (error: any) {
    logger.error(`LLM error: ${error.message}`)
    await larkService.message.update(
      messageId,
      cardGender.genErrorCard("LLM调用失败: " + error.message)
    )
  }
}

/**
 * 发送结果报告
 * @param ctx - 上下文数据，包含body和larkService
 */
const manageGroupMsg = async (ctx: Context.Data) => {
  const {
    logger,
    larkCard,
    larkBody: { actionValue },
  } = ctx

  const cardGender = larkCard.child("groupAgent", false)

  logger.debug(`Action value: ${JSON.stringify(actionValue)}`)

  const { chatId, chatName, functionId, functionName, timeScope } = actionValue
  if (!chatId || !chatName || !functionId || !functionName || !timeScope) {
    logger.error(`Invalid value: ${JSON.stringify(actionValue)}`)
    return cardGender.genErrorCard("Invalid value")
  }

  // 处理群组消息
  sendGroupReport(ctx)
  // 发送一个loading的消息
  return cardGender.genSuccessCard("正在爬楼中，请稍等...")
}

const groupAgent = {
  sendGroupSelector,
  sendFunctionSelector,
  sendTimeScopeSelector,
  manageGroupMsg,
}

export default groupAgent