@zhin.js/adapter-discord 5.0.2 → 5.0.3

package/src/endpoint.ts

@@ -1,1239 +1,457 @@
 /**
- * Discord Endpoint 实现 (Gateway)
+ * DiscordEndpoint — lifecycle, outbound, admit, gateway / interactions modes, agent tool surface.
  */
+import { ChannelType } from 'discord.js';
+import type { EndpointInstance } from '@zhin.js/adapter';
+import type { MessageGateway } from '@zhin.js/core/runtime';
+import type { HttpHost, HttpRouteRegistration } from '@zhin.js/host-http';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import type { CapabilityId } from '@zhin.js/plugin-runtime';
+import { registerDiscordAgentEndpoint } from './discord-agent-deps.js';
 import {
-  Client,
-  GatewayIntentBits,
-  Message as DiscordMessage,
-  TextChannel,
-  DMChannel,
-  NewsChannel,
-  ThreadChannel,
-  EmbedBuilder,
-  AttachmentBuilder,
-  MessageCreateOptions,
-  ChannelType,
-  REST,
-  Routes,
-  ApplicationCommandData,
-  ChatInputCommandInteraction,
-  ButtonInteraction,
-  InteractionType,
-  InteractionResponseType,
-  GuildMember,
-  ActionRowBuilder,
-  ButtonBuilder,
-  ButtonStyle,
-  PermissionFlagsBits,
-  type MessageEditOptions as DiscordEditMessageOptions,
-} from 'discord.js';
+  connectDiscordGatewayClient,
+  defaultCreateClient,
+  DEFAULT_INTENTS,
+  resolveSenderRole,
+  toMessageCreateOptions,
+  type CreateDiscordClient,
+  type DiscordClientTransport,
+} from './gateway.js';
 import {
-  Endpoint,
-  Message,
-  SendOptions,
-  SendContent,
-  MessageSegment,
-  segment,
-  expandInteractiveSegmentsInContent,
-  type EditMessageOptions,
-} from 'zhin.js';
-import type { DiscordGatewayConfig, DiscordChannelMessage } from "./types.js";
-import type { DiscordAdapter } from "./adapter.js";
-import { createReadStream, promises as fs } from 'fs';
-
-import path from "path";
-import { fromCanonicalSegments, toCanonicalSegments } from './segment-mapper.js';
-
-export class DiscordEndpoint
-  extends Client
-  implements Endpoint<DiscordGatewayConfig, DiscordChannelMessage> {
-  private slashCommandHandlers: Map<
-    string,
-    (interaction: ChatInputCommandInteraction) => Promise<void>
-  > = new Map();
-  /** message_id -> channel_id，用于在仅有 message_id 的场景执行 reaction 操作 */
-  private readonly messageChannelMap = new Map<string, string>();
-  $connected: boolean = false;
-  get pluginLogger() {
-    return this.adapter.plugin.logger;
-  }
-
-  get $id() {
-    return this.$config.name;
-  }
-
-  constructor(public adapter: DiscordAdapter, public $config: DiscordGatewayConfig) {
-    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.adapter.emit("message.receive", message);
-    this.pluginLogger.debug(
-      `${this.$config.name} recv  ${message.$channel.type}(${message.$channel.id}): ${segment.raw(
-        message.$content
-      )}`
-    );
-  }
-
-  private async handleSlashCommand(
-    interaction: ChatInputCommandInteraction
-  ): Promise<void> {
-    const commandName = interaction.commandName;
-    const handler = this.slashCommandHandlers.get(commandName);
+  formatButtonContent,
+  formatInboundContent,
+  formatOutboundBody,
+  senderDisplayName,
+  type DiscordButtonInbound,
+  type DiscordInboundMessage,
+  type DiscordOutboundBody,
+  type ResolvedDiscordGatewayConfig,
+  type ResolvedDiscordInteractionsConfig,
+} from './protocol.js';
+import { registerDiscordInteractionRoutes } from './webhook.js';
+
+const DISCORD_API = 'https://discord.com/api/v10';
+const logger = getLogger('discord');
+
+export type {
+  CreateDiscordClient,
+  DiscordClientTransport,
+} from './gateway.js';
+
+export interface DiscordEndpointOptions {
+  readonly id: CapabilityId;
+  readonly gateway: MessageGateway;
+  readonly config: ResolvedDiscordGatewayConfig;
+  readonly createClient?: CreateDiscordClient;
+}
 
-    if (handler) {
-      try {
-        await handler(interaction);
-        this.pluginLogger.info(
-          `Executed slash command: /${commandName} by ${interaction.user.tag}`
-        );
-      } catch (error) {
-        this.pluginLogger.error(
-          `Error executing slash command /${commandName}:`,
-          error
-        );
+export class DiscordGatewayEndpoint implements EndpointInstance {
+  readonly #options: DiscordEndpointOptions;
+  readonly #createClient: CreateDiscordClient;
+  #client: DiscordClientTransport | null = null;
+  #open = false;
+  #started = false;
+  #unregisterAgent?: () => void;
+  readonly #messageChannelMap = new Map<string, string>();
 
-        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 });
-        }
-      }
-    } else {
-      this.pluginLogger.warn(`Unknown slash command: /${commandName}`);
-      if (!interaction.replied) {
-        await interaction.reply({
-          content: "Unknown command.",
-          ephemeral: true,
-        });
-      }
-    }
+  constructor(options: DiscordEndpointOptions) {
+    this.#options = options;
+    this.#createClient = options.createClient ?? defaultCreateClient;
   }
 
