@zhin.js/adapter-discord 1.0.7 → 1.0.8

package/src/index.ts

@@ -1,1056 +1,1145 @@
 import {
-    Client,
-    GatewayIntentBits,
-    Message as DiscordMessage,
-    TextChannel,
-    DMChannel,
-    NewsChannel,
-    ThreadChannel,
-    EmbedBuilder,
-    AttachmentBuilder,
-    MessageCreateOptions,
-    ChannelType,
-    REST,
-    Routes,
-    ApplicationCommandData,
-    ChatInputCommandInteraction,
-    InteractionType,
-    InteractionResponseType
-} from 'discord.js';
+  Client,
+  GatewayIntentBits,
+  Message as DiscordMessage,
+  TextChannel,
+  DMChannel,
+  NewsChannel,
+  ThreadChannel,
+  EmbedBuilder,
+  AttachmentBuilder,
+  MessageCreateOptions,
+  ChannelType,
+  REST,
+  Routes,
+  ApplicationCommandData,
+  ChatInputCommandInteraction,
+  InteractionType,
+  InteractionResponseType,
+} from "discord.js";
 import {
-    Bot,
-    BotConfig,
-    Adapter,
-    Plugin,
-    registerAdapter,
-    Message,
-    SendOptions,
-    SendContent,
-    MessageSegment,
-    segment,
-    useContext
+  Bot,
+  Adapter,
+  Plugin,
+  registerAdapter,
+  Message,
+  SendOptions,
+  SendContent,
+  MessageSegment,
+  segment,
+  useContext,
+  usePlugin,
 } from "zhin.js";
-import type { Context } from 'koa';
-import { createReadStream } from 'fs';
-import { promises as fs } from 'fs';
-import path from 'path';
+import type { Context } from "koa";
+import { createReadStream } from "fs";
+import { promises as fs } from "fs";
+import path from "path";
 
 // 声明模块，注册 discord 适配器类型
