处理器

简介

处理器（Processor）是Chaite提供的一种机制，用于对LLM的输入和输出进行处理，允许用户对AI的交互流程进行自定义和增强。处理器分为前处理器（PreProcessor）和后处理器（PostProcessor）两种类型。

前处理器：在用户消息发送给LLM之前进行处理
后处理器：在接收到LLM回复后，发送给用户之前进行处理

处理器的定义

Chaite中的处理器通过实现PreProcessor或PostProcessor抽象类来定义：

export interface Processor {
  type: 'pre' | 'post'
  name: string
}

/**
 * 继承这个来实现一个前处理器
 */
export abstract class PreProcessor implements Processor {
  type: 'pre'
  abstract process(message: UserMessage): Promise<UserMessage>
  name: string
  id: string
}

/**
 * 继承这个来实现一个后处理器
 */
export abstract class PostProcessor implements Processor {
  type: 'post'
  abstract process(message: AssistantMessage): Promise<AssistantMessage>
  name: string
  id: string
}

编写自定义处理器

前处理器示例

前处理器可以对用户的输入进行修改、过滤或增强。以下是一个敏感词过滤的前处理器示例：

import { PreProcessor } from 'chaite'

class SensitiveWordFilterProcessor extends PreProcessor {
  type = 'pre'
  name = 'sensitiveWordFilter'

  /**
   * 处理用户输入，过滤敏感词
   * @param {import('chaite').UserMessage} message
   * @returns {Promise<import('chaite').UserMessage>}
   */
  async process(message) {
    // 定义敏感词列表
    const sensitiveWords = ['敏感词1', '敏感词2', '敏感词3']

    // 遍历消息内容
    for (let content of message.content) {
      if (content.type === 'text') {
        // 替换敏感词
        for (const word of sensitiveWords) {
          if (content.text.includes(word)) {
            content.text = content.text.replaceAll(word, '***')
          }
        }
      }
    }

    return message
  }
}

export default new SensitiveWordFilterProcessor()

后处理器示例

后处理器可以对AI的回复进行修改、增强或执行额外操作。以下是一个文本转语音的后处理器示例：

import { asyncLocalStorage, PostProcessor } from 'chaite'

class TTSPostProcessor extends PostProcessor {
  type = 'post'
  name = 'tts'

  /**
   * 处理逻辑
   * 将AI回复转换为语音并发送
   * @param {import('chaite').AssistantMessage} message
   * @returns {Promise<import('chaite').AssistantMessage>}
   */
  async process(message) {
    const context = asyncLocalStorage.getStore()
    const e = context.getEvent()

    // 获取AI的文本回复
    if (!message.content || message.content.length === 0) {
      return message
    }
    const rawResponse = message.content[0].text

    try {
      // 这里调用TTS API生成语音
      // ...
      // 发送语音
      // ...
    } catch (error) {
      console.error('TTS处理失败:', error)
      // 如果TTS失败，告知用户
      await e.reply('语音生成失败，请查看文本回复')
    }

    // 返回原始消息，不做修改
    return message
  }
}

export default new TTSPostProcessor()

内容审查后处理器

import { PostProcessor } from 'chaite'

export class ContentFilterPostProcessor extends PostProcessor {
  name = 'contentFilter'
  type = 'post'

  /**
   * 对AI回复进行内容审查
   * @param {import('chaite').AssistantMessage} message
   * @returns {Promise<import('chaite').AssistantMessage>}
   */
  async process(message) {
    // 定义屏蔽词
    const blockWords = ['屏蔽词1', '屏蔽词2', '屏蔽词3']
    // 屏蔽策略：full(完全屏蔽) 或 mask(替换敏感词)
    const blockStrategy = 'mask'
    // 替换字符
    const blockWordMask = '***'

    switch (blockStrategy) {
      case 'full': {
        for (let content of message.content) {
          for (const blockWord of blockWords) {
            if (content.type === 'text' && content.text?.includes(blockWord)) {
              content.text = '回复已屏蔽'
              break
            }
          }
        }
        break
      }
      case 'mask': {
        for (let content of message.content) {
          for (const blockWord of blockWords) {
            if (content.type === 'text' && content.text?.includes(blockWord)) {
              content.text = content.text.replaceAll(blockWord, blockWordMask)
              break
            }
          }
        }
      }
    }

    return message
  }
}

export default new ContentFilterPostProcessor()

使用上下文

在处理器中，你可以通过asyncLocalStorage获取当前上下文信息：

import { asyncLocalStorage, PostProcessor } from 'chaite'

class MyProcessor extends PostProcessor {
  // ...

  async process(message) {
    // 获取上下文
    const context = asyncLocalStorage.getStore()
    // 获取事件对象
    const e = context.getEvent()

    // 现在你可以访问事件信息
    // ...

    return message
  }
}

export default new MyProcessor()

配置处理器

编写完处理器后，需要将其添加到配置中才能使用。你可以将处理器文件放在指定目录下，Chaite会自动加载它们。

最佳实践

专注单一职责：每个处理器应该只完成一个明确的任务
性能考虑：处理器会在每次交互中执行，确保其性能高效
顺序重要性：多个处理器的执行顺序可能影响最终结果
错误处理：确保处理器中的错误不会中断整个对话流程