-  private async handleButtonInteraction(interaction: ButtonInteraction): Promise<void> {
+  async start(): Promise<void> {
+    if (this.#started) return;
+    this.#started = true;
     try {
-      await interaction.deferUpdate();
-    } catch {
-      // already acknowledged
-    }
-    const channel = interaction.channel;
-    if (!channel) return;
-    const channelType = channel.type === ChannelType.DM ? "private" : "group";
-    const message = Message.from(interaction, {
-      $id: interaction.id,
-      $adapter: "discord",
-      $endpoint: this.$config.name,
-      $sender: {
-        id: interaction.user.id,
-        name: interaction.user.username || interaction.user.displayName,
-      },
-      $channel: {
-        id: channel.id,
-        type: channelType,
-      },
-      $content: [{
-        type: "action",
-        data: {
-          id: interaction.customId,
-          payload: interaction.customId,
-          sourceMessageId: interaction.message?.id,
-        },
-      }],
-      $raw: interaction.customId,
-      $timestamp: Date.now(),
-      $recall: async () => {},
-      $reply: async (content: SendContent): Promise<string> => {
-        if (!interaction.channel?.isTextBased()) return "";
-        const result = await this.sendContentToChannel(interaction.channel as TextChannel, content);
-        return result.id;
-      },
-    });
-    this.adapter.emit("message.receive", message);
-  }
-
-  async $connect(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      // 监听消息事件
-      this.on("messageCreate", this.handleDiscordMessage.bind(this));
-
-      // 监听交互事件（Slash Commands + 按钮）
-      this.on("interactionCreate", async (interaction) => {
-        if (interaction.isChatInputCommand() && this.$config.enableSlashCommands) {
-          await this.handleSlashCommand(interaction);
-          return;
-        }
-        if (interaction.isButton()) {
-          await this.handleButtonInteraction(interaction);
-        }
+      this.#unregisterAgent = registerDiscordAgentEndpoint(this.#options.config.name, this);
+      const intents = this.#options.config.intents?.length
+        ? [...this.#options.config.intents]
+        : DEFAULT_INTENTS;
+      this.#client = this.#createClient(intents);
+      await connectDiscordGatewayClient(this.#client, this.#options.config, {
+        onMessage: (msg) => this.admit(msg),
+        onButton: (interaction) => this.admitButton(interaction),
       });
-
-      // 监听就绪事件
-      this.once("clientReady", async () => {
-        this.$connected = true;
-        this.pluginLogger.info(
-          `Discord endpoint ${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.pluginLogger.error("Discord client error:", error);
-        this.$connected = false;
-        reject(error);
-      });
-
-      // 登录
-      this.login(this.$config.token).catch((error) => {
-        this.pluginLogger.error("Failed to login to Discord:", error);
-        this.$connected = false;
-        reject(error);
-      });
-    });
-  }
-
-  async $disconnect(): Promise<void> {
-    try {
-      (this as unknown as import('node:events').EventEmitter).removeAllListeners();
-      await this.destroy();
-      this.$connected = false;
-      this.pluginLogger.info(`Discord endpoint ${this.$config.name} disconnected`);
+      logger.info(formatCompact({
+        op: 'connect',
+        endpoint: this.#options.config.name,
+        mode: 'gateway',
+        user: this.#client.user?.tag,
+      }));
     } catch (error) {
-      this.pluginLogger.error("Error disconnecting Discord bot:", error);
+      await this.stop();
+      logger.error('Failed to connect Discord gateway:', 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;
-    }
+  open(): void {
+    this.#open = true;
+  }
 
-    // 转换消息内容为 segment 格式
-    const wire = this.parseMessageContent(msg);
-    const content = toCanonicalSegments(wire);
+  close(): void {
+    this.#open = false;
+  }
 
-    const sender = (() => {
-      const base = {
-        id: msg.author.id,
-        name: msg.member?.displayName || msg.author.displayName,
-      } as { id: string; name: string; role?: string; permissions?: string[] };
-      const member = msg.member;
-      const guild = msg.guild;
-      if (member && guild) {
-        const tokens: string[] = [];
-        const permChecks: Array<[bigint, string]> = [
-          [PermissionFlagsBits.Administrator, "ADMINISTRATOR"],
-          [PermissionFlagsBits.ManageRoles, "MANAGE_ROLES"],
-          [PermissionFlagsBits.ModerateMembers, "MODERATE_MEMBERS"],
-          [PermissionFlagsBits.ManageChannels, "MANAGE_CHANNELS"],
-          [PermissionFlagsBits.ManageGuild, "MANAGE_GUILD"],
-        ];
-        for (const [bit, name] of permChecks) {
-          if (member.permissions.has(bit)) tokens.push(name);
-        }
-        if (guild.ownerId === msg.author.id) {
-          base.role = "owner";
-          tokens.push("guild_owner", "ADMINISTRATOR");
-        } else if (tokens.includes("ADMINISTRATOR") || tokens.includes("MODERATE_MEMBERS")) {
-          base.role = "admin";
-        } else {
-          base.role = "member";
-        }
-        base.permissions = tokens;
+  async stop(): Promise<void> {
+    this.#open = false;
+    this.#unregisterAgent?.();
+    this.#unregisterAgent = undefined;
+    if (this.#client) {
+      try {
+        this.#client.removeAllListeners();
+        await this.#client.destroy();
+      } catch {
+        /* ignore */
       }
-      return base;
-    })();
-
-    const result = Message.from(msg, {
-      $id: msg.id,
-      $adapter: "discord",
-      $endpoint: this.$config.name,
-      $sender: sender,
-      $channel: {
-        id: channelId,
-        type: channelType,
-      },
-      $content: content,
-      $raw: msg.content,
-      $timestamp: msg.createdTimestamp,
-      $recall: async () => {
-        await msg.delete();
-      },
-      $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.pluginLogger.warn(
-              `Could not find message to reply to: ${replyId}`
-            );
-          }
-        }
-
-        const res = await this.adapter.sendMessage({
-          context: "discord",
-          endpoint: this.$config.name,
-          id: msg.channel.id,
-          type: msg.channel.type as any,
-          content: content,
-        });
-        return res;
-      },
+      this.#client = null;
+    }
+    this.#started = false;
+    logger.debug(formatCompact({ op: 'disconnect', endpoint: this.#options.config.name }));
+  }
+
+  async send({ target, payload }: { readonly target: string; readonly payload: unknown }): Promise<string> {
+    const body = formatOutboundBody(payload);
+    const messageId = await this.#sendBody(target, body);
+    this.#messageChannelMap.set(messageId, target);
+    logger.debug(formatCompact({
+      op: 'discord_send',
+      endpoint: this.#options.config.name,
+      target,
+      messageId,
+    }));
+    return messageId;
+  }
+
+  /** Test / internal: admit a message when open. */
+  admit(msg: DiscordInboundMessage): void {
+    if (!this.#open) return;
+    if (msg.authorBot) return;
+    this.#messageChannelMap.set(msg.id, msg.channelId);
+    void this.#options.gateway.receive({
+      adapter: this.#options.id,
+      target: msg.channelId,
+      content: formatInboundContent(msg),
+      sender: senderDisplayName(msg),
+      id: msg.id,
+      metadata: Object.freeze({
+        endpoint: this.#options.config.name,
+        channelKind: msg.channelKind,
+        userId: msg.authorId,
+        guildId: msg.guildId,
+        permissions: msg.permissionTokens,
+        role: resolveSenderRole(msg),
+        ...(msg.mentionedBot ? { mentioned: true } : {}),
+      }),
+    }).catch((err) => {
+      logger.warn(formatCompact({
+        op: 'discord_gateway_receive_failed',
+        target: msg.channelId,
+        error: err instanceof Error ? err.message : String(err),
+      }));
     });
-
-    this.messageChannelMap.set(result.$id, channelId);
-
-    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,
-        },
-      });
-    }
-
-    // 文本消息（包含提及、表情等）
-    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,
-        },
-      });
-    }
-
-    // 贴纸消息
-    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,
-        },
-      });
-    }
-
-    return segments.length > 0
-      ? segments
-      : [{ type: "text", data: { text: "" } }];
+  /** Test / internal: admit a button interaction when open. */
+  admitButton(interaction: DiscordButtonInbound): void {
+    if (!this.#open) return;
+    void this.#options.gateway.receive({
+      adapter: this.#options.id,
+      target: interaction.channelId,
+      content: formatButtonContent(interaction),
+      sender: interaction.userName,
+      id: interaction.id,
+      metadata: Object.freeze({
+        endpoint: this.#options.config.name,
+        eventType: 'button',
+        payload: interaction.customId,
+        sourceMessageId: interaction.sourceMessageId,
+      }),
+    }).catch((err) => {
+      logger.warn(formatCompact({
+        op: 'discord_gateway_receive_failed',
+        target: interaction.channelId,
+        error: err instanceof Error ? err.message : String(err),
+      }));
+    });
   }
 
-  // 解析文本内容，处理提及、频道引用、角色引用等
-  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;
-    }
+  // ── Agent tool surface ──────────────────────────────────────────────
 
-    // 添加最后剩余的文本
-    if (lastIndex < content.length) {
-      const remainingText = content.slice(lastIndex);
-      if (remainingText.trim()) {
-        segments.push({ type: "text", data: { text: remainingText } });
-      }
-    }
-
-    return segments.length > 0
-      ? segments
-      : [{ type: "text", data: { text: content } }];
+  async addRole(guildId: string, userId: string, roleId: string): Promise<boolean> {
+    const member = await this.#fetchMember(guildId, userId) as { roles: { add(id: string): Promise<unknown> } };
+    await member.roles.add(roleId);
+    return true;
   }
 
-  // 解析附件
-  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,
-        },
-      });
-    }
-
-    return segments;
+  async removeRole(guildId: string, userId: string, roleId: string): Promise<boolean> {
+    const member = await this.#fetchMember(guildId, userId) as { roles: { remove(id: string): Promise<unknown> } };
+    await member.roles.remove(roleId);
+    return true;
+  }
+
+  async getRoles(guildId: string): Promise<unknown[]> {
+    const guild = await this.#requireClient().guilds.fetch(guildId);
+    await guild.roles.fetch();
+    const cache = guild.roles.cache as Map<string, {
+      id: string;
+      name: string;
+      hexColor: string;
+      position: number;
+      permissions: { bitfield: bigint };
+    }>;
+    return [...cache.values()].map((role) => ({
+      id: role.id,
+      name: role.name,
+      color: role.hexColor,
+      position: role.position,
+      permissions: role.permissions.bitfield.toString(),
+    }));
+  }
+
+  async createThread(
+    channelId: string,
+    name: string,
+    messageId?: string,
+    autoArchiveDuration?: number,
+  ): Promise<{ id: string }> {
+    const channel = await this.#requireClient().channels.fetch(channelId);
+    if (!channel || !('threads' in channel) || !channel.threads) {
+      throw new Error(`Channel ${channelId} 不支持创建帖子`);
+    }
+    const options: Record<string, unknown> = {
+      name,
+      autoArchiveDuration: autoArchiveDuration || 1440,
+    };
+    if (messageId) options.startMessage = messageId;
+    return channel.threads.create(options);
   }
 
-  async $sendMessage(options: SendOptions): Promise<string> {
-    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 canonical = expandInteractiveSegmentsInContent(options.content);
-      const wire = fromCanonicalSegments(canonical);
-      const result = await this.sendContentToChannel(
-        channel as any,
-        wire
-      );
-      this.messageChannelMap.set(result.id, options.id);
-      this.pluginLogger.debug(
-        `${this.$config.name} send ${options.type}(${options.id}): ${segment.raw(options.content)}`
-      );
-      return result.id;
-    } catch (error) {
-      this.pluginLogger.error("Failed to send Discord message:", error);
-      throw error;
+  async addReaction(channelId: string, messageId: string, emoji: string): Promise<void> {
+    const channel = await this.#requireClient().channels.fetch(channelId);
+    if (!channel?.isTextBased() || !channel.messages) {
+      throw new Error(`Channel ${channelId} 不是文本频道`);
     }
+    const message = await channel.messages.fetch(messageId);
+    await message.react(emoji);
   }
 
-  // 发送内容到频道
-  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;
-
-        case "keyboard": {
-          const components = (data.rows ?? []).map((row: Array<{ id: string; label: string; payload: string; disabled?: boolean; style?: string }>) =>
-            new ActionRowBuilder<ButtonBuilder>().addComponents(
-              ...row.map((btn) => {
-                const b = new ButtonBuilder()
-                  .setCustomId(String(btn.payload).slice(0, 100))
-                  .setLabel(btn.label)
-                  .setDisabled(!!btn.disabled);
-                if (btn.style === "danger") b.setStyle(ButtonStyle.Danger);
-                else if (btn.style === "primary") b.setStyle(ButtonStyle.Primary);
-                else b.setStyle(ButtonStyle.Secondary);
-                return b;
-              }),
-            ),
-          );
-          messageOptions.components = components;
-          break;
-        }
-
-        default:
-          // 未知类型作为文本处理
-          textContent += data.text || `[${type}]`;
-      }
-    }
-
-    // 设置消息内容
-    if (textContent.trim()) {
-      messageOptions.content = textContent.trim();
-    }
-
-    if (embeds.length > 0) {
-      messageOptions.embeds = embeds.slice(0, 10); // Discord 限制最多10个embed
-    }
-
-    if (files.length > 0) {
-      messageOptions.files = files;
-    }
-
-    // 发送消息
-    return await channel.send(messageOptions);
+  async sendEmbed(
+    channelId: string,
+    embedData: Record<string, unknown>,
+  ): Promise<{ id: string }> {
+    const body: DiscordOutboundBody = { embeds: [embedData] };
+    const id = await this.#sendBody(channelId, body);
+    return { id };
   }
 
-  async $editMessage(options: EditMessageOptions): Promise<void> {
-    const channel = await this.channels.fetch(options.id);
-    if (!channel || !channel.isTextBased()) {
-      throw new Error(`Channel ${options.id} is not a text channel`);
-    }
-    const msg = await (channel as TextChannel).messages.fetch(options.messageId);
-    const messageOptions: DiscordEditMessageOptions = {};
-    let textContent = "";
-    if (!Array.isArray(options.content)) options.content = [options.content];
-    for (const seg of options.content) {
-      if (typeof seg === "string") {
-        textContent += seg;
-        continue;
-      }
-      if (seg.type === "text") textContent += seg.data.text || "";
-      if (seg.type === "keyboard") {
-        messageOptions.components = (seg.data.rows ?? []).map((row: Array<{ label: string; payload: string; disabled?: boolean; style?: string }>) =>
-          new ActionRowBuilder<ButtonBuilder>().addComponents(
-            ...row.map((btn) => {
-              const b = new ButtonBuilder()
-                .setCustomId(String(btn.payload).slice(0, 100))
-                .setLabel(btn.label)
-                .setDisabled(!!btn.disabled);
-              if (btn.style === "danger") b.setStyle(ButtonStyle.Danger);
-              else if (btn.style === "primary") b.setStyle(ButtonStyle.Primary);
-              else b.setStyle(ButtonStyle.Secondary);
-              return b;
-            }),
-          ),
-        );
-      }
+  async createForumPost(
+    channelId: string,
+    name: string,
+    content: string,
+    tags?: string[],
+  ): Promise<{ id: string }> {
+    const channel = await this.#requireClient().channels.fetch(channelId);
+    if (!channel || channel.type !== ChannelType.GuildForum || !channel.threads) {
+      throw new Error(`Channel ${channelId} 不是论坛频道`);
+    }
+    const options: Record<string, unknown> = {
+      name,
+      message: { content },
+    };
+    if (tags?.length && channel.availableTags?.length) {
+      const tagIds = channel.availableTags
+        .filter((t) => tags.includes(t.name))
+        .map((t) => t.id);
+      if (tagIds.length) options.appliedTags = tagIds;
     }
-    if (textContent.trim()) messageOptions.content = textContent.trim();
-    await msg.edit(messageOptions);
+    return channel.threads.create(options);
   }
 
-  async $recallMessage(id: string): Promise<void> { }
-
-  // ==================== 服务器管理 API ====================
-
-  /**
-   * 踢出成员
-   * @param guildId 服务器 ID
-   * @param userId 用户 ID
-   * @param reason 原因
-   */
   async kickMember(guildId: string, userId: string, reason?: string): Promise<boolean> {
-    try {
-      const guild = await this.guilds.fetch(guildId);
-      const member = await guild.members.fetch(userId);
-      await member.kick(reason);
-      this.pluginLogger.info(`Discord Endpoint ${this.$id} 踢出成员 ${userId}（服务器 ${guildId}）`);
-      return true;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 踢出成员失败:`, error);
-      throw error;
-    }
+    const member = await this.#fetchMember(guildId, userId) as { kick(reason?: string): Promise<unknown> };
+    await member.kick(reason);
+    return true;
   }
 
-  /**
-   * 封禁成员
-   * @param guildId 服务器 ID
-   * @param userId 用户 ID
-   * @param reason 原因
-   * @param deleteMessageDays 删除消息天数
-   */
-  async banMember(guildId: string, userId: string, reason?: string, deleteMessageDays?: number): Promise<boolean> {
-    try {
-      const guild = await this.guilds.fetch(guildId);
-      await guild.members.ban(userId, { reason, deleteMessageSeconds: deleteMessageDays ? deleteMessageDays * 86400 : undefined });
-      this.pluginLogger.info(`Discord Endpoint ${this.$id} 封禁成员 ${userId}（服务器 ${guildId}）`);
-      return true;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 封禁成员失败:`, error);
-      throw error;
-    }
+  async banMember(guildId: string, userId: string, reason?: string): Promise<boolean> {
+    const guild = await this.#requireClient().guilds.fetch(guildId);
+    await guild.members.ban(userId, { reason });
+    return true;
   }
 
-  /**
-   * 解除封禁
-   * @param guildId 服务器 ID
-   * @param userId 用户 ID
-   * @param reason 原因
-   */
   async unbanMember(guildId: string, userId: string, reason?: string): Promise<boolean> {
-    try {
-      const guild = await this.guilds.fetch(guildId);
-      await guild.members.unban(userId, reason);
-      this.pluginLogger.info(`Discord Endpoint ${this.$id} 解除封禁 ${userId}（服务器 ${guildId}）`);
-      return true;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 解除封禁失败:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * 超时（禁言）成员
-   * @param guildId 服务器 ID
-   * @param userId 用户 ID
-   * @param duration 超时时长（秒），0 表示取消超时
-   * @param reason 原因
-   */
-  async timeoutMember(guildId: string, userId: string, duration: number = 600, reason?: string): Promise<boolean> {
-    try {
-      const guild = await this.guilds.fetch(guildId);
-      const member = await guild.members.fetch(userId);
-      if (duration === 0) {
-        await member.timeout(null, reason);
-        this.pluginLogger.info(`Discord Endpoint ${this.$id} 取消成员 ${userId} 超时（服务器 ${guildId}）`);
-      } else {
-        await member.timeout(duration * 1000, reason);
-        this.pluginLogger.info(`Discord Endpoint ${this.$id} 超时成员 ${userId} ${duration}秒（服务器 ${guildId}）`);
-      }
-      return true;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 超时操作失败:`, error);
-      throw error;
-    }
+    const guild = await this.#requireClient().guilds.fetch(guildId);
+    await guild.members.unban(userId, reason);
+    return true;
+  }
+
+  async timeoutMember(
+    guildId: string,
+    userId: string,
+    duration = 600,
+    reason?: string,
+  ): Promise<boolean> {
+    const member = await this.#fetchMember(guildId, userId) as {
+      timeout(ms: number | null, reason?: string): Promise<unknown>;
+    };
+    await member.timeout(duration === 0 ? null : duration * 1000, reason);
+    return true;
   }
 
-  /**
-   * 修改成员昵称
-   * @param guildId 服务器 ID
-   * @param userId 用户 ID
-   * @param nickname 新昵称
-   */
   async setNickname(guildId: string, userId: string, nickname: string): Promise<boolean> {
-    try {
-      const guild = await this.guilds.fetch(guildId);
-      const member = await guild.members.fetch(userId);
-      await member.setNickname(nickname);
-      this.pluginLogger.info(`Discord Endpoint ${this.$id} 设置成员 ${userId} 昵称为 "${nickname}"（服务器 ${guildId}）`);
-      return true;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 设置昵称失败:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * 添加角色
-   * @param guildId 服务器 ID
-   * @param userId 用户 ID
-   * @param roleId 角色 ID
-   */
-  async addRole(guildId: string, userId: string, roleId: string): Promise<boolean> {
-    try {
-      const guild = await this.guilds.fetch(guildId);
-      const member = await guild.members.fetch(userId);
-      await member.roles.add(roleId);
-      this.pluginLogger.info(`Discord Endpoint ${this.$id} 给成员 ${userId} 添加角色 ${roleId}（服务器 ${guildId}）`);
-      return true;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 添加角色失败:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * 移除角色
-   * @param guildId 服务器 ID
-   * @param userId 用户 ID
-   * @param roleId 角色 ID
-   */
-  async removeRole(guildId: string, userId: string, roleId: string): Promise<boolean> {
-    try {
-      const guild = await this.guilds.fetch(guildId);
-      const member = await guild.members.fetch(userId);
-      await member.roles.remove(roleId);
-      this.pluginLogger.info(`Discord Endpoint ${this.$id} 移除成员 ${userId} 的角色 ${roleId}（服务器 ${guildId}）`);
-      return true;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 移除角色失败:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取服务器角色列表
-   * @param guildId 服务器 ID
-   */
-  async getRoles(guildId: string): Promise<any[]> {
-    try {
-      const guild = await this.guilds.fetch(guildId);
-      await guild.roles.fetch();
-      return guild.roles.cache.map(role => ({
-        id: role.id,
-        name: role.name,
-        color: role.hexColor,
-        position: role.position,
-        permissions: role.permissions.bitfield.toString(),
-      }));
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 获取角色列表失败:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取成员列表
-   * @param guildId 服务器 ID
-   * @param limit 数量限制
-   */
-  async getMembers(guildId: string, limit: number = 100): Promise<any[]> {
-    try {
-      const guild = await this.guilds.fetch(guildId);
-      const members = await guild.members.fetch({ limit });
-      return Array.from(members.values()).map(member => ({
-        id: member.id,
-        username: member.user.username,
-        nickname: member.nickname,
-        roles: member.roles.cache.map(r => r.id),
-        joined_at: member.joinedAt?.toISOString(),
-      }));
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 获取成员列表失败:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取服务器信息
-   * @param guildId 服务器 ID
-   */
-  async getGuildInfo(guildId: string): Promise<any> {
-    try {
-      const guild = await this.guilds.fetch(guildId);
-      return {
-        id: guild.id,
-        name: guild.name,
-        icon: guild.iconURL(),
-        owner_id: guild.ownerId,
-        member_count: guild.memberCount,
-        created_at: guild.createdAt?.toISOString(),
-      };
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 获取服务器信息失败:`, error);
-      throw error;
-    }
-  }
-
-  async createThread(channelId: string, name: string, messageId?: string, autoArchiveDuration?: number): Promise<ThreadChannel> {
-    try {
-      const channel = await this.channels.fetch(channelId);
-      if (!channel || !('threads' in channel)) throw new Error(`Channel ${channelId} 不支持创建帖子`);
-      const options: any = { name, autoArchiveDuration: autoArchiveDuration || 1440 };
-      if (messageId) options.startMessage = messageId;
-      const thread = await (channel as TextChannel).threads.create(options);
-      this.pluginLogger.info(`Discord Endpoint ${this.$id} 创建帖子 "${name}" (channel ${channelId})`);
-      return thread;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 创建帖子失败:`, error);
-      throw error;
-    }
-  }
-
-  async addReaction(channelId: string, messageId: string, emoji: string): Promise<void> {
-    try {
-      const channel = await this.channels.fetch(channelId);
-      if (!channel || !channel.isTextBased()) throw new Error(`Channel ${channelId} 不是文本频道`);
-      const message = await (channel as TextChannel).messages.fetch(messageId);
-      await message.react(emoji);
-      this.pluginLogger.info(`Discord Endpoint ${this.$id} 添加反应 ${emoji} (message ${messageId})`);
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 添加反应失败:`, error);
-      throw error;
-    }
+    const member = await this.#fetchMember(guildId, userId) as {
+      setNickname(nickname: string): Promise<unknown>;
+    };
+    await member.setNickname(nickname);
+    return true;
+  }
+
+  async getMembers(guildId: string, limit = 100): Promise<unknown[]> {
+    const guild = await this.#requireClient().guilds.fetch(guildId);
+    const members = await guild.members.fetch({ limit }) as Map<string, {
+      id: string;
+      user: { username: string };
+      nickname: string | null;
+      roles: { cache: { map(fn: (r: { id: string }) => string): string[] } };
+      joinedAt?: Date | null;
+    }>;
+    return [...members.values()].map((member) => ({
+      id: member.id,
+      username: member.user.username,
+      nickname: member.nickname,
+      roles: member.roles.cache.map((r) => r.id),
+      joined_at: member.joinedAt?.toISOString(),
+    }));
+  }
+
+  async getGuildInfo(guildId: string): Promise<unknown> {
+    const guild = await this.#requireClient().guilds.fetch(guildId);
+    return {
+      id: guild.id,
+      name: guild.name,
+      icon: guild.iconURL?.(),
+      owner_id: guild.ownerId,
+      member_count: guild.memberCount,
+      created_at: guild.createdAt?.toISOString(),
+    };
   }
 
-  private resolveDiscordMessageRef(messageId: string): { channelId: string; msgId: string } | null {
-    if (messageId.includes(':')) {
-      const [channelId, msgId] = messageId.split(':');
-      if (channelId && msgId) {
-        this.messageChannelMap.set(msgId, channelId);
-        return { channelId, msgId };
-      }
+  async #sendBody(channelId: string, body: DiscordOutboundBody): Promise<string> {
+    const channel = await this.#requireClient().channels.fetch(channelId);
+    if (!channel || !channel.isTextBased() || !channel.send) {
+      throw new Error(`Channel ${channelId} is not a text channel`);
     }
-
-    const channelId = this.messageChannelMap.get(messageId);
-    if (!channelId) return null;
-    return { channelId, msgId: messageId };
+    const options = await toMessageCreateOptions(body);
+    const result = await channel.send(options);
+    return result.id;
   }
 
-  async $addReaction(messageId: string, emoji: string): Promise<string | null> {
-    const ref = this.resolveDiscordMessageRef(messageId);
-    if (!ref) {
-      this.pluginLogger.warn(`Discord Endpoint ${this.$id} 无法根据 message_id=${messageId} 定位 channel_id，跳过 addReaction`);
-      return null;
-    }
-
-    try {
-      await this.addReaction(ref.channelId, ref.msgId, emoji);
-      return emoji;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 添加 reaction 失败:`, error);
-      return null;
-    }
+  async #fetchMember(guildId: string, userId: string): Promise<unknown> {
+    const guild = await this.#requireClient().guilds.fetch(guildId);
+    return guild.members.fetch(userId);
   }
 
-  async $removeReaction(messageId: string, reactionId: string): Promise<void> {
-    const ref = this.resolveDiscordMessageRef(messageId);
-    if (!ref) {
-      this.pluginLogger.warn(`Discord Endpoint ${this.$id} 无法根据 message_id=${messageId} 定位 channel_id，跳过 removeReaction`);
-      return;
-    }
-
-    try {
-      const channel = await this.channels.fetch(ref.channelId);
-      if (!channel || !channel.isTextBased()) return;
-      const message = await (channel as TextChannel).messages.fetch(ref.msgId);
-      const targetReaction =
-        message.reactions.resolve(reactionId as any) ||
-        message.reactions.cache.find(
-          (reaction) =>
-            reaction.emoji.toString() === reactionId ||
-            reaction.emoji.name === reactionId ||
-            reaction.emoji.id === reactionId,
-        );
-      if (targetReaction && this.user?.id) {
-        await targetReaction.users.remove(this.user.id);
-      }
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 移除 reaction 失败:`, error);
-    }
+  #requireClient(): DiscordClientTransport {
+    if (!this.#client) throw new Error('Discord client not connected');
+    return this.#client;
   }
+}
 
-  async sendEmbed(channelId: string, embedData: { title?: string; description?: string; color?: number; url?: string; fields?: { name: string; value: string; inline?: boolean }[] }): Promise<DiscordMessage<boolean>> {
-    try {
-      const channel = await this.channels.fetch(channelId);
-      if (!channel || !channel.isTextBased()) throw new Error(`Channel ${channelId} 不是文本频道`);
-      const embed = this.createEmbedFromData(embedData);
-      const msg = await (channel as TextChannel).send({ embeds: [embed] });
-      this.pluginLogger.info(`Discord Endpoint ${this.$id} 发送 Embed 到 ${channelId}`);
-      return msg;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 发送 Embed 失败:`, error);
-      throw error;
-    }
-  }
+export interface DiscordInteractionsEndpointOptions {
+  readonly id: CapabilityId;
+  readonly gateway: MessageGateway;
+  readonly http: HttpHost;
+  readonly config: ResolvedDiscordInteractionsConfig;
+  readonly fetch?: typeof globalThis.fetch;
+}
 
-  async createForumPost(channelId: string, name: string, content: string, tags?: string[]): Promise<ThreadChannel> {
-    try {
-      const channel = await this.channels.fetch(channelId);
-      if (!channel || channel.type !== ChannelType.GuildForum) throw new Error(`Channel ${channelId} 不是论坛频道`);
-      const forumChannel = channel as any;
-      const options: any = {
-        name,
-        message: { content },
-      };
-      if (tags?.length && forumChannel.availableTags?.length) {
-        const tagIds = forumChannel.availableTags
-          .filter((t: any) => tags.includes(t.name))
-          .map((t: any) => t.id);
-        if (tagIds.length) options.appliedTags = tagIds;
-      }
-      const thread = await forumChannel.threads.create(options);
-      this.pluginLogger.info(`Discord Endpoint ${this.$id} 创建论坛帖 "${name}" (channel ${channelId})`);
-      return thread;
-    } catch (error) {
-      this.pluginLogger.error(`Discord Endpoint ${this.$id} 创建论坛帖失败:`, error);
-      throw error;
-    }
-  }
+export class DiscordInteractionsEndpoint implements EndpointInstance {
+  readonly #options: DiscordInteractionsEndpointOptions;
+  readonly #fetch: typeof globalThis.fetch;
+  #routeReleases: HttpRouteRegistration[] = [];
+  #open = false;
+  #started = false;
 
-  // 处理文件段
-  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",
-        })
-      );
-    }
+  constructor(options: DiscordInteractionsEndpointOptions) {
+    this.#options = options;
+    this.#fetch = options.fetch ?? globalThis.fetch;
   }
 
-  // 从数据创建 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;
+  get isOpen(): boolean {
+    return this.#open;
   }
 
-  // 工具方法：获取活动类型
-  private getActivityType(type: string) {
-    const activityTypes = {
-      PLAYING: 0,
-      STREAMING: 1,
-      LISTENING: 2,
-      WATCHING: 3,
-      COMPETING: 5,
-    };
-    return activityTypes[type as keyof typeof activityTypes] || 0;
+  get config(): ResolvedDiscordInteractionsConfig {
+    return this.#options.config;
   }
 
-  // 注册 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.pluginLogger.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.pluginLogger.info("Successfully registered guild slash commands");
-      }
-    } catch (error) {
-      this.pluginLogger.error("Failed to register slash commands:", error);
-    }
+  async start(): Promise<void> {
+    if (this.#started) return;
+    this.#started = true;
+    this.#routeReleases.push(...registerDiscordInteractionRoutes(this.#options.http, this));
+    logger.info(formatCompact({
+      op: 'connect',
+      endpoint: this.#options.config.name,
+      mode: 'interactions',
+      path: this.#options.config.interactionsPath,
+    }));
   }
 
-  // 添加 Slash Command 处理器
-  addSlashCommandHandler(
-    commandName: string,
-    handler: (interaction: ChatInputCommandInteraction) => Promise<void>
-  ) {
-    this.slashCommandHandlers.set(commandName, handler);
+  open(): void {
+    this.#open = true;
   }
 
-  // 移除 Slash Command 处理器
-  removeSlashCommandHandler(commandName: string): boolean {
-    return this.slashCommandHandlers.delete(commandName);
+  close(): void {
+    this.#open = false;
   }
 
-  // 工具方法：检查文件是否存在
-  private async fileExists(filePath: string): Promise<boolean> {
-    try {
-      await fs.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
+  async stop(): Promise<void> {
+    this.#open = false;
+    for (const release of this.#routeReleases.splice(0)) release();
+    this.#started = false;
+    logger.debug(formatCompact({ op: 'disconnect', endpoint: this.#options.config.name }));
   }
 
-  // 静态方法：格式化内容为文本（用于日志显示）
-  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("");
+  async send({ target, payload }: { readonly target: string; readonly payload: unknown }): Promise<string> {
+    const body = formatOutboundBody(payload);
+    const response = await this.#fetch(`${DISCORD_API}/channels/${target}/messages`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bot ${this.#options.config.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`Discord send failed (${response.status}): ${text.slice(0, 200)}`);
+    }
+    const data = JSON.parse(text) as { id?: string };
+    return data.id ?? '';
+  }
+
+  admit(msg: DiscordInboundMessage): void {
+    if (!this.#open) return;
+    void this.#options.gateway.receive({
+      adapter: this.#options.id,
+      target: msg.channelId,
+      content: formatInboundContent(msg),
+      sender: senderDisplayName(msg),
+      id: msg.id,
+      metadata: Object.freeze({
+        endpoint: this.#options.config.name,
+        channelKind: msg.channelKind,
+        userId: msg.authorId,
+        guildId: msg.guildId,
+        eventType: 'application_command',
+      }),
+    }).catch((err) => {
+      logger.warn(formatCompact({
+        op: 'discord_gateway_receive_failed',
+        target: msg.channelId,
+        error: err instanceof Error ? err.message : String(err),
+      }));
+    });
   }
 }
-
-// ================================================================================================
-// DiscordInteractionsEndpoint 类（Interactions 端点模式）
-// ================================================================================================
-
-import * as nacl from "tweetnacl";
-