-declare module '@zhin.js/types'{
-    interface RegisteredAdapters{
-        discord:Adapter<DiscordBot>
-        'discord-interactions':Adapter<DiscordInteractionsBot>
-    }
+declare module "@zhin.js/types" {
+  interface RegisteredAdapters {
+    discord: Adapter<DiscordBot>;
+    "discord-interactions": Adapter<DiscordInteractionsBot>;
+  }
 }
 
 // Discord Gateway 模式配置
-export type DiscordBotConfig = BotConfig & {
-    context: 'discord'
-    token: string
-    name: string
-    intents?: GatewayIntentBits[]
-    // Discord 特有配置
-    enableSlashCommands?: boolean
-    globalCommands?: boolean
-    defaultActivity?: {
-        name: string
-        type: 'PLAYING' | 'STREAMING' | 'LISTENING' | 'WATCHING' | 'COMPETING'
-        url?: string
-    }
-    // Slash Commands 定义
-    slashCommands?: ApplicationCommandData[]
-}
+export type DiscordBotConfig = Bot.Config & {
+  context: "discord";
+  token: string;
+  name: string;
+  intents?: GatewayIntentBits[];
+  // Discord 特有配置
+  enableSlashCommands?: boolean;
+  globalCommands?: boolean;
+  defaultActivity?: {
+    name: string;
+    type: "PLAYING" | "STREAMING" | "LISTENING" | "WATCHING" | "COMPETING";
+    url?: string;
+  };
+  // Slash Commands 定义
+  slashCommands?: ApplicationCommandData[];
+};
 
 // Discord Interactions 模式配置
-export interface DiscordInteractionsConfig extends BotConfig {
-    context: 'discord-interactions'
-    token: string
-    name: string
-    applicationId: string
-    publicKey: string  // Discord 应用的 Public Key
-    interactionsPath: string  // 交互端点路径，如 '/discord/interactions'
-    // 是否同时使用 Gateway（默认 false）
-    useGateway?: boolean
-    intents?: GatewayIntentBits[]
-    // Slash Commands 定义
-    slashCommands?: ApplicationCommandData[]
-    globalCommands?: boolean
-    defaultActivity?: {
-        name: string
-        type: 'PLAYING' | 'STREAMING' | 'LISTENING' | 'WATCHING' | 'COMPETING'
-        url?: string
-    }
+export interface DiscordInteractionsConfig extends Bot.Config {
+  context: "discord-interactions";
+  token: string;
+  name: string;
+  applicationId: string;
+  publicKey: string; // Discord 应用的 Public Key
+  interactionsPath: string; // 交互端点路径，如 '/discord/interactions'
+  // 是否同时使用 Gateway（默认 false）
+  useGateway?: boolean;
+  intents?: GatewayIntentBits[];
+  // Slash Commands 定义
+  slashCommands?: ApplicationCommandData[];
+  globalCommands?: boolean;
+  defaultActivity?: {
+    name: string;
+    type: "PLAYING" | "STREAMING" | "LISTENING" | "WATCHING" | "COMPETING";
+    url?: string;
+  };
 }
 
 // Bot 接口
 export interface DiscordBot {
-    $config: DiscordBotConfig
+  $config: DiscordBotConfig;
 }
 
 export interface DiscordInteractionsBot {
-    $config: DiscordInteractionsConfig
+  $config: DiscordInteractionsConfig;
 }
 
 // Discord 消息类型
 type DiscordChannelMessage = DiscordMessage<boolean>;
-
+const plugin = usePlugin();
 // 主要的 DiscordBot 类
-export class DiscordBot extends Client implements Bot<DiscordChannelMessage, DiscordBotConfig> {
-    $connected?: boolean
-    private slashCommandHandlers: Map<string, (interaction: ChatInputCommandInteraction) => Promise<void>> = new Map()
-
-    constructor(private plugin: Plugin, public $config: DiscordBotConfig) {
-        const intents = $config.intents || [
-            GatewayIntentBits.Guilds,
-            GatewayIntentBits.GuildMessages,
-            GatewayIntentBits.MessageContent,
-            GatewayIntentBits.DirectMessages,
-            GatewayIntentBits.GuildMembers,
-            GatewayIntentBits.GuildMessageReactions
-        ];
-
-        super({ intents });
-        this.$connected = false;
-    }
-
-    private async handleDiscordMessage(msg: DiscordChannelMessage): Promise<void> {
-        // 忽略机器人消息
-        if (msg.author.bot) return;
-
-        const message = this.$formatMessage(msg);
-        this.plugin.dispatch('message.receive', message);
-        this.plugin.logger.info(`recv ${message.$channel.type}(${message.$channel.id}): ${segment.raw(message.$content)}`);
-        this.plugin.dispatch(`message.${message.$channel.type}.receive`, message);
-    }
-
-    private async handleSlashCommand(interaction: ChatInputCommandInteraction): Promise<void> {
-        const commandName = interaction.commandName;
-        const handler = this.slashCommandHandlers.get(commandName);
-        
-        if (handler) {
-            try {
-                await handler(interaction);
-                this.plugin.logger.info(`Executed slash command: /${commandName} by ${interaction.user.tag}`);
-            } catch (error) {
-                this.plugin.logger.error(`Error executing slash command /${commandName}:`, error);
-                
-                const errorMessage = 'An error occurred while executing this command.';
-                if (interaction.replied || interaction.deferred) {
-                    await interaction.followUp({ content: errorMessage, ephemeral: true });
-                } else {
-                    await interaction.reply({ content: errorMessage, ephemeral: true });
-                }
-            }
+export class DiscordBot
+  extends Client
+  implements Bot<DiscordChannelMessage, DiscordBotConfig>
+{
+  $connected?: boolean;
+  private slashCommandHandlers: Map<
+    string,
+    (interaction: ChatInputCommandInteraction) => Promise<void>
+  > = new Map();
+
+  constructor(public $config: DiscordBotConfig) {
+    const intents = $config.intents || [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.DirectMessages,
+      GatewayIntentBits.GuildMembers,
+      GatewayIntentBits.GuildMessageReactions,
+    ];
+
+    super({ intents });
+    this.$connected = false;
+  }
+
+  private async handleDiscordMessage(
+    msg: DiscordChannelMessage
+  ): Promise<void> {
+    // 忽略机器人消息
+    if (msg.author.bot) return;
+
+    const message = this.$formatMessage(msg);
+    plugin.dispatch("message.receive", message);
+    plugin.logger.info(
+      `recv ${message.$channel.type}(${message.$channel.id}): ${segment.raw(
+        message.$content
+      )}`
+    );
+    plugin.dispatch(`message.${message.$channel.type}.receive`, message);
+  }
+
+  private async handleSlashCommand(
+    interaction: ChatInputCommandInteraction
+  ): Promise<void> {
+    const commandName = interaction.commandName;
+    const handler = this.slashCommandHandlers.get(commandName);
+
+    if (handler) {
+      try {
+        await handler(interaction);
+        plugin.logger.info(
+          `Executed slash command: /${commandName} by ${interaction.user.tag}`
+        );
+      } catch (error) {
+        plugin.logger.error(
+          `Error executing slash command /${commandName}:`,
+          error
+        );
+
+        const errorMessage = "An error occurred while executing this command.";
+        if (interaction.replied || interaction.deferred) {
+          await interaction.followUp({
+            content: errorMessage,
+            ephemeral: true,
+          });
         } else {
-            this.plugin.logger.warn(`Unknown slash command: /${commandName}`);
-            if (!interaction.replied) {
-                await interaction.reply({ 
-                    content: 'Unknown command.', 
-                    ephemeral: true 
-                });
-            }
+          await interaction.reply({ content: errorMessage, ephemeral: true });
         }
-    }
-
-    async $connect(): Promise<void> {
-        return new Promise((resolve, reject) => {
-            // 监听消息事件
-            this.on('messageCreate', this.handleDiscordMessage.bind(this));
-
-            // 监听交互事件（Slash Commands）
-            if (this.$config.enableSlashCommands) {
-                this.on('interactionCreate', async (interaction) => {
-                    if (interaction.isChatInputCommand()) {
-                        await this.handleSlashCommand(interaction);
-                    }
-                });
-            }
-
-            // 监听就绪事件
-            this.once('ready', async () => {
-                this.$connected = true;
-                this.plugin.logger.info(`Discord bot ${this.$config.name} connected successfully as ${this.user?.tag}`);
-                
-                // 设置活动状态
-                if (this.$config.defaultActivity) {
-                    this.user?.setActivity(this.$config.defaultActivity.name, {
-                        type: this.getActivityType(this.$config.defaultActivity.type),
-                        url: this.$config.defaultActivity.url
-                    });
-                }
-
-                // 注册 Slash Commands
-                if (this.$config.enableSlashCommands && this.$config.slashCommands) {
-                    await this.registerSlashCommands();
-                }
-                
-                resolve();
-            });
-
-            // 监听错误事件
-            this.on('error', (error) => {
-                this.plugin.logger.error('Discord client error:', error);
-                this.$connected = false;
-                reject(error);
-            });
-
-            // 登录
-            this.login(this.$config.token).catch((error) => {
-                this.plugin.logger.error('Failed to login to Discord:', error);
-                this.$connected = false;
-                reject(error);
-            });
+      }
+    } else {
+      plugin.logger.warn(`Unknown slash command: /${commandName}`);
+      if (!interaction.replied) {
+        await interaction.reply({
+          content: "Unknown command.",
+          ephemeral: true,
         });
+      }
     }
-
-    async $disconnect(): Promise<void> {
-        try {
-            await this.destroy();
-            this.$connected = false;
-            this.plugin.logger.info(`Discord bot ${this.$config.name} disconnected`);
-        } catch (error) {
-            this.plugin.logger.error('Error disconnecting Discord bot:', error);
-            throw error;
+  }
+
+  async $connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      // 监听消息事件
+      this.on("messageCreate", this.handleDiscordMessage.bind(this));
+
+      // 监听交互事件（Slash Commands）
+      if (this.$config.enableSlashCommands) {
+        this.on("interactionCreate", async (interaction) => {
+          if (interaction.isChatInputCommand()) {
+            await this.handleSlashCommand(interaction);
+          }
+        });
+      }
+
+      // 监听就绪事件
+      this.once("clientReady", async () => {
+        this.$connected = true;
+        plugin.logger.info(
+          `Discord bot ${this.$config.name} connected successfully as ${this.user?.tag}`
+        );
+
+        // 设置活动状态
+        if (this.$config.defaultActivity) {
+          this.user?.setActivity(this.$config.defaultActivity.name, {
+            type: this.getActivityType(this.$config.defaultActivity.type),
+            url: this.$config.defaultActivity.url,
+          });
         }
-    }
 
-    $formatMessage(msg: DiscordChannelMessage): Message<DiscordChannelMessage> {
-        // 确定聊天类型和ID
-        let channelType: 'private' | 'group' | 'channel';
-        let channelId: string;
-
-        if (msg.channel.type === ChannelType.DM) {
-            channelType = 'private';
-            channelId = msg.channel.id;
-        } else if (msg.channel.type === ChannelType.GroupDM) {
-            channelType = 'group';
-            channelId = msg.channel.id;
-        } else {
-            channelType = 'channel';
-            channelId = msg.channel.id;
+        // 注册 Slash Commands
+        if (this.$config.enableSlashCommands && this.$config.slashCommands) {
+          await this.registerSlashCommands();
         }
 
-        // 转换消息内容为 segment 格式
-        const content = this.parseMessageContent(msg);
+        resolve();
+      });
 
-        const result = Message.from(msg, {
-            $id: msg.id,
-            $adapter: 'discord',
-            $bot: this.$config.name,
-            $sender: {
-                id: msg.author.id,
-                name: msg.member?.displayName || msg.author.displayName
-            },
-            $channel: {
-                id: channelId,
-                type: channelType
-            },
-            $content: content,
-            $raw: msg.content,
-            $timestamp: msg.createdTimestamp,
-            $reply: async (content: SendContent, quote?: boolean | string): Promise<string> => {
-                if (!Array.isArray(content)) content = [content];
-
-                const sendOptions: MessageCreateOptions = {};
-
-                // 处理回复消息
-                if (quote) {
-                    const replyId = typeof quote === "boolean" ? result.$id : quote;
-                    try {
-                        const replyMessage = await msg.channel.messages.fetch(replyId);
-                        sendOptions.reply = { messageReference: replyMessage };
-                    } catch (error) {
-                        this.plugin.logger.warn(`Could not find message to reply to: ${replyId}`);
-                    }
-                }
-
-                const res = await this.sendContentToChannel(msg.channel as any, content, sendOptions);
-                return res.id;
-            }
-        });
+      // 监听错误事件
+      this.on("error", (error) => {
+        plugin.logger.error("Discord client error:", error);
+        this.$connected = false;
+        reject(error);
+      });
 
-        return result;
+      // 登录
+      this.login(this.$config.token).catch((error) => {
+        plugin.logger.error("Failed to login to Discord:", error);
+        this.$connected = false;
+        reject(error);
+      });
+    });
+  }
+
+  async $disconnect(): Promise<void> {
+    try {
+      await this.destroy();
+      this.$connected = false;
+      plugin.logger.info(`Discord bot ${this.$config.name} disconnected`);
+    } catch (error) {
+      plugin.logger.error("Error disconnecting Discord bot:", error);
+      throw error;
+    }
+  }
+
+  $formatMessage(msg: DiscordChannelMessage): Message<DiscordChannelMessage> {
+    // 确定聊天类型和ID
+    let channelType: "private" | "group" | "channel";
+    let channelId: string;
+
+    if (msg.channel.type === ChannelType.DM) {
+      channelType = "private";
+      channelId = msg.channel.id;
+    } else if (msg.channel.type === ChannelType.GroupDM) {
+      channelType = "group";
+      channelId = msg.channel.id;
+    } else {
+      channelType = "channel";
+      channelId = msg.channel.id;
     }
 
-    // 解析 Discord 消息内容为 segment 格式
-    parseMessageContent(msg: DiscordChannelMessage): MessageSegment[] {
-        const segments: MessageSegment[] = [];
-
-        // 回复消息处理
-        if (msg.reference) {
-            segments.push({
-                type: 'reply',
-                data: {
-                    id: msg.reference.messageId,
-                    channel_id: msg.reference.channelId,
-                    guild_id: msg.reference.guildId
-                }
-            });
-        }
-
-        // 文本消息（包含提及、表情等）
-        if (msg.content) {
-            segments.push(...this.parseTextContent(msg.content, msg));
-        }
-
-        // 附件消息
-        for (const attachment of msg.attachments.values()) {
-            segments.push(...this.parseAttachment(attachment));
-        }
-
-        // Embed 消息
-        for (const embed of msg.embeds) {
-            segments.push({
-                type: 'embed',
-                data: {
-                    title: embed.title,
-                    description: embed.description,
-                    color: embed.color,
-                    url: embed.url,
-                    thumbnail: embed.thumbnail,
-                    image: embed.image,
-                    author: embed.author,
-                    footer: embed.footer,
-                    fields: embed.fields,
-                    timestamp: embed.timestamp
-                }
-            });
-        }
+    // 转换消息内容为 segment 格式
+    const content = this.parseMessageContent(msg);
+
+    const result = Message.from(msg, {
+      $id: msg.id,
+      $adapter: "discord",
+      $bot: this.$config.name,
+      $sender: {
+        id: msg.author.id,
+        name: msg.member?.displayName || msg.author.displayName,
+      },
+      $channel: {
+        id: channelId,
+        type: channelType,
+      },
+      $content: content,
+      $raw: msg.content,
+      $timestamp: msg.createdTimestamp,
+      $reply: async (
+        content: SendContent,
+        quote?: boolean | string
+      ): Promise<string> => {
+        if (!Array.isArray(content)) content = [content];
 
-        // 贴纸消息
-        for (const sticker of msg.stickers.values()) {
-            segments.push({
-                type: 'sticker',
-                data: {
-                    id: sticker.id,
-                    name: sticker.name,
-                    url: sticker.url,
-                    format: sticker.format,
-                    tags: sticker.tags
-                }
-            });
+        const sendOptions: MessageCreateOptions = {};
+
+        // 处理回复消息
+        if (quote) {
+          const replyId = typeof quote === "boolean" ? result.$id : quote;
+          try {
+            const replyMessage = await msg.channel.messages.fetch(replyId);
+            sendOptions.reply = { messageReference: replyMessage };
+          } catch (error) {
+            plugin.logger.warn(
+              `Could not find message to reply to: ${replyId}`
+            );
+          }
         }
 
-        return segments.length > 0 ? segments : [{ type: 'text', data: { text: '' } }];
+        const res = await this.sendContentToChannel(
+          msg.channel as any,
+          content,
+          sendOptions
+        );
+        return res.id;
+      },
+    });
+
+    return result;
+  }
+
+  // 解析 Discord 消息内容为 segment 格式
+  parseMessageContent(msg: DiscordChannelMessage): MessageSegment[] {
+    const segments: MessageSegment[] = [];
+
+    // 回复消息处理
+    if (msg.reference) {
+      segments.push({
+        type: "reply",
+        data: {
+          id: msg.reference.messageId,
+          channel_id: msg.reference.channelId,
+          guild_id: msg.reference.guildId,
+        },
+      });
     }
 
-    // 解析文本内容，处理提及、频道引用、角色引用等
-    parseTextContent(content: string, msg: DiscordChannelMessage): MessageSegment[] {
-        const segments: MessageSegment[] = [];
-        let lastIndex = 0;
-
-        // 匹配用户提及 <@!?用户ID>
-        const userMentionRegex = /<@!?(\d+)>/g;
-        // 匹配频道提及 <#频道ID>  
-        const channelMentionRegex = /<#(\d+)>/g;
-        // 匹配角色提及 <@&角色ID>
-        const roleMentionRegex = /<@&(\d+)>/g;
-        // 匹配自定义表情 <:名称:ID> 或 <a:名称:ID>
-        const emojiRegex = /<a?:(\w+):(\d+)>/g;
-
-        const allMatches: Array<{
-            match: RegExpExecArray;
-            type: 'user' | 'channel' | 'role' | 'emoji';
-        }> = [];
-
-        // 收集所有匹配项
-        let match;
-        while ((match = userMentionRegex.exec(content)) !== null) {
-            allMatches.push({ match, type: 'user' });
-        }
-        while ((match = channelMentionRegex.exec(content)) !== null) {
-            allMatches.push({ match, type: 'channel' });
-        }
-        while ((match = roleMentionRegex.exec(content)) !== null) {
-            allMatches.push({ match, type: 'role' });
-        }
-        while ((match = emojiRegex.exec(content)) !== null) {
-            allMatches.push({ match, type: 'emoji' });
-        }
-
-        // 按位置排序
-        allMatches.sort((a, b) => a.match.index! - b.match.index!);
-
-        // 处理每个匹配项
-        for (const { match, type } of allMatches) {
-            const matchStart = match.index!;
-            const matchEnd = matchStart + match[0].length;
-
-            // 添加匹配项前的文本
-            if (matchStart > lastIndex) {
-                const beforeText = content.slice(lastIndex, matchStart);
-                if (beforeText.trim()) {
-                    segments.push({ type: 'text', data: { text: beforeText } });
-                }
-            }
-
-            // 添加特殊内容段
-            switch (type) {
-                case 'user':
-                    const userId = match[1];
-                    const user = msg.mentions.users.get(userId);
-                    segments.push({
-                        type: 'at',
-                        data: {
-                            id: userId,
-                            name: user?.username || 'Unknown',
-                            text: match[0]
-                        }
-                    });
-                    break;
-
-                case 'channel':
-                    const channelId = match[1];
-                    const channel = msg.mentions.channels.get(channelId);
-                    segments.push({
-                        type: 'channel_mention',
-                        data: {
-                            id: channelId,
-                            name: (channel as any)?.name || 'unknown-channel',
-                            text: match[0]
-                        }
-                    });
-                    break;
-
-                case 'role':
-                    const roleId = match[1];
-                    const role = msg.mentions.roles.get(roleId);
-                    segments.push({
-                        type: 'role_mention',
-                        data: {
-                            id: roleId,
-                            name: role?.name || 'unknown-role',
-                            text: match[0]
-                        }
-                    });
-                    break;
-
-                case 'emoji':
-                    const emojiName = match[1];
-                    const emojiId = match[2];
-                    const isAnimated = match[0].startsWith('<a:');
-                    segments.push({
-                        type: 'emoji',
-                        data: {
-                            id: emojiId,
-                            name: emojiName,
-                            animated: isAnimated,
-                            url: `https://cdn.discordapp.com/emojis/${emojiId}.${isAnimated ? 'gif' : 'png'}`,
-                            text: match[0]
-                        }
-                    });
-                    break;
-            }
-
-            lastIndex = matchEnd;
-        }
-
-        // 添加最后剩余的文本
-        if (lastIndex < content.length) {
-            const remainingText = content.slice(lastIndex);
-            if (remainingText.trim()) {
-                segments.push({ type: 'text', data: { text: remainingText } });
-            }
-        }
+    // 文本消息（包含提及、表情等）
+    if (msg.content) {
+      segments.push(...this.parseTextContent(msg.content, msg));
+    }
 
-        return segments.length > 0 ? segments : [{ type: 'text', data: { text: content } }];
+    // 附件消息
+    for (const attachment of msg.attachments.values()) {
+      segments.push(...this.parseAttachment(attachment));
     }
 
-    // 解析附件
-    parseAttachment(attachment: any): MessageSegment[] {
-        const segments: MessageSegment[] = [];
-
-        if (attachment.contentType?.startsWith('image/')) {
-            segments.push({
-                type: 'image',
-                data: {
-                    id: attachment.id,
-                    name: attachment.name,
-                    url: attachment.url,
-                    proxy_url: attachment.proxyURL,
-                    size: attachment.size,
-                    width: attachment.width,
-                    height: attachment.height,
-                    content_type: attachment.contentType
-                }
-            });
-        } else if (attachment.contentType?.startsWith('audio/')) {
-            segments.push({
-                type: 'audio',
-                data: {
-                    id: attachment.id,
-                    name: attachment.name,
-                    url: attachment.url,
-                    proxy_url: attachment.proxyURL,
-                    size: attachment.size,
-                    content_type: attachment.contentType
-                }
-            });
-        } else if (attachment.contentType?.startsWith('video/')) {
-            segments.push({
-                type: 'video',
-                data: {
-                    id: attachment.id,
-                    name: attachment.name,
-                    url: attachment.url,
-                    proxy_url: attachment.proxyURL,
-                    size: attachment.size,
-                    width: attachment.width,
-                    height: attachment.height,
-                    content_type: attachment.contentType
-                }
-            });
-        } else {
-            segments.push({
-                type: 'file',
-                data: {
-                    id: attachment.id,
-                    name: attachment.name,
-                    url: attachment.url,
-                    proxy_url: attachment.proxyURL,
-                    size: attachment.size,
-                    content_type: attachment.contentType
-                }
-            });
-        }
+    // Embed 消息
+    for (const embed of msg.embeds) {
+      segments.push({
+        type: "embed",
+        data: {
+          title: embed.title,
+          description: embed.description,
+          color: embed.color,
+          url: embed.url,
+          thumbnail: embed.thumbnail,
+          image: embed.image,
+          author: embed.author,
+          footer: embed.footer,
+          fields: embed.fields,
+          timestamp: embed.timestamp,
+        },
+      });
+    }
 
-        return segments;
+    // 贴纸消息
+    for (const sticker of msg.stickers.values()) {
+      segments.push({
+        type: "sticker",
+        data: {
+          id: sticker.id,
+          name: sticker.name,
+          url: sticker.url,
+          format: sticker.format,
+          tags: sticker.tags,
+        },
+      });
     }
 
-    async $sendMessage(options: SendOptions): Promise<string> {
-        options = await this.plugin.app.handleBeforeSend(options);
-
-        try {
-            const channel = await this.channels.fetch(options.id);
-            if (!channel || !channel.isTextBased()) {
-                throw new Error(`Channel ${options.id} is not a text channel`);
-            }
-
-            const result = await this.sendContentToChannel(channel as any, options.content);
-            this.plugin.logger.info(`send ${options.type}(${options.id}): ${segment.raw(options.content)}`);
-            return result.id;
-        } catch (error) {
-            this.plugin.logger.error('Failed to send Discord message:', error);
-            throw error;
-        }
+    return segments.length > 0
+      ? segments
+      : [{ type: "text", data: { text: "" } }];
+  }
+
+  // 解析文本内容，处理提及、频道引用、角色引用等
+  parseTextContent(
+    content: string,
+    msg: DiscordChannelMessage
+  ): MessageSegment[] {
+    const segments: MessageSegment[] = [];
+    let lastIndex = 0;
+
+    // 匹配用户提及 <@!?用户ID>
+    const userMentionRegex = /<@!?(\d+)>/g;
+    // 匹配频道提及 <#频道ID>
+    const channelMentionRegex = /<#(\d+)>/g;
+    // 匹配角色提及 <@&角色ID>
+    const roleMentionRegex = /<@&(\d+)>/g;
+    // 匹配自定义表情 <:名称:ID> 或 <a:名称:ID>
+    const emojiRegex = /<a?:(\w+):(\d+)>/g;
+
+    const allMatches: Array<{
+      match: RegExpExecArray;
+      type: "user" | "channel" | "role" | "emoji";
+    }> = [];
+
+    // 收集所有匹配项
+    let match;
+    while ((match = userMentionRegex.exec(content)) !== null) {
+      allMatches.push({ match, type: "user" });
+    }
+    while ((match = channelMentionRegex.exec(content)) !== null) {
+      allMatches.push({ match, type: "channel" });
+    }
+    while ((match = roleMentionRegex.exec(content)) !== null) {
+      allMatches.push({ match, type: "role" });
+    }
+    while ((match = emojiRegex.exec(content)) !== null) {
+      allMatches.push({ match, type: "emoji" });
     }
 
-    // 发送内容到频道
-    async sendContentToChannel(
-        channel: TextChannel | DMChannel | NewsChannel | ThreadChannel,
-        content: SendContent,
-        extraOptions: MessageCreateOptions = {}
-    ): Promise<DiscordMessage<boolean>> {
-        if (!Array.isArray(content)) content = [content];
+    // 按位置排序
+    allMatches.sort((a, b) => a.match.index! - b.match.index!);
 
-        const messageOptions: MessageCreateOptions = { ...extraOptions };
-        let textContent = '';
-        const embeds: EmbedBuilder[] = [];
-        const files: AttachmentBuilder[] = [];
-
-        for (const segment of content) {
-            if (typeof segment === 'string') {
-                textContent += segment;
-                continue;
-            }
-
-            const { type, data } = segment;
-
-            switch (type) {
-                case 'text':
-                    textContent += data.text || '';
-                    break;
-
-                case 'at':
-                    textContent += `<@${data.id}>`;
-                    break;
-
-                case 'channel_mention':
-                    textContent += `<#${data.id}>`;
-                    break;
-
-                case 'role_mention':
-                    textContent += `<@&${data.id}>`;
-                    break;
-
-                case 'emoji':
-                    textContent += data.animated ? `<a:${data.name}:${data.id}>` : `<:${data.name}:${data.id}>`;
-                    break;
-
-                case 'image':
-                case 'audio':
-                case 'video':
-                case 'file':
-                    await this.handleFileSegment(data, files, textContent);
-                    break;
-
-                case 'embed':
-                    embeds.push(this.createEmbedFromData(data));
-                    break;
-
-                default:
-                    // 未知类型作为文本处理
-                    textContent += data.text || `[${type}]`;
-            }
-        }
+    // 处理每个匹配项
+    for (const { match, type } of allMatches) {
+      const matchStart = match.index!;
+      const matchEnd = matchStart + match[0].length;
 
-        // 设置消息内容
-        if (textContent.trim()) {
-            messageOptions.content = textContent.trim();
+      // 添加匹配项前的文本
+      if (matchStart > lastIndex) {
+        const beforeText = content.slice(lastIndex, matchStart);
+        if (beforeText.trim()) {
+          segments.push({ type: "text", data: { text: beforeText } });
         }
+      }
+
+      // 添加特殊内容段
+      switch (type) {
+        case "user":
+          const userId = match[1];
+          const user = msg.mentions.users.get(userId);
+          segments.push({
+            type: "at",
+            data: {
+              id: userId,
+              name: user?.username || "Unknown",
+              text: match[0],
+            },
+          });
+          break;
+
+        case "channel":
+          const channelId = match[1];
+          const channel = msg.mentions.channels.get(channelId);
+          segments.push({
+            type: "channel_mention",
+            data: {
+              id: channelId,
+              name: (channel as any)?.name || "unknown-channel",
+              text: match[0],
+            },
+          });
+          break;
+
+        case "role":
+          const roleId = match[1];
+          const role = msg.mentions.roles.get(roleId);
+          segments.push({
+            type: "role_mention",
+            data: {
+              id: roleId,
+              name: role?.name || "unknown-role",
+              text: match[0],
+            },
+          });
+          break;
+
+        case "emoji":
+          const emojiName = match[1];
+          const emojiId = match[2];
+          const isAnimated = match[0].startsWith("<a:");
+          segments.push({
+            type: "emoji",
+            data: {
+              id: emojiId,
+              name: emojiName,
+              animated: isAnimated,
+              url: `https://cdn.discordapp.com/emojis/${emojiId}.${
+                isAnimated ? "gif" : "png"
+              }`,
+              text: match[0],
+            },
+          });
+          break;
+      }
 
-        if (embeds.length > 0) {
-            messageOptions.embeds = embeds.slice(0, 10); // Discord 限制最多10个embed
-        }
+      lastIndex = matchEnd;
+    }
 
-        if (files.length > 0) {
-            messageOptions.files = files;
-        }
+    // 添加最后剩余的文本
+    if (lastIndex < content.length) {
+      const remainingText = content.slice(lastIndex);
+      if (remainingText.trim()) {
+        segments.push({ type: "text", data: { text: remainingText } });
+      }
+    }
 
-        // 发送消息
-        return await channel.send(messageOptions);
+    return segments.length > 0
+      ? segments
+      : [{ type: "text", data: { text: content } }];
+  }
+
+  // 解析附件
+  parseAttachment(attachment: any): MessageSegment[] {
+    const segments: MessageSegment[] = [];
+
+    if (attachment.contentType?.startsWith("image/")) {
+      segments.push({
+        type: "image",
+        data: {
+          id: attachment.id,
+          name: attachment.name,
+          url: attachment.url,
+          proxy_url: attachment.proxyURL,
+          size: attachment.size,
+          width: attachment.width,
+          height: attachment.height,
+          content_type: attachment.contentType,
+        },
+      });
+    } else if (attachment.contentType?.startsWith("audio/")) {
+      segments.push({
+        type: "audio",
+        data: {
+          id: attachment.id,
+          name: attachment.name,
+          url: attachment.url,
+          proxy_url: attachment.proxyURL,
+          size: attachment.size,
+          content_type: attachment.contentType,
+        },
+      });
+    } else if (attachment.contentType?.startsWith("video/")) {
+      segments.push({
+        type: "video",
+        data: {
+          id: attachment.id,
+          name: attachment.name,
+          url: attachment.url,
+          proxy_url: attachment.proxyURL,
+          size: attachment.size,
+          width: attachment.width,
+          height: attachment.height,
+          content_type: attachment.contentType,
+        },
+      });
+    } else {
+      segments.push({
+        type: "file",
+        data: {
+          id: attachment.id,
+          name: attachment.name,
+          url: attachment.url,
+          proxy_url: attachment.proxyURL,
+          size: attachment.size,
+          content_type: attachment.contentType,
+        },
+      });
     }
-    async $recallMessage(id:string):Promise<void> {
-        
+
+    return segments;
+  }
+
+  async $sendMessage(options: SendOptions): Promise<string> {
+    options = await plugin.app.handleBeforeSend(options);
+
+    try {
+      const channel = await this.channels.fetch(options.id);
+      if (!channel || !channel.isTextBased()) {
+        throw new Error(`Channel ${options.id} is not a text channel`);
+      }
+
+      const result = await this.sendContentToChannel(
+        channel as any,
+        options.content
+      );
+      plugin.logger.info(
+        `send ${options.type}(${options.id}): ${segment.raw(options.content)}`
+      );
+      return result.id;
+    } catch (error) {
+      plugin.logger.error("Failed to send Discord message:", error);
+      throw error;
     }
-    // 处理文件段
-    async handleFileSegment(data: any, files: AttachmentBuilder[], textContent: string): Promise<void> {
-        if (data.file && await this.fileExists(data.file)) {
-            // 本地文件
-            files.push(new AttachmentBuilder(createReadStream(data.file), {
-                name: data.name || path.basename(data.file)
-            }));
-        } else if (data.url) {
-            // URL 文件
-            files.push(new AttachmentBuilder(data.url, {
-                name: data.name || 'attachment'
-            }));
-        } else if (data.buffer) {
-            // Buffer 数据
-            files.push(new AttachmentBuilder(data.buffer, {
-                name: data.name || 'attachment'
-            }));
-        }
+  }
+
+  // 发送内容到频道
+  async sendContentToChannel(
+    channel: TextChannel | DMChannel | NewsChannel | ThreadChannel,
+    content: SendContent,
+    extraOptions: MessageCreateOptions = {}
+  ): Promise<DiscordMessage<boolean>> {
+    if (!Array.isArray(content)) content = [content];
+
+    const messageOptions: MessageCreateOptions = { ...extraOptions };
+    let textContent = "";
+    const embeds: EmbedBuilder[] = [];
+    const files: AttachmentBuilder[] = [];
+
+    for (const segment of content) {
+      if (typeof segment === "string") {
+        textContent += segment;
+        continue;
+      }
+
+      const { type, data } = segment;
+
+      switch (type) {
+        case "text":
+          textContent += data.text || "";
+          break;
+
+        case "at":
+          textContent += `<@${data.id}>`;
+          break;
+
+        case "channel_mention":
+          textContent += `<#${data.id}>`;
+          break;
+
+        case "role_mention":
+          textContent += `<@&${data.id}>`;
+          break;
+
+        case "emoji":
+          textContent += data.animated
+            ? `<a:${data.name}:${data.id}>`
+            : `<:${data.name}:${data.id}>`;
+          break;
+
+        case "image":
+        case "audio":
+        case "video":
+        case "file":
+          await this.handleFileSegment(data, files, textContent);
+          break;
+
+        case "embed":
+          embeds.push(this.createEmbedFromData(data));
+          break;
+
+        default:
+          // 未知类型作为文本处理
+          textContent += data.text || `[${type}]`;
+      }
     }
 
-    // 从数据创建 Embed
-    createEmbedFromData(data: any): EmbedBuilder {
-        const embed = new EmbedBuilder();
-
-        if (data.title) embed.setTitle(data.title);
-        if (data.description) embed.setDescription(data.description);
-        if (data.color) embed.setColor(data.color);
-        if (data.url) embed.setURL(data.url);
-        if (data.thumbnail?.url) embed.setThumbnail(data.thumbnail.url);
-        if (data.image?.url) embed.setImage(data.image.url);
-        if (data.author) embed.setAuthor(data.author);
-        if (data.footer) embed.setFooter(data.footer);
-        if (data.timestamp) embed.setTimestamp(new Date(data.timestamp));
-        if (data.fields && Array.isArray(data.fields)) {
-            embed.addFields(data.fields);
-        }
-
-        return embed;
+    // 设置消息内容
+    if (textContent.trim()) {
+      messageOptions.content = textContent.trim();
     }
 
-    // 工具方法：获取活动类型
-    private getActivityType(type: string) {
-        const activityTypes = {
-            'PLAYING': 0,
-            'STREAMING': 1,
-            'LISTENING': 2,
-            'WATCHING': 3,
-            'COMPETING': 5
-        };
-        return activityTypes[type as keyof typeof activityTypes] || 0;
+    if (embeds.length > 0) {
+      messageOptions.embeds = embeds.slice(0, 10); // Discord 限制最多10个embed
     }
 
-    // 注册 Slash Commands
-    private async registerSlashCommands(): Promise<void> {
-        if (!this.$config.slashCommands || !this.user) return;
-
-        try {
-            const rest = new REST({ version: '10' }).setToken(this.$config.token);
-            
-            if (this.$config.globalCommands) {
-                // 注册全局命令
-                await rest.put(
-                    Routes.applicationCommands(this.user.id),
-                    { body: this.$config.slashCommands }
-                );
-                this.plugin.logger.info('Successfully registered global slash commands');
-            } else {
-                // 为每个服务器注册命令
-                for (const guild of this.guilds.cache.values()) {
-                    await rest.put(
-                        Routes.applicationGuildCommands(this.user.id, guild.id),
-                        { body: this.$config.slashCommands }
-                    );
-                }
-                this.plugin.logger.info('Successfully registered guild slash commands');
-            }
-        } catch (error) {
-            this.plugin.logger.error('Failed to register slash commands:', error);
-        }
+    if (files.length > 0) {
+      messageOptions.files = files;
     }
 
-    // 添加 Slash Command 处理器
-    addSlashCommandHandler(commandName: string, handler: (interaction: ChatInputCommandInteraction) => Promise<void>) {
-        this.slashCommandHandlers.set(commandName, handler);
+    // 发送消息
+    return await channel.send(messageOptions);
+  }
+  async $recallMessage(id: string): Promise<void> {}
+  // 处理文件段
+  async handleFileSegment(
+    data: any,
+    files: AttachmentBuilder[],
+    textContent: string
+  ): Promise<void> {
+    if (data.file && (await this.fileExists(data.file))) {
+      // 本地文件
+      files.push(
+        new AttachmentBuilder(createReadStream(data.file), {
+          name: data.name || path.basename(data.file),
+        })
+      );
+    } else if (data.url) {
+      // URL 文件
+      files.push(
+        new AttachmentBuilder(data.url, {
+          name: data.name || "attachment",
+        })
+      );
+    } else if (data.buffer) {
+      // Buffer 数据
+      files.push(
+        new AttachmentBuilder(data.buffer, {
+          name: data.name || "attachment",
+        })
+      );
     }
-
-    // 移除 Slash Command 处理器
-    removeSlashCommandHandler(commandName: string): boolean {
-        return this.slashCommandHandlers.delete(commandName);
+  }
+
+  // 从数据创建 Embed
+  createEmbedFromData(data: any): EmbedBuilder {
+    const embed = new EmbedBuilder();
+
+    if (data.title) embed.setTitle(data.title);
+    if (data.description) embed.setDescription(data.description);
+    if (data.color) embed.setColor(data.color);
+    if (data.url) embed.setURL(data.url);
+    if (data.thumbnail?.url) embed.setThumbnail(data.thumbnail.url);
+    if (data.image?.url) embed.setImage(data.image.url);
+    if (data.author) embed.setAuthor(data.author);
+    if (data.footer) embed.setFooter(data.footer);
+    if (data.timestamp) embed.setTimestamp(new Date(data.timestamp));
+    if (data.fields && Array.isArray(data.fields)) {
+      embed.addFields(data.fields);
     }
 
-    // 工具方法：检查文件是否存在
-    private async fileExists(filePath: string): Promise<boolean> {
-        try {
-            await fs.access(filePath);
-            return true;
-        } catch {
-            return false;
+    return embed;
+  }
+
+  // 工具方法：获取活动类型
+  private getActivityType(type: string) {
+    const activityTypes = {
+      PLAYING: 0,
+      STREAMING: 1,
+      LISTENING: 2,
+      WATCHING: 3,
+      COMPETING: 5,
+    };
+    return activityTypes[type as keyof typeof activityTypes] || 0;
+  }
+
+  // 注册 Slash Commands
+  private async registerSlashCommands(): Promise<void> {
+    if (!this.$config.slashCommands || !this.user) return;
+
+    try {
+      const rest = new REST({ version: "10" }).setToken(this.$config.token);
+
+      if (this.$config.globalCommands) {
+        // 注册全局命令
+        await rest.put(Routes.applicationCommands(this.user.id), {
+          body: this.$config.slashCommands,
+        });
+        plugin.logger.info("Successfully registered global slash commands");
+      } else {
+        // 为每个服务器注册命令
+        for (const guild of this.guilds.cache.values()) {
+          await rest.put(
+            Routes.applicationGuildCommands(this.user.id, guild.id),
+            { body: this.$config.slashCommands }
+          );
         }
+        plugin.logger.info("Successfully registered guild slash commands");
+      }
+    } catch (error) {
+      plugin.logger.error("Failed to register slash commands:", error);
     }
-
-    // 静态方法：格式化内容为文本（用于日志显示）
-    static formatContentToText(content: SendContent): string {
-        if (!Array.isArray(content)) content = [content];
-
-        return content.map(segment => {
-            if (typeof segment === 'string') return segment;
-
-            switch (segment.type) {
-                case 'text':
-                    return segment.data.text || '';
-                case 'at':
-                    return `@${segment.data.name || segment.data.id}`;
-                case 'channel_mention':
-                    return `#${segment.data.name}`;
-                case 'role_mention':
-                    return `@${segment.data.name}`;
-                case 'image':
-                    return '[图片]';
-                case 'audio':
-                    return '[音频]';
-                case 'video':
-                    return '[视频]';
-                case 'file':
-                    return '[文件]';
-                case 'embed':
-                    return '[嵌入消息]';
-                case 'emoji':
-                    return `:${segment.data.name}:`;
-                default:
-                    return `[${segment.type}]`;
-            }
-        }).join('');
+  }
+
+  // 添加 Slash Command 处理器
+  addSlashCommandHandler(
+    commandName: string,
+    handler: (interaction: ChatInputCommandInteraction) => Promise<void>
+  ) {
+    this.slashCommandHandlers.set(commandName, handler);
+  }
+
+  // 移除 Slash Command 处理器
+  removeSlashCommandHandler(commandName: string): boolean {
+    return this.slashCommandHandlers.delete(commandName);
+  }
+
+  // 工具方法：检查文件是否存在
+  private async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
     }
+  }
+
+  // 静态方法：格式化内容为文本（用于日志显示）
+  static formatContentToText(content: SendContent): string {
+    if (!Array.isArray(content)) content = [content];
+
+    return content
+      .map((segment) => {
+        if (typeof segment === "string") return segment;
+
+        switch (segment.type) {
+          case "text":
+            return segment.data.text || "";
+          case "at":
+            return `@${segment.data.name || segment.data.id}`;
+          case "channel_mention":
+            return `#${segment.data.name}`;
+          case "role_mention":
+            return `@${segment.data.name}`;
+          case "image":
+            return "[图片]";
+          case "audio":
+            return "[音频]";
+          case "video":
+            return "[视频]";
+          case "file":
+            return "[文件]";
+          case "embed":
+            return "[嵌入消息]";
+          case "emoji":
+            return `:${segment.data.name}:`;
+          default:
+            return `[${segment.type}]`;
+        }
+      })
+      .join("");
+  }
 }
 
 // ================================================================================================
 // DiscordInteractionsBot 类（Interactions 端点模式）
 // ================================================================================================
 
-import * as nacl from 'tweetnacl';
-
-export class DiscordInteractionsBot extends Client implements Bot<any, DiscordInteractionsConfig> {
-    $connected?: boolean
-    private router: any
-    private slashCommandHandlers: Map<string, (interaction: any) => Promise<void>> = new Map()
-
-    constructor(private plugin: Plugin, router: any, public $config: DiscordInteractionsConfig) {
-        const intents = $config.intents || [
-            GatewayIntentBits.Guilds,
-            GatewayIntentBits.GuildMessages,
-            GatewayIntentBits.MessageContent,
-        ];
-        
-        super({ intents });
-        this.$connected = false;
-        this.router = router;
-        
-        // 设置交互端点路由
-        this.setupInteractionsEndpoint();
+import * as nacl from "tweetnacl";
+
+export class DiscordInteractionsBot
+  extends Client
+  implements Bot<any, DiscordInteractionsConfig>
+{
+  $connected?: boolean;
+  private router: any;
+  private slashCommandHandlers: Map<
+    string,
+    (interaction: any) => Promise<void>
+  > = new Map();
+
+  constructor(router: any, public $config: DiscordInteractionsConfig) {
+    const intents = $config.intents || [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+    ];
+
+    super({ intents });
+    this.$connected = false;
+    this.router = router;
+
+    // 设置交互端点路由
+    this.setupInteractionsEndpoint();
+  }
+
+  private setupInteractionsEndpoint(): void {
+    // 设置路由处理 Discord Interactions
+    this.router.post(this.$config.interactionsPath, (ctx: Context) => {
+      this.handleInteraction(ctx);
+    });
+  }
+
+  private async handleInteraction(ctx: Context): Promise<void> {
+    try {
+      const signature = ctx.get("x-signature-ed25519");
+      const timestamp = ctx.get("x-signature-timestamp");
+      const bodyString = JSON.stringify((ctx.request as any).body);
+
+      // 验证请求签名
+      if (!this.verifyDiscordSignature(bodyString, signature, timestamp)) {
+        plugin.logger.warn("Invalid Discord signature");
+        ctx.status = 401;
+        ctx.body = "Unauthorized";
+        return;
+      }
+
+      const interaction = (ctx.request as any).body;
+
+      // 处理不同类型的交互
+      if (interaction.type === InteractionType.Ping) {
+        // PING - Discord 验证端点
+        ctx.body = { type: InteractionResponseType.Pong };
+      } else if (interaction.type === InteractionType.ApplicationCommand) {
+        // APPLICATION_COMMAND - 应用命令
+        const response = await this.handleApplicationCommand(interaction);
+        ctx.body = response;
+      } else {
+        // 其他交互类型
+        ctx.status = 400;
+        ctx.body = "Unsupported interaction type";
+      }
+    } catch (error) {
+      plugin.logger.error("Interactions error:", error);
+      ctx.status = 500;
+      ctx.body = "Internal Server Error";
     }
-
-    private setupInteractionsEndpoint(): void {
-        // 设置路由处理 Discord Interactions
-        this.router.post(this.$config.interactionsPath, (ctx: Context) => {
-            this.handleInteraction(ctx);
-        });
+  }
+
+  private verifyDiscordSignature(
+    body: string,
+    signature: string,
+    timestamp: string
+  ): boolean {
+    try {
+      const publicKey = Buffer.from(this.$config.publicKey, "hex");
+      const sig = Buffer.from(signature, "hex");
+      const message = Buffer.from(timestamp + body, "utf8");
+
+      return nacl.sign.detached.verify(message, sig, publicKey);
+    } catch (error) {
+      plugin.logger.error("Signature verification error:", error);
+      return false;
     }
-
-    private async handleInteraction(ctx: Context): Promise<void> {
-        try {
-            const signature = ctx.get('x-signature-ed25519');
-            const timestamp = ctx.get('x-signature-timestamp');
-            const bodyString = JSON.stringify((ctx.request as any).body);
-
-            // 验证请求签名
-            if (!this.verifyDiscordSignature(bodyString, signature, timestamp)) {
-                this.plugin.logger.warn('Invalid Discord signature');
-                ctx.status = 401;
-                ctx.body = 'Unauthorized';
-                return;
-            }
-
-            const interaction = (ctx.request as any).body;
-
-            // 处理不同类型的交互
-            if (interaction.type === InteractionType.Ping) {
-                // PING - Discord 验证端点
-                ctx.body = { type: InteractionResponseType.Pong };
-            } else if (interaction.type === InteractionType.ApplicationCommand) {
-                // APPLICATION_COMMAND - 应用命令
-                const response = await this.handleApplicationCommand(interaction);
-                ctx.body = response;
-            } else {
-                // 其他交互类型
-                ctx.status = 400;
-                ctx.body = 'Unsupported interaction type';
-            }
-
-        } catch (error) {
-            this.plugin.logger.error('Interactions error:', error);
-            ctx.status = 500;
-            ctx.body = 'Internal Server Error';
-        }
+  }
+
+  private async handleApplicationCommand(interaction: any): Promise<any> {
+    // 处理应用命令
+    const commandName = interaction.data.name;
+
+    // 转换为标准消息格式并分发
+    const message = this.formatInteractionAsMessage(interaction);
+    plugin.dispatch("message.receive", message);
+
+    // 查找自定义处理器
+    const handler = this.slashCommandHandlers.get(commandName);
+    if (handler) {
+      try {
+        await handler(interaction);
+      } catch (error) {
+        plugin.logger.error(
+          `Error in slash command handler for ${commandName}:`,
+          error
+        );
+      }
     }
 
-    private verifyDiscordSignature(body: string, signature: string, timestamp: string): boolean {
-        try {
-            const publicKey = Buffer.from(this.$config.publicKey, 'hex');
-            const sig = Buffer.from(signature, 'hex');
-            const message = Buffer.from(timestamp + body, 'utf8');
-            
-            return nacl.sign.detached.verify(message, sig, publicKey);
-        } catch (error) {
-            this.plugin.logger.error('Signature verification error:', error);
-            return false;
-        }
+    // 默认响应
+    return {
+      type: InteractionResponseType.ChannelMessageWithSource,
+      data: {
+        content: `处理命令: ${commandName}`,
+        flags: 64, // EPHEMERAL - 只有用户可见
+      },
+    };
+  }
+
+  private formatInteractionAsMessage(interaction: any): Message<any> {
+    const channelType = interaction.guild_id ? "channel" : "private";
+    const channelId = interaction.channel_id;
+
+    // 解析命令参数为内容
+    const options = interaction.data.options || [];
+    const content = [segment.text(`/${interaction.data.name}`)];
+
+    for (const option of options) {
+      content.push(segment.text(` ${option.name}:${option.value}`));
     }
 
-    private async handleApplicationCommand(interaction: any): Promise<any> {
-        // 处理应用命令
-        const commandName = interaction.data.name;
-        
-        // 转换为标准消息格式并分发
-        const message = this.formatInteractionAsMessage(interaction);
-        this.plugin.dispatch('message.receive', message);
-        
-        // 查找自定义处理器
-        const handler = this.slashCommandHandlers.get(commandName);
-        if (handler) {
-            try {
-                await handler(interaction);
-            } catch (error) {
-                this.plugin.logger.error(`Error in slash command handler for ${commandName}:`, error);
-            }
-        }
+    return Message.from(interaction, {
+      $id: interaction.id,
+      $adapter: "discord-interactions",
+      $bot: this.$config.name,
+      $sender: {
+        id: interaction.user?.id || interaction.member?.user?.id,
+        name: interaction.user?.username || interaction.member?.user?.username,
+      },
+      $channel: {
+        id: channelId,
+        type: channelType as any,
+      },
+      $raw: JSON.stringify(interaction),
+      $timestamp: Date.now(),
+      $content: content,
+      $reply: async (content: SendContent): Promise<string> => {
+        return this.$sendMessage({
+          ...this.$formatMessage(interaction),
+          content: content,
+        });
+      },
+    });
+  }
 
-        // 默认响应
-        return {
-            type: InteractionResponseType.ChannelMessageWithSource,
-            data: {
-                content: `处理命令: ${commandName}`,
-                flags: 64 // EPHEMERAL - 只有用户可见
-            }
-        };
+  private formatSendContent(content: SendContent): any {
+    if (typeof content === "string") {
+      return { content };
     }
 
-    private formatInteractionAsMessage(interaction: any): Message<any> {
-        const channelType = interaction.guild_id ? 'channel' : 'private';
-        const channelId = interaction.channel_id;
-        
-        // 解析命令参数为内容
-        const options = interaction.data.options || [];
-        const content = [segment.text(`/${interaction.data.name}`)];
-        
-        for (const option of options) {
-            content.push(segment.text(` ${option.name}:${option.value}`));
-        }
-        
-        return Message.from(interaction, {
-            $id: interaction.id,
-            $adapter: 'discord-interactions',
-            $bot: this.$config.name,
-            $sender: {
-                id: interaction.user?.id || interaction.member?.user?.id,
-                name: interaction.user?.username || interaction.member?.user?.username
-            },
-            $channel: {
-                id: channelId,
-                type: channelType as any
-            },
-            $raw: JSON.stringify(interaction),
-            $timestamp: Date.now(),
-            $content: content,
-            $reply: async (content: SendContent): Promise<string> => {
-                return this.$sendMessage({
-                    ...this.$formatMessage(interaction),
-                    content: content
-                });
-            }
-        });
-    }
+    if (Array.isArray(content)) {
+      const textParts: string[] = [];
+      let embed: any = null;
 
-    private formatSendContent(content: SendContent): any {
-        if (typeof content === 'string') {
-            return { content };
-        }
-        
-        if (Array.isArray(content)) {
-            const textParts: string[] = [];
-            let embed: any = null;
-            
-            for (const item of content) {
-                if (typeof item === 'string') {
-                    textParts.push(item);
-                } else {
-                    const segment = item as MessageSegment;
-                    switch (segment.type) {
-                        case 'text':
-                            textParts.push(segment.data.text || segment.data.content || '');
-                            break;
-                        case 'embed':
-                            embed = segment.data;
-                            break;
-                    }
-                }
-            }
-            
-            const result: any = {};
-            if (textParts.length > 0) {
-                result.content = textParts.join('');
-            }
-            if (embed) {
-                result.embeds = [embed];
-            }
-            
-            return result;
+      for (const item of content) {
+        if (typeof item === "string") {
+          textParts.push(item);
+        } else {
+          const segment = item as MessageSegment;
+          switch (segment.type) {
+            case "text":
+              textParts.push(segment.data.text || segment.data.content || "");
+              break;
+            case "embed":
+              embed = segment.data;
+              break;
+          }
         }
-        
-        return { content: String(content) };
-    }
+      }
 
-    async $connect(): Promise<void> {
-        try {
-            // 注册 Slash Commands
-            if (this.$config.slashCommands) {
-                await this.registerSlashCommands();
-            }
-            
-            // 如果启用 Gateway，连接 Discord Gateway
-            if (this.$config.useGateway) {
-                await this.login(this.$config.token);
-                
-                // 设置活动状态
-                if (this.$config.defaultActivity) {
-                    this.user?.setActivity(this.$config.defaultActivity.name, {
-                        type: this.getActivityType(this.$config.defaultActivity.type),
-                        url: this.$config.defaultActivity.url
-                    });
-                }
-            }
-            
-            this.$connected = true;
-            this.plugin.logger.info(`Discord interactions bot connected: ${this.$config.name}`);
-            this.plugin.logger.info(`Interactions endpoint: ${this.$config.interactionsPath}`);
-            
-        } catch (error) {
-            this.plugin.logger.error('Failed to connect Discord interactions bot:', error);
-            throw error;
-        }
-    }
+      const result: any = {};
+      if (textParts.length > 0) {
+        result.content = textParts.join("");
+      }
+      if (embed) {
+        result.embeds = [embed];
+      }
 
-    async $disconnect(): Promise<void> {
-        try {
-            if (this.isReady()) {
-                await this.destroy();
-            }
-            this.$connected = false;
-            this.plugin.logger.info('Discord interactions bot disconnected');
-        } catch (error) {
-            this.plugin.logger.error('Error disconnecting Discord interactions bot:', error);
-        }
+      return result;
     }
 
-    // Slash Commands 管理
-    private async registerSlashCommands(): Promise<void> {
-        if (!this.$config.slashCommands) return;
-
-        try {
-            const rest = new REST({ version: '10' }).setToken(this.$config.token);
-            
-            if (this.$config.globalCommands) {
-                await rest.put(
-                    Routes.applicationCommands(this.$config.applicationId),
-                    { body: this.$config.slashCommands }
-                );
-                this.plugin.logger.info('Successfully registered global slash commands');
-            } else {
-                this.plugin.logger.info('Note: Guild commands registration requires connecting to Gateway first');
-            }
-        } catch (error) {
-            this.plugin.logger.error('Failed to register slash commands:', error);
+    return { content: String(content) };
+  }
+
+  async $connect(): Promise<void> {
+    try {
+      // 注册 Slash Commands
+      if (this.$config.slashCommands) {
+        await this.registerSlashCommands();
+      }
+
+      // 如果启用 Gateway，连接 Discord Gateway
+      if (this.$config.useGateway) {
+        await this.login(this.$config.token);
+
+        // 设置活动状态
+        if (this.$config.defaultActivity) {
+          this.user?.setActivity(this.$config.defaultActivity.name, {
+            type: this.getActivityType(this.$config.defaultActivity.type),
+            url: this.$config.defaultActivity.url,
+          });
         }
+      }
+
+      this.$connected = true;
+      plugin.logger.info(
+        `Discord interactions bot connected: ${this.$config.name}`
+      );
+      plugin.logger.info(
+        `Interactions endpoint: ${this.$config.interactionsPath}`
+      );
+    } catch (error) {
+      plugin.logger.error("Failed to connect Discord interactions bot:", error);
+      throw error;
     }
-
-    // 添加 Slash Command 处理器
-    addSlashCommandHandler(commandName: string, handler: (interaction: any) => Promise<void>): void {
-        this.slashCommandHandlers.set(commandName, handler);
-    }
-
-    // 移除 Slash Command 处理器
-    removeSlashCommandHandler(commandName: string): boolean {
-        return this.slashCommandHandlers.delete(commandName);
+  }
+
+  async $disconnect(): Promise<void> {
+    try {
+      if (this.isReady()) {
+        await this.destroy();
+      }
+      this.$connected = false;
+      plugin.logger.info("Discord interactions bot disconnected");
+    } catch (error) {
+      plugin.logger.error(
+        "Error disconnecting Discord interactions bot:",
+        error
+      );
     }
+  }
 
-    // 工具方法
-    private getActivityType(type: string): any {
-        const activityTypes: any = {
-            'PLAYING': 0,
-            'STREAMING': 1,
-            'LISTENING': 2,
-            'WATCHING': 3,
-            'COMPETING': 5
-        };
-        return activityTypes[type] || 0;
-    }
+  // Slash Commands 管理
+  private async registerSlashCommands(): Promise<void> {
+    if (!this.$config.slashCommands) return;
 
-    // 简化实现 - 只支持基本消息格式化和发送
-    $formatMessage(msg: any): Message<any> {
-        return this.formatInteractionAsMessage(msg);
-    }
+    try {
+      const rest = new REST({ version: "10" }).setToken(this.$config.token);
 
-    async $sendMessage(options: SendOptions): Promise<string> {
-        // 简化实现 - 通过 REST API 发送消息
-        try {
-            const rest = new REST({ version: '10' }).setToken(this.$config.token);
-            const messageContent = this.formatSendContent(options.content);
-            
-            await rest.post(
-                Routes.channelMessages(options.id),
-                { body: messageContent }
-            );
-        } catch (error) {
-            this.plugin.logger.error('Failed to send message:', error);
-        }
-        return ''
+      if (this.$config.globalCommands) {
+        await rest.put(Routes.applicationCommands(this.$config.applicationId), {
+          body: this.$config.slashCommands,
+        });
+        plugin.logger.info("Successfully registered global slash commands");
+      } else {
+        plugin.logger.info(
+          "Note: Guild commands registration requires connecting to Gateway first"
+        );
+      }
+    } catch (error) {
+      plugin.logger.error("Failed to register slash commands:", error);
     }
-    async $recallMessage(id:string):Promise<void> {
-        
+  }
+
+  // 添加 Slash Command 处理器
+  addSlashCommandHandler(
+    commandName: string,
+    handler: (interaction: any) => Promise<void>
+  ): void {
+    this.slashCommandHandlers.set(commandName, handler);
+  }
+
+  // 移除 Slash Command 处理器
+  removeSlashCommandHandler(commandName: string): boolean {
+    return this.slashCommandHandlers.delete(commandName);
+  }
+
+  // 工具方法
+  private getActivityType(type: string): any {
+    const activityTypes: any = {
+      PLAYING: 0,
+      STREAMING: 1,
+      LISTENING: 2,
+      WATCHING: 3,
+      COMPETING: 5,
+    };
+    return activityTypes[type] || 0;
+  }
+
+  // 简化实现 - 只支持基本消息格式化和发送
+  $formatMessage(msg: any): Message<any> {
+    return this.formatInteractionAsMessage(msg);
+  }
+
+  async $sendMessage(options: SendOptions): Promise<string> {
+    // 简化实现 - 通过 REST API 发送消息
+    try {
+      const rest = new REST({ version: "10" }).setToken(this.$config.token);
+      const messageContent = this.formatSendContent(options.content);
+
+      await rest.post(Routes.channelMessages(options.id), {
+        body: messageContent,
+      });
+    } catch (error) {
+      plugin.logger.error("Failed to send message:", error);
     }
+    return "";
+  }
+  async $recallMessage(id: string): Promise<void> {}
 }
 
 // 注册 Gateway 模式适配器
-registerAdapter(new Adapter('discord', (plugin: Plugin, config: any) => new DiscordBot(plugin, config as DiscordBotConfig)))
+registerAdapter(
+  new Adapter(
+    "discord",
+    (config: any) => new DiscordBot(config as DiscordBotConfig)
+  )
+);
 
 // 注册 Interactions 端点模式适配器（需要 router）
-useContext('router', (router) => {
-    registerAdapter(new Adapter('discord-interactions',
-        (plugin: Plugin, config: any) => new DiscordInteractionsBot(plugin, router, config as DiscordInteractionsConfig)
-    ));
+useContext("router", (router) => {
+  registerAdapter(
+    new Adapter(
+      "discord-interactions",
+      (config: any) =>
+        new DiscordInteractionsBot(router, config as DiscordInteractionsConfig)
+    )
+  );
 });