egg_server/routes/bot/eventMsg.ts

import groupAgent from "../../controller/groupAgent"
import soupAgent from "../../controller/soupAgent"
import { Context } from "../../types"
import llm from "../../utils/llm"
import { cleanLLMRes } from "../../utils/llm/base"
import { isNotP2POrAtBot } from "../../utils/message"

/**
 * 过滤出非法消息，如果发表情包就直接发回去
 * @param {Context} ctx - 上下文数据，包含body, logger和larkService
 * @returns {boolean} 是否为非法消息
 */
const filterIllegalMsg = async (ctx: Context): Promise<boolean> => {
  const { body, logger, larkService, larkBody } = ctx
  const { chatId, msgType, msgText } = larkBody
  // 没有chatId的消息不处理
  logger.info(`bot req chatId: ${chatId}`)
  if (!chatId) return true

  // 获取msgType
  logger.info(`bot req msgType: ${msgType}`)
  // 放行纯文本消息
  if (msgType === "text") {
    // 过滤艾特全体成员的消息
    if (msgText.includes("@_all")) {
      return true
    }
    // 放行
    return false
  }

  // 发表情包就直接发回去
  if (msgType === "sticker") {
    logger.info(`got a sticker message, chatId: ${chatId}`)
    const content = body?.event?.message?.content
    larkService.message.send("chat_id", chatId, "sticker", content)
  }

  // 非表情包其他的信息都不处理
  else {
    logger.info(`got a illegal message, chatId: ${chatId}`)
    larkService.message.sendText2Chat(
      chatId,
      "哇！这是什么东东？我只懂普通文本啦！[可爱]"
    )
  }

  // 非纯文本，全不放行
  return true
}

/**
 * 发送ID消息
 * @param {Context} ctx - 上下文数据
 */
const manageIdMsg = ({
  larkBody: { chatId },
  larkCard,
  larkService,
}: Context) =>
  larkService.message.sendCard2Chat(
    chatId,
    larkCard.genTempCard("chatId", { chat_id: chatId })
  )

/**
 * 处理意图消息
 * @param {Context} ctx - 上下文数据
 */
const manageIntent = async (ctx: Context) => {
  const {
    body,
    logger,
    larkService: { message },
    attachService,
    larkBody: { msgText, chatId },
    larkCard,
    requestId,
  } = ctx
  logger.info(`bot req text: ${msgText}`)
  await message.updateOrReply(
    larkCard.genPendingCard("正在理解您的意图，请稍等...")
  )
  try {
    const llmRes = (await llm.invoke(
      "intentRecognition",
      {
        userInput: msgText,
        time: new Date().toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" }),
      },
      requestId
    )) as string
    const cleanedLlmRes = cleanLLMRes(llmRes)
    logger.info(`intentRecognition llm res: ${cleanedLlmRes}`)
    // 返回值不是数字，说明是通识回答
    const intent = Number(cleanedLlmRes)
    if (isNaN(intent)) {
      await message.updateOrReply(larkCard.genSuccessCard(cleanedLlmRes))
      return
    }

    switch (intent) {
      // 获取聊天ID
      case 1:
        await manageIdMsg(ctx)
        break
      // CI监控
      case 2:
        await attachService.ciMonitor(chatId)
        break
      // 生成简报
      case 3:
        await message.updateOrReply(
          larkCard.genSuccessCard("正在为您收集简报，请稍等片刻~")
        )
        await attachService.reportCollector(body)
        break
      // 获取帮助
      case 4:
        await message.updateOrReply(
          larkCard.genTempCard("eggGuide", { chat_id: chatId }) as string
        )
        break
      // 开启日报订阅
      case 5:
        groupAgent.report.setSubscription(ctx, "daily", true)
        break
      // 开启周报订阅
      case 6:
        groupAgent.report.setSubscription(ctx, "weekly", true)
        break
      // 关闭日报订阅
      case 7:
        groupAgent.report.setSubscription(ctx, "daily", false)
        break
      // 关闭周报订阅
      case 8:
        groupAgent.report.setSubscription(ctx, "weekly", false)
        break
      // 立即发送日报
      case 9:
        groupAgent.report.gen4Test(ctx, "daily")
        break
      // 立即发送周报
      case 10:
        groupAgent.report.gen4Test(ctx, "weekly")
        break
      // 开始海龟汤游戏
      case 11:
        soupAgent.startOrStopGame(ctx, true, "manual")
        break
      // 结束海龟汤游戏
      case 12:
        soupAgent.startOrStopGame(ctx, false, "manual")
        break
      // 通识回答
      case 13:
      default:
        groupAgent.agent(ctx)
        break
    }
  } catch (error) {
    logger.error(`manageIntent error: ${error}`)
    await message.updateOrReply(larkCard.genErrorCard(`意图分析失败`))
  }
}

/**
 * 处理Event消息
 * @param {Context} ctx - 上下文数据
 */
export const manageEventMsg = async (ctx: Context) => {
  // 非群聊和非艾特机器人的消息不处理
  if (isNotP2POrAtBot(ctx)) return
  // 过滤非法消息
  if (await filterIllegalMsg(ctx)) return
  // 海龟汤
  if (await soupAgent.agent(ctx)) return
  // 处理命令消息
  await manageIntent(ctx)
}