@chat-adapter/discord 4.3.0

package/dist/index.js

@@ -0,0 +1,1569 @@
+// src/index.ts
+import {
+  extractCard,
+  extractFiles,
+  NetworkError,
+  toBuffer,
+  ValidationError
+} from "@chat-adapter/shared";
+import { convertEmojiPlaceholders as convertEmojiPlaceholders2, defaultEmojiResolver, getEmoji } from "chat";
+import {
+  Client,
+  Events,
+  GatewayIntentBits
+} from "discord.js";
+import {
+  ChannelType,
+  InteractionType
+} from "discord-api-types/v10";
+import {
+  InteractionResponseType as DiscordInteractionResponseType,
+  verifyKey
+} from "discord-interactions";
+
+// src/cards.ts
+import { convertEmojiPlaceholders } from "chat";
+import { ButtonStyle } from "discord-api-types/v10";
+function convertEmoji(text) {
+  return convertEmojiPlaceholders(text, "discord");
+}
+function cardToDiscordPayload(card) {
+  const embed = {};
+  const fields = [];
+  const components = [];
+  if (card.title) {
+    embed.title = convertEmoji(card.title);
+  }
+  if (card.subtitle) {
+    embed.description = convertEmoji(card.subtitle);
+  }
+  if (card.imageUrl) {
+    embed.image = {
+      url: card.imageUrl
+    };
+  }
+  embed.color = 5793266;
+  const textParts = [];
+  for (const child of card.children) {
+    processChild(child, textParts, fields, components);
+  }
+  if (textParts.length > 0) {
+    if (embed.description) {
+      embed.description += `
+
+${textParts.join("\n\n")}`;
+    } else {
+      embed.description = textParts.join("\n\n");
+    }
+  }
+  if (fields.length > 0) {
+    embed.fields = fields;
+  }
+  return {
+    embeds: [embed],
+    components
+  };
+}
+function processChild(child, textParts, fields, components) {
+  switch (child.type) {
+    case "text":
+      textParts.push(convertTextElement(child));
+      break;
+    case "image":
+      break;
+    case "divider":
+      textParts.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      break;
+    case "actions":
+      components.push(convertActionsElement(child));
+      break;
+    case "section":
+      processSectionElement(child, textParts, fields, components);
+      break;
+    case "fields":
+      convertFieldsElement(child, fields);
+      break;
+  }
+}
+function convertTextElement(element) {
+  let text = convertEmoji(element.content);
+  if (element.style === "bold") {
+    text = `**${text}**`;
+  } else if (element.style === "muted") {
+    text = `*${text}*`;
+  }
+  return text;
+}
+function convertActionsElement(element) {
+  const buttons = element.children.map(
+    (button) => convertButtonElement(button)
+  );
+  return {
+    type: 1,
+    // Action Row
+    components: buttons
+  };
+}
+function convertButtonElement(button) {
+  const discordButton = {
+    type: 2,
+    // Button
+    style: getButtonStyle(button.style),
+    label: button.label,
+    custom_id: button.id
+  };
+  return discordButton;
+}
+function getButtonStyle(style) {
+  switch (style) {
+    case "primary":
+      return ButtonStyle.Primary;
+    case "danger":
+      return ButtonStyle.Danger;
+    default:
+      return ButtonStyle.Secondary;
+  }
+}
+function processSectionElement(element, textParts, fields, components) {
+  for (const child of element.children) {
+    processChild(child, textParts, fields, components);
+  }
+}
+function convertFieldsElement(element, fields) {
+  for (const field of element.children) {
+    fields.push({
+      name: convertEmoji(field.label),
+      value: convertEmoji(field.value),
+      inline: true
+      // Discord fields can be inline
+    });
+  }
+}
+function cardToFallbackText(card) {
+  const parts = [];
+  if (card.title) {
+    parts.push(`**${convertEmoji(card.title)}**`);
+  }
+  if (card.subtitle) {
+    parts.push(convertEmoji(card.subtitle));
+  }
+  for (const child of card.children) {
+    const text = childToFallbackText(child);
+    if (text) {
+      parts.push(text);
+    }
+  }
+  return parts.join("\n\n");
+}
+function childToFallbackText(child) {
+  switch (child.type) {
+    case "text":
+      return convertEmoji(child.content);
+    case "fields":
+      return child.children.map((f) => `**${convertEmoji(f.label)}**: ${convertEmoji(f.value)}`).join("\n");
+    case "actions":
+      return `[${child.children.map((b) => convertEmoji(b.label)).join("] [")}]`;
+    case "section":
+      return child.children.map((c) => childToFallbackText(c)).filter(Boolean).join("\n");
+    case "divider":
+      return "---";
+    default:
+      return null;
+  }
+}
+
+// src/markdown.ts
+import {
+  BaseFormatConverter,
+  getNodeChildren,
+  getNodeValue,
+  isBlockquoteNode,
+  isCodeNode,
+  isDeleteNode,
+  isEmphasisNode,
+  isInlineCodeNode,
+  isLinkNode,
+  isListItemNode,
+  isListNode,
+  isParagraphNode,
+  isStrongNode,
+  isTextNode,
+  parseMarkdown
+} from "chat";
+var DiscordFormatConverter = class extends BaseFormatConverter {
+  /**
+   * Convert @mentions to Discord format in plain text.
+   * @name → <@name>
+   */
+  convertMentionsToDiscord(text) {
+    return text.replace(/@(\w+)/g, "<@$1>");
+  }
+  /**
+   * Override renderPostable to convert @mentions in plain strings.
+   */
+  renderPostable(message) {
+    if (typeof message === "string") {
+      return this.convertMentionsToDiscord(message);
+    }
+    if ("raw" in message) {
+      return this.convertMentionsToDiscord(message.raw);
+    }
+    if ("markdown" in message) {
+      return this.fromAst(parseMarkdown(message.markdown));
+    }
+    if ("ast" in message) {
+      return this.fromAst(message.ast);
+    }
+    return "";
+  }
+  /**
+   * Render an AST to Discord markdown format.
+   */
+  fromAst(ast) {
+    return this.fromAstWithNodeConverter(
+      ast,
+      (node) => this.nodeToDiscordMarkdown(node)
+    );
+  }
+  /**
+   * Parse Discord markdown into an AST.
+   */
+  toAst(discordMarkdown) {
+    let markdown = discordMarkdown;
+    markdown = markdown.replace(/<@!?(\w+)>/g, "@$1");
+    markdown = markdown.replace(/<#(\w+)>/g, "#$1");
+    markdown = markdown.replace(/<@&(\w+)>/g, "@&$1");
+    markdown = markdown.replace(/<a?:(\w+):\d+>/g, ":$1:");
+    markdown = markdown.replace(/\|\|([^|]+)\|\|/g, "[spoiler: $1]");
+    return parseMarkdown(markdown);
+  }
+  nodeToDiscordMarkdown(node) {
+    if (isParagraphNode(node)) {
+      return getNodeChildren(node).map((child) => this.nodeToDiscordMarkdown(child)).join("");
+    }
+    if (isTextNode(node)) {
+      return node.value.replace(/@(\w+)/g, "<@$1>");
+    }
+    if (isStrongNode(node)) {
+      const content = getNodeChildren(node).map((child) => this.nodeToDiscordMarkdown(child)).join("");
+      return `**${content}**`;
+    }
+    if (isEmphasisNode(node)) {
+      const content = getNodeChildren(node).map((child) => this.nodeToDiscordMarkdown(child)).join("");
+      return `*${content}*`;
+    }
+    if (isDeleteNode(node)) {
+      const content = getNodeChildren(node).map((child) => this.nodeToDiscordMarkdown(child)).join("");
+      return `~~${content}~~`;
+    }
+    if (isInlineCodeNode(node)) {
+      return `\`${node.value}\``;
+    }
+    if (isCodeNode(node)) {
+      return `\`\`\`${node.lang || ""}
+${node.value}
+\`\`\``;
+    }
+    if (isLinkNode(node)) {
+      const linkText = getNodeChildren(node).map((child) => this.nodeToDiscordMarkdown(child)).join("");
+      return `[${linkText}](${node.url})`;
+    }
+    if (isBlockquoteNode(node)) {
+      return getNodeChildren(node).map((child) => `> ${this.nodeToDiscordMarkdown(child)}`).join("\n");
+    }
+    if (isListNode(node)) {
+      return getNodeChildren(node).map((item, i) => {
+        const prefix = node.ordered ? `${i + 1}.` : "-";
+        const content = getNodeChildren(item).map((child) => this.nodeToDiscordMarkdown(child)).join("");
+        return `${prefix} ${content}`;
+      }).join("\n");
+    }
+    if (isListItemNode(node)) {
+      return getNodeChildren(node).map((child) => this.nodeToDiscordMarkdown(child)).join("");
+    }
+    if (node.type === "break") {
+      return "\n";
+    }
+    if (node.type === "thematicBreak") {
+      return "---";
+    }
+    const children = getNodeChildren(node);
+    if (children.length > 0) {
+      return children.map((child) => this.nodeToDiscordMarkdown(child)).join("");
+    }
+    return getNodeValue(node);
+  }
+};
+
+// src/index.ts
+var DISCORD_API_BASE = "https://discord.com/api/v10";
+var DISCORD_MAX_CONTENT_LENGTH = 2e3;
+var DiscordAdapter = class {
+  name = "discord";
+  userName;
+  botUserId;
+  botToken;
+  publicKey;
+  applicationId;
+  mentionRoleIds;
+  chat = null;
+  logger;
+  formatConverter = new DiscordFormatConverter();
+  constructor(config) {
+    this.botToken = config.botToken;
+    this.publicKey = config.publicKey.trim().toLowerCase();
+    this.applicationId = config.applicationId;
+    this.mentionRoleIds = config.mentionRoleIds ?? [];
+    this.botUserId = config.applicationId;
+    this.logger = config.logger;
+    this.userName = config.userName ?? "bot";
+    if (!/^[0-9a-f]{64}$/.test(this.publicKey)) {
+      this.logger.error("Invalid Discord public key format", {
+        length: this.publicKey.length,
+        isHex: /^[0-9a-f]+$/.test(this.publicKey)
+      });
+    }
+  }
+  async initialize(chat) {
+    this.chat = chat;
+    this.logger.info("Discord adapter initialized", {
+      applicationId: this.applicationId,
+      // Log full public key for debugging - it's public, not secret
+      publicKey: this.publicKey
+    });
+  }
+  /**
+   * Handle incoming Discord webhook (HTTP Interactions or forwarded Gateway events).
+   */
+  async handleWebhook(request, options) {
+    const bodyBuffer = await request.arrayBuffer();
+    const bodyBytes = new Uint8Array(bodyBuffer);
+    const body = new TextDecoder().decode(bodyBytes);
+    const gatewayToken = request.headers.get("x-discord-gateway-token");
+    if (gatewayToken) {
+      if (gatewayToken !== this.botToken) {
+        this.logger.warn("Invalid gateway token");
+        return new Response("Invalid gateway token", { status: 401 });
+      }
+      this.logger.info("Discord forwarded Gateway event received");
+      try {
+        const event = JSON.parse(body);
+        return this.handleForwardedGatewayEvent(event, options);
+      } catch {
+        return new Response("Invalid JSON", { status: 400 });
+      }
+    }
+    this.logger.info("Discord webhook received", {
+      bodyLength: body.length,
+      bodyBytesLength: bodyBytes.length,
+      hasSignature: !!request.headers.get("x-signature-ed25519"),
+      hasTimestamp: !!request.headers.get("x-signature-timestamp")
+    });
+    const signature = request.headers.get("x-signature-ed25519");
+    const timestamp = request.headers.get("x-signature-timestamp");
+    const signatureValid = await this.verifySignature(
+      bodyBytes,
+      signature,
+      timestamp
+    );
+    if (!signatureValid) {
+      this.logger.warn("Discord signature verification failed, returning 401");
+      return new Response("Invalid signature", { status: 401 });
+    }
+    this.logger.info("Discord signature verification passed");
+    let interaction;
+    try {
+      interaction = JSON.parse(body);
+    } catch {
+      return new Response("Invalid JSON", { status: 400 });
+    }
+    this.logger.info("Discord interaction parsed", {
+      type: interaction.type,
+      typeIsPing: interaction.type === InteractionType.Ping,
+      expectedPingType: InteractionType.Ping,
+      id: interaction.id
+    });
+    if (interaction.type === InteractionType.Ping) {
+      const responseBody = JSON.stringify({
+        type: DiscordInteractionResponseType.PONG
+      });
+      this.logger.info("Discord PING received, responding with PONG", {
+        responseBody,
+        responseType: DiscordInteractionResponseType.PONG
+      });
+      return new Response(responseBody, {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (interaction.type === InteractionType.MessageComponent) {
+      this.handleComponentInteraction(interaction, options);
+      return this.respondToInteraction({
+        type: 6 /* DeferredUpdateMessage */
+      });
+    }
+    if (interaction.type === InteractionType.ApplicationCommand) {
+      return this.respondToInteraction({
+        type: 5 /* DeferredChannelMessageWithSource */
+      });
+    }
+    return new Response("Unknown interaction type", { status: 400 });
+  }
+  /**
+   * Verify Discord's Ed25519 signature using official discord-interactions library.
+   */
+  async verifySignature(bodyBytes, signature, timestamp) {
+    if (!signature || !timestamp) {
+      this.logger.warn(
+        "Discord signature verification failed: missing headers",
+        {
+          hasSignature: !!signature,
+          hasTimestamp: !!timestamp
+        }
+      );
+      return false;
+    }
+    try {
+      this.logger.info("Discord signature verification attempt", {
+        bodyBytesLength: bodyBytes.length,
+        signatureLength: signature.length,
+        timestampLength: timestamp.length,
+        publicKeyLength: this.publicKey.length,
+        timestamp,
+        signaturePrefix: signature.slice(0, 16),
+        publicKey: this.publicKey
+      });
+      const isValid = await verifyKey(
+        bodyBytes,
+        signature,
+        timestamp,
+        this.publicKey
+      );
+      if (!isValid) {
+        const bodyString = new TextDecoder().decode(bodyBytes);
+        this.logger.warn(
+          "Discord signature verification failed: invalid signature",
+          {
+            publicKeyLength: this.publicKey.length,
+            signatureLength: signature.length,
+            publicKeyPrefix: this.publicKey.slice(0, 8),
+            publicKeySuffix: this.publicKey.slice(-8),
+            timestamp,
+            bodyLength: bodyBytes.length,
+            bodyPrefix: bodyString.slice(0, 50)
+          }
+        );
+      }
+      return isValid;
+    } catch (error) {
+      this.logger.warn("Discord signature verification failed: exception", {
+        error
+      });
+      return false;
+    }
+  }
+  /**
+   * Create a JSON response for Discord interactions.
+   */
+  respondToInteraction(response) {
+    return new Response(JSON.stringify(response), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Handle MESSAGE_COMPONENT interactions (button clicks).
+   */
+  handleComponentInteraction(interaction, options) {
+    if (!this.chat) {
+      this.logger.warn("Chat instance not initialized, ignoring interaction");
+      return;
+    }
+    const customId = interaction.data?.custom_id;
+    if (!customId) {
+      this.logger.warn("No custom_id in component interaction");
+      return;
+    }
+    const user = interaction.member?.user || interaction.user;
+    if (!user) {
+      this.logger.warn("No user in component interaction");
+      return;
+    }
+    const channelId = interaction.channel_id;
+    const guildId = interaction.guild_id || "@me";
+    const messageId = interaction.message?.id;
+    if (!channelId || !messageId) {
+      this.logger.warn("Missing channel_id or message_id in interaction");
+      return;
+    }
+    const threadId = this.encodeThreadId({
+      guildId,
+      channelId
+    });
+    const actionEvent = {
+      actionId: customId,
+      value: customId,
+      // Discord custom_id often contains the value
+      user: {
+        userId: user.id,
+        userName: user.username,
+        fullName: user.global_name || user.username,
+        isBot: user.bot ?? false,
+        isMe: false
+      },
+      messageId,
+      threadId,
+      adapter: this,
+      raw: interaction
+    };
+    this.logger.debug("Processing Discord button action", {
+      actionId: customId,
+      messageId,
+      threadId
+    });
+    this.chat.processAction(actionEvent, options);
+  }
+  /**
+   * Handle a forwarded Gateway event received via webhook.
+   */
+  async handleForwardedGatewayEvent(event, options) {
+    this.logger.info("Processing forwarded Gateway event", {
+      type: event.type,
+      timestamp: event.timestamp
+    });
+    switch (event.type) {
+      case "GATEWAY_MESSAGE_CREATE":
+        await this.handleForwardedMessage(
+          event.data,
+          options
+        );
+        break;
+      case "GATEWAY_MESSAGE_REACTION_ADD":
+        await this.handleForwardedReaction(
+          event.data,
+          true,
+          options
+        );
+        break;
+      case "GATEWAY_MESSAGE_REACTION_REMOVE":
+        await this.handleForwardedReaction(
+          event.data,
+          false,
+          options
+        );
+        break;
+      default:
+        this.logger.debug("Forwarded Gateway event (no handler)", {
+          type: event.type
+        });
+    }
+    return new Response(JSON.stringify({ ok: true }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Handle a forwarded MESSAGE_CREATE event.
+   */
+  async handleForwardedMessage(data, _options) {
+    if (!this.chat) return;
+    const guildId = data.guild_id || "@me";
+    const channelId = data.channel_id;
+    let discordThreadId;
+    let parentChannelId = channelId;
+    if (data.thread) {
+      discordThreadId = data.thread.id;
+      parentChannelId = data.thread.parent_id;
+    } else if (data.channel_type === 11 || data.channel_type === 12) {
+      try {
+        const response = await this.discordFetch(
+          `/channels/${channelId}`,
+          "GET"
+        );
+        const channel = await response.json();
+        if (channel.parent_id) {
+          discordThreadId = channelId;
+          parentChannelId = channel.parent_id;
+          this.logger.debug("Fetched thread parent for forwarded message", {
+            threadId: channelId,
+            parentId: channel.parent_id
+          });
+        }
+      } catch (error) {
+        this.logger.error("Failed to fetch thread parent", {
+          error: String(error),
+          channelId
+        });
+      }
+    }
+    const isUserMentioned = data.is_mention || data.mentions.some((m) => m.id === this.applicationId);
+    const isRoleMentioned = this.mentionRoleIds.length > 0 && data.mention_roles?.some(
+      (roleId) => this.mentionRoleIds.includes(roleId)
+    );
+    const isMentioned = isUserMentioned || isRoleMentioned;
+    if (!discordThreadId && isMentioned) {
+      try {
+        const newThread = await this.createDiscordThread(channelId, data.id);
+        discordThreadId = newThread.id;
+        this.logger.debug("Created Discord thread for forwarded mention", {
+          channelId,
+          messageId: data.id,
+          threadId: newThread.id
+        });
+      } catch (error) {
+        this.logger.error("Failed to create Discord thread for mention", {
+          error: String(error),
+          messageId: data.id
+        });
+      }
+    }
+    const threadId = this.encodeThreadId({
+      guildId,
+      channelId: parentChannelId,
+      threadId: discordThreadId
+    });
+    const chatMessage = {
+      id: data.id,
+      threadId,
+      text: data.content,
+      formatted: this.formatConverter.toAst(data.content),
+      author: {
+        userId: data.author.id,
+        userName: data.author.username,
+        fullName: data.author.global_name || data.author.username,
+        isBot: data.author.bot === true,
+        // Discord returns null for non-bots
+        isMe: data.author.id === this.applicationId
+      },
+      metadata: {
+        dateSent: new Date(data.timestamp),
+        edited: false
+      },
+      attachments: data.attachments.map((a) => ({
+        type: this.getAttachmentType(a.content_type),
+        url: a.url,
+        name: a.filename,
+        mimeType: a.content_type,
+        size: a.size
+      })),
+      raw: data,
+      isMention: isMentioned
+    };
+    try {
+      await this.chat.handleIncomingMessage(this, threadId, chatMessage);
+    } catch (error) {
+      this.logger.error("Error handling forwarded message", {
+        error: String(error),
+        messageId: data.id
+      });
+    }
+  }
+  /**
+   * Handle a forwarded REACTION_ADD or REACTION_REMOVE event.
+   */
+  async handleForwardedReaction(data, added, _options) {
+    if (!this.chat) return;
+    const guildId = data.guild_id || "@me";
+    const channelId = data.channel_id;
+    const threadId = this.encodeThreadId({
+      guildId,
+      channelId
+    });
+    const emojiName = data.emoji.name || "unknown";
+    const normalizedEmoji = this.normalizeDiscordEmoji(emojiName);
+    const userInfo = data.user ?? data.member?.user;
+    if (!userInfo) {
+      this.logger.warn("Reaction event missing user info", { data });
+      return;
+    }
+    const reactionEvent = {
+      adapter: this,
+      threadId,
+      messageId: data.message_id,
+      emoji: normalizedEmoji,
+      rawEmoji: data.emoji.id ? `<:${emojiName}:${data.emoji.id}>` : emojiName,
+      added,
+      user: {
+        userId: userInfo.id,
+        userName: userInfo.username,
+        fullName: userInfo.username,
+        isBot: userInfo.bot === true,
+        // Discord returns null for non-bots
+        isMe: userInfo.id === this.applicationId
+      },
+      raw: data
+    };
+    this.chat.processReaction(reactionEvent);
+  }
+  /**
+   * Post a message to a Discord channel or thread.
+   */
+  async postMessage(threadId, message) {
+    let { channelId, threadId: discordThreadId } = this.decodeThreadId(threadId);
+    const actualThreadId = threadId;
+    if (discordThreadId) {
+      channelId = discordThreadId;
+    }
+    const payload = {};
+    const embeds = [];
+    const components = [];
+    const card = extractCard(message);
+    if (card) {
+      const cardPayload = cardToDiscordPayload(card);
+      embeds.push(...cardPayload.embeds);
+      components.push(...cardPayload.components);
+      payload.content = this.truncateContent(cardToFallbackText(card));
+    } else {
+      payload.content = this.truncateContent(
+        convertEmojiPlaceholders2(
+          this.formatConverter.renderPostable(message),
+          "discord"
+        )
+      );
+    }
+    if (embeds.length > 0) {
+      payload.embeds = embeds;
+    }
+    if (components.length > 0) {
+      payload.components = components;
+    }
+    const files = extractFiles(message);
+    if (files.length > 0) {
+      return this.postMessageWithFiles(
+        channelId,
+        actualThreadId,
+        payload,
+        files
+      );
+    }
+    this.logger.debug("Discord API: POST message", {
+      channelId,
+      contentLength: payload.content?.length || 0,
+      embedCount: embeds.length,
+      componentCount: components.length
+    });
+    const response = await this.discordFetch(
+      `/channels/${channelId}/messages`,
+      "POST",
+      payload
+    );
+    const result = await response.json();
+    this.logger.debug("Discord API: POST message response", {
+      messageId: result.id
+    });
+    return {
+      id: result.id,
+      threadId: actualThreadId,
+      raw: result
+    };
+  }
+  /**
+   * Create a Discord thread from a message.
+   */
+  async createDiscordThread(channelId, messageId) {
+    const threadName = `Thread ${(/* @__PURE__ */ new Date()).toLocaleString()}`;
+    this.logger.debug("Discord API: POST thread", {
+      channelId,
+      messageId,
+      threadName
+    });
+    const response = await this.discordFetch(
+      `/channels/${channelId}/messages/${messageId}/threads`,
+      "POST",
+      {
+        name: threadName,
+        auto_archive_duration: 1440
+        // 24 hours
+      }
+    );
+    const result = await response.json();
+    this.logger.debug("Discord API: POST thread response", {
+      threadId: result.id,
+      threadName: result.name
+    });
+    return result;
+  }
+  /**
+   * Truncate content to Discord's maximum length.
+   */
+  truncateContent(content) {
+    if (content.length <= DISCORD_MAX_CONTENT_LENGTH) {
+      return content;
+    }
+    return `${content.slice(0, DISCORD_MAX_CONTENT_LENGTH - 3)}...`;
+  }
+  /**
+   * Post a message with file attachments.
+   */
+  async postMessageWithFiles(channelId, threadId, payload, files) {
+    const formData = new FormData();
+    formData.append("payload_json", JSON.stringify(payload));
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      if (!file) continue;
+      const buffer = await toBuffer(file.data, {
+        platform: "discord"
+      });
+      if (!buffer) continue;
+      const blob = new Blob([new Uint8Array(buffer)], {
+        type: file.mimeType || "application/octet-stream"
+      });
+      formData.append(`files[${i}]`, blob, file.filename);
+    }
+    const response = await fetch(
+      `${DISCORD_API_BASE}/channels/${channelId}/messages`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bot ${this.botToken}`
+        },
+        body: formData
+      }
+    );
+    if (!response.ok) {
+      const error = await response.text();
+      throw new NetworkError(
+        "discord",
+        `Failed to post message: ${response.status} ${error}`
+      );
+    }
+    const result = await response.json();
+    return {
+      id: result.id,
+      threadId,
+      raw: result
+    };
+  }
+  /**
+   * Edit an existing Discord message.
+   */
+  async editMessage(threadId, messageId, message) {
+    const { channelId, threadId: discordThreadId } = this.decodeThreadId(threadId);
+    const targetChannelId = discordThreadId || channelId;
+    const payload = {};
+    const embeds = [];
+    const components = [];
+    const card = extractCard(message);
+    if (card) {
+      const cardPayload = cardToDiscordPayload(card);
+      embeds.push(...cardPayload.embeds);
+      components.push(...cardPayload.components);
+      payload.content = this.truncateContent(cardToFallbackText(card));
+    } else {
+      payload.content = this.truncateContent(
+        convertEmojiPlaceholders2(
+          this.formatConverter.renderPostable(message),
+          "discord"
+        )
+      );
+    }
+    if (embeds.length > 0) {
+      payload.embeds = embeds;
+    }
+    if (components.length > 0) {
+      payload.components = components;
+    }
+    this.logger.debug("Discord API: PATCH message", {
+      channelId: targetChannelId,
+      messageId,
+      contentLength: payload.content?.length || 0
+    });
+    const response = await this.discordFetch(
+      `/channels/${targetChannelId}/messages/${messageId}`,
+      "PATCH",
+      payload
+    );
+    const result = await response.json();
+    this.logger.debug("Discord API: PATCH message response", {
+      messageId: result.id
+    });
+    return {
+      id: result.id,
+      threadId,
+      raw: result
+    };
+  }
+  /**
+   * Delete a Discord message.
+   */
+  async deleteMessage(threadId, messageId) {
+    const { channelId } = this.decodeThreadId(threadId);
+    this.logger.debug("Discord API: DELETE message", {
+      channelId,
+      messageId
+    });
+    await this.discordFetch(
+      `/channels/${channelId}/messages/${messageId}`,
+      "DELETE"
+    );
+    this.logger.debug("Discord API: DELETE message response", { ok: true });
+  }
+  /**
+   * Add a reaction to a Discord message.
+   */
+  async addReaction(threadId, messageId, emoji) {
+    const { channelId } = this.decodeThreadId(threadId);
+    const emojiEncoded = this.encodeEmoji(emoji);
+    this.logger.debug("Discord API: PUT reaction", {
+      channelId,
+      messageId,
+      emoji: emojiEncoded
+    });
+    await this.discordFetch(
+      `/channels/${channelId}/messages/${messageId}/reactions/${emojiEncoded}/@me`,
+      "PUT"
+    );
+    this.logger.debug("Discord API: PUT reaction response", { ok: true });
+  }
+  /**
+   * Remove a reaction from a Discord message.
+   */
+  async removeReaction(threadId, messageId, emoji) {
+    const { channelId } = this.decodeThreadId(threadId);
+    const emojiEncoded = this.encodeEmoji(emoji);
+    this.logger.debug("Discord API: DELETE reaction", {
+      channelId,
+      messageId,
+      emoji: emojiEncoded
+    });
+    await this.discordFetch(
+      `/channels/${channelId}/messages/${messageId}/reactions/${emojiEncoded}/@me`,
+      "DELETE"
+    );
+    this.logger.debug("Discord API: DELETE reaction response", { ok: true });
+  }
+  /**
+   * Encode an emoji for use in Discord API URLs.
+   */
+  encodeEmoji(emoji) {
+    const emojiStr = defaultEmojiResolver.toDiscord ? defaultEmojiResolver.toDiscord(emoji) : String(emoji);
+    return encodeURIComponent(emojiStr);
+  }
+  /**
+   * Start typing indicator in a Discord channel or thread.
+   */
+  async startTyping(threadId) {
+    const { channelId, threadId: discordThreadId } = this.decodeThreadId(threadId);
+    const targetChannelId = discordThreadId || channelId;
+    this.logger.debug("Discord API: POST typing", {
+      channelId: targetChannelId
+    });
+    await this.discordFetch(`/channels/${targetChannelId}/typing`, "POST");
+  }
+  /**
+   * Fetch messages from a Discord channel or thread.
+   * If threadId includes a Discord thread ID, fetches from that thread channel.
+   */
+  async fetchMessages(threadId, options = {}) {
+    const { channelId, threadId: discordThreadId } = this.decodeThreadId(threadId);
+    const targetChannelId = discordThreadId || channelId;
+    const limit = options.limit || 50;
+    const direction = options.direction ?? "backward";
+    const params = new URLSearchParams();
+    params.set("limit", String(limit));
+    if (options.cursor) {
+      if (direction === "backward") {
+        params.set("before", options.cursor);
+      } else {
+        params.set("after", options.cursor);
+      }
+    }
+    this.logger.debug("Discord API: GET messages", {
+      channelId: targetChannelId,
+      limit,
+      direction,
+      cursor: options.cursor
+    });
+    const response = await this.discordFetch(
+      `/channels/${targetChannelId}/messages?${params.toString()}`,
+      "GET"
+    );
+    const rawMessages = await response.json();
+    this.logger.debug("Discord API: GET messages response", {
+      messageCount: rawMessages.length
+    });
+    const sortedMessages = [...rawMessages].reverse();
+    const messages = sortedMessages.map(
+      (msg) => this.parseDiscordMessage(msg, threadId)
+    );
+    let nextCursor;
+    if (rawMessages.length === limit) {
+      if (direction === "backward") {
+        const oldest = rawMessages[rawMessages.length - 1];
+        nextCursor = oldest?.id;
+      } else {
+        const newest = rawMessages[0];
+        nextCursor = newest?.id;
+      }
+    }
+    return {
+      messages,
+      nextCursor
+    };
+  }
+  /**
+   * Fetch thread/channel information.
+   */
+  async fetchThread(threadId) {
+    const { channelId, guildId } = this.decodeThreadId(threadId);
+    this.logger.debug("Discord API: GET channel", { channelId });
+    const response = await this.discordFetch(`/channels/${channelId}`, "GET");
+    const channel = await response.json();
+    return {
+      id: threadId,
+      channelId,
+      channelName: channel.name,
+      isDM: channel.type === ChannelType.DM || channel.type === ChannelType.GroupDM,
+      metadata: {
+        guildId,
+        channelType: channel.type,
+        raw: channel
+      }
+    };
+  }
+  /**
+   * Open a DM with a user.
+   */
+  async openDM(userId) {
+    this.logger.debug("Discord API: POST DM channel", { userId });
+    const response = await this.discordFetch(`/users/@me/channels`, "POST", {
+      recipient_id: userId
+    });
+    const dmChannel = await response.json();
+    this.logger.debug("Discord API: POST DM channel response", {
+      channelId: dmChannel.id
+    });
+    return this.encodeThreadId({
+      guildId: "@me",
+      channelId: dmChannel.id
+    });
+  }
+  /**
+   * Check if a thread is a DM.
+   */
+  isDM(threadId) {
+    const { guildId } = this.decodeThreadId(threadId);
+    return guildId === "@me";
+  }
+  /**
+   * Encode platform data into a thread ID string.
+   */
+  encodeThreadId(platformData) {
+    const threadPart = platformData.threadId ? `:${platformData.threadId}` : "";
+    return `discord:${platformData.guildId}:${platformData.channelId}${threadPart}`;
+  }
+  /**
+   * Decode thread ID string back to platform data.
+   */
+  decodeThreadId(threadId) {
+    const parts = threadId.split(":");
+    if (parts.length < 3 || parts[0] !== "discord") {
+      throw new ValidationError(
+        "discord",
+        `Invalid Discord thread ID: ${threadId}`
+      );
+    }
+    return {
+      guildId: parts[1],
+      channelId: parts[2],
+      threadId: parts[3]
+    };
+  }
+  /**
+   * Parse a Discord message into normalized format.
+   */
+  parseMessage(raw) {
+    const msg = raw;
+    const guildId = msg.guild_id || "@me";
+    const threadId = this.encodeThreadId({
+      guildId,
+      channelId: msg.channel_id
+    });
+    return this.parseDiscordMessage(msg, threadId);
+  }
+  /**
+   * Parse a Discord API message into normalized format.
+   */
+  parseDiscordMessage(msg, threadId) {
+    const author = msg.author;
+    const isBot = author.bot ?? false;
+    const isMe = author.id === this.botUserId;
+    return {
+      id: msg.id,
+      threadId,
+      text: this.formatConverter.extractPlainText(msg.content),
+      formatted: this.formatConverter.toAst(msg.content),
+      raw: msg,
+      author: {
+        userId: author.id,
+        userName: author.username,
+        fullName: author.global_name || author.username,
+        isBot,
+        isMe
+      },
+      metadata: {
+        dateSent: new Date(msg.timestamp),
+        edited: msg.edited_timestamp !== null,
+        editedAt: msg.edited_timestamp ? new Date(msg.edited_timestamp) : void 0
+      },
+      attachments: (msg.attachments || []).map((att) => ({
+        type: this.getAttachmentType(att.content_type),
+        url: att.url,
+        name: att.filename,
+        mimeType: att.content_type,
+        size: att.size,
+        width: att.width ?? void 0,
+        height: att.height ?? void 0
+      }))
+    };
+  }
+  /**
+   * Determine attachment type from MIME type.
+   */
+  getAttachmentType(mimeType) {
+    if (!mimeType) return "file";
+    if (mimeType.startsWith("image/")) return "image";
+    if (mimeType.startsWith("video/")) return "video";
+    if (mimeType.startsWith("audio/")) return "audio";
+    return "file";
+  }
+  /**
+   * Render formatted content to Discord markdown.
+   */
+  renderFormatted(content) {
+    return this.formatConverter.fromAst(content);
+  }
+  /**
+   * Make a request to the Discord API.
+   */
+  async discordFetch(path, method, body) {
+    const url = `${DISCORD_API_BASE}${path}`;
+    const headers = {
+      Authorization: `Bot ${this.botToken}`
+    };
+    if (body) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      this.logger.error("Discord API error", {
+        path,
+        method,
+        status: response.status,
+        error: errorText
+      });
+      throw new NetworkError(
+        "discord",
+        `Discord API error: ${response.status} ${errorText}`
+      );
+    }
+    return response;
+  }
+  /**
+   * Start Gateway WebSocket listener for receiving messages/mentions.
+   * Uses waitUntil to keep the connection alive for the specified duration.
+   *
+   * This is a workaround for serverless environments - the Gateway connection
+   * will stay alive for the duration, listening for messages.
+   *
+   * @param options - Webhook options with waitUntil function
+   * @param durationMs - How long to keep listening (default: 180000ms = 3 minutes)
+   * @param abortSignal - Optional AbortSignal to stop the listener early (e.g., when a new listener starts)
+   * @param webhookUrl - URL to forward Gateway events to (required for webhook forwarding mode)
+   * @returns Response indicating the listener was started
+   */
+  async startGatewayListener(options, durationMs = 18e4, abortSignal, webhookUrl) {
+    if (!this.chat) {
+      return new Response("Chat instance not initialized", { status: 500 });
+    }
+    if (!options.waitUntil) {
+      return new Response("waitUntil not provided", { status: 500 });
+    }
+    this.logger.info("Starting Discord Gateway listener", {
+      durationMs,
+      webhookUrl: webhookUrl ? "configured" : "not configured"
+    });
+    const listenerPromise = this.runGatewayListener(
+      durationMs,
+      abortSignal,
+      webhookUrl
+    );
+    options.waitUntil(listenerPromise);
+    return new Response(
+      JSON.stringify({
+        status: "listening",
+        durationMs,
+        message: `Gateway listener started, will run for ${durationMs / 1e3} seconds`
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+  /**
+   * Run the Gateway listener for a specified duration.
+   */
+  async runGatewayListener(durationMs, abortSignal, webhookUrl) {
+    const client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.GuildMessageReactions,
+        GatewayIntentBits.DirectMessageReactions
+      ]
+    });
+    let isShuttingDown = false;
+    if (webhookUrl) {
+      client.on("raw", async (packet) => {
+        if (isShuttingDown) return;
+        if (!packet.t) return;
+        this.logger.info("Discord Gateway forwarding event", {
+          type: packet.t
+        });
+        await this.forwardGatewayEvent(webhookUrl, {
+          type: `GATEWAY_${packet.t}`,
+          timestamp: Date.now(),
+          data: packet.d
+        });
+      });
+    } else {
+      this.setupLegacyGatewayHandlers(client, () => isShuttingDown);
+    }
+    client.on(Events.ClientReady, () => {
+      this.logger.info("Discord Gateway connected", {
+        username: client.user?.username,
+        id: client.user?.id
+      });
+    });
+    client.on(Events.Error, (error) => {
+      this.logger.error("Discord Gateway error", { error: String(error) });
+    });
+    try {
+      await client.login(this.botToken);
+      await new Promise((resolve) => {
+        const timeout = setTimeout(resolve, durationMs);
+        if (abortSignal) {
+          if (abortSignal.aborted) {
+            clearTimeout(timeout);
+            resolve();
+            return;
+          }
+          abortSignal.addEventListener(
+            "abort",
+            () => {
+              this.logger.info(
+                "Discord Gateway listener received abort signal (new listener started)"
+              );
+              clearTimeout(timeout);
+              resolve();
+            },
+            { once: true }
+          );
+        }
+      });
+      this.logger.info(
+        "Discord Gateway listener duration elapsed, disconnecting"
+      );
+    } catch (error) {
+      this.logger.error("Discord Gateway listener error", {
+        error: String(error)
+      });
+    } finally {
+      isShuttingDown = true;
+      client.destroy();
+      this.logger.info("Discord Gateway listener stopped");
+    }
+  }
+  /**
+   * Set up legacy Gateway handlers for direct processing (when webhookUrl is not provided).
+   */
+  setupLegacyGatewayHandlers(client, isShuttingDown) {
+    client.on(Events.MessageCreate, async (message) => {
+      if (isShuttingDown()) {
+        this.logger.debug("Ignoring message - Gateway is shutting down");
+        return;
+      }
+      if (message.author.bot) {
+        this.logger.debug("Ignoring message from bot", {
+          authorId: message.author.id,
+          authorName: message.author.username,
+          isMe: message.author.id === client.user?.id
+        });
+        return;
+      }
+      const isUserMentioned = message.mentions.has(client.user?.id ?? "");
+      const isRoleMentioned = this.mentionRoleIds.length > 0 && message.mentions.roles.some(
+        (role) => this.mentionRoleIds.includes(role.id)
+      );
+      const isMentioned = isUserMentioned || isRoleMentioned;
+      this.logger.info("Discord Gateway message received", {
+        channelId: message.channelId,
+        guildId: message.guildId,
+        authorId: message.author.id,
+        isMentioned,
+        isUserMentioned,
+        isRoleMentioned,
+        content: message.content.slice(0, 100)
+      });
+      await this.handleGatewayMessage(message, isMentioned);
+    });
+    client.on(Events.MessageReactionAdd, async (reaction, user) => {
+      if (isShuttingDown()) {
+        this.logger.debug("Ignoring reaction - Gateway is shutting down");
+        return;
+      }
+      if (user.bot) {
+        this.logger.debug("Ignoring reaction from bot", {
+          userId: user.id,
+          isMe: user.id === client.user?.id
+        });
+        return;
+      }
+      this.logger.info("Discord Gateway reaction added", {
+        emoji: reaction.emoji.name,
+        messageId: reaction.message.id,
+        channelId: reaction.message.channelId,
+        userId: user.id
+      });
+      if (user.username) {
+        await this.handleGatewayReaction(
+          reaction,
+          user,
+          true
+        );
+      }
+    });
+    client.on(Events.MessageReactionRemove, async (reaction, user) => {
+      if (isShuttingDown()) {
+        this.logger.debug(
+          "Ignoring reaction removal - Gateway is shutting down"
+        );
+        return;
+      }
+      if (user.bot) {
+        this.logger.debug("Ignoring reaction removal from bot", {
+          userId: user.id,
+          isMe: user.id === client.user?.id
+        });
+        return;
+      }
+      this.logger.info("Discord Gateway reaction removed", {
+        emoji: reaction.emoji.name,
+        messageId: reaction.message.id,
+        channelId: reaction.message.channelId,
+        userId: user.id
+      });
+      if (user.username) {
+        await this.handleGatewayReaction(
+          reaction,
+          user,
+          false
+        );
+      }
+    });
+  }
+  /**
+   * Forward a Gateway event to the webhook endpoint.
+   */
+  async forwardGatewayEvent(webhookUrl, event) {
+    try {
+      this.logger.debug("Forwarding Gateway event to webhook", {
+        type: event.type,
+        webhookUrl
+      });
+      const response = await fetch(webhookUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-discord-gateway-token": this.botToken
+        },
+        body: JSON.stringify(event)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.logger.error("Failed to forward Gateway event", {
+          type: event.type,
+          status: response.status,
+          error: errorText
+        });
+      } else {
+        this.logger.debug("Gateway event forwarded successfully", {
+          type: event.type
+        });
+      }
+    } catch (error) {
+      this.logger.error("Error forwarding Gateway event", {
+        type: event.type,
+        error: String(error)
+      });
+    }
+  }
+  /**
+   * Handle a message received via the Gateway WebSocket.
+   */
+  async handleGatewayMessage(message, isMentioned) {
+    if (!this.chat) return;
+    const guildId = message.guildId || "@me";
+    const channelId = message.channelId;
+    const isInThread = message.channel.isThread();
+    let discordThreadId;
+    let parentChannelId = channelId;
+    if (isInThread && "parentId" in message.channel && message.channel.parentId) {
+      discordThreadId = channelId;
+      parentChannelId = message.channel.parentId;
+    }
+    if (!discordThreadId && isMentioned) {
+      try {
+        const newThread = await this.createDiscordThread(channelId, message.id);
+        discordThreadId = newThread.id;
+        this.logger.debug("Created Discord thread for incoming mention", {
+          channelId,
+          messageId: message.id,
+          threadId: newThread.id
+        });
+      } catch (error) {
+        this.logger.error("Failed to create Discord thread for mention", {
+          error: String(error),
+          messageId: message.id
+        });
+      }
+    }
+    const threadId = this.encodeThreadId({
+      guildId,
+      channelId: parentChannelId,
+      threadId: discordThreadId
+    });
+    const chatMessage = {
+      id: message.id,
+      threadId,
+      text: message.content,
+      formatted: this.formatConverter.toAst(message.content),
+      author: {
+        userId: message.author.id,
+        userName: message.author.username,
+        fullName: message.author.displayName || message.author.username,
+        isBot: message.author.bot,
+        isMe: false
+        // Gateway messages are never from ourselves (we filter those)
+      },
+      metadata: {
+        dateSent: message.createdAt,
+        edited: message.editedAt !== null,
+        editedAt: message.editedAt ?? void 0
+      },
+      attachments: message.attachments.map((a) => ({
+        type: this.getAttachmentType(a.contentType),
+        url: a.url,
+        name: a.name,
+        mimeType: a.contentType ?? void 0,
+        size: a.size
+      })),
+      raw: {
+        id: message.id,
+        channel_id: channelId,
+        guild_id: guildId,
+        content: message.content,
+        author: {
+          id: message.author.id,
+          username: message.author.username
+        },
+        timestamp: message.createdAt.toISOString()
+      },
+      // Add isMention flag for the chat handlers
+      isMention: isMentioned
+    };
+    try {
+      await this.chat.handleIncomingMessage(this, threadId, chatMessage);
+    } catch (error) {
+      this.logger.error("Error handling Gateway message", {
+        error: String(error),
+        messageId: message.id
+      });
+    }
+  }
+  /**
+   * Handle a reaction received via the Gateway WebSocket.
+   */
+  async handleGatewayReaction(reaction, user, added) {
+    if (!this.chat) return;
+    const guildId = reaction.message.guildId || "@me";
+    const channelId = reaction.message.channelId;
+    const threadId = this.encodeThreadId({
+      guildId,
+      channelId,
+      threadId: void 0
+    });
+    const emojiName = reaction.emoji.name || "unknown";
+    const normalizedEmoji = this.normalizeDiscordEmoji(emojiName);
+    const reactionEvent = {
+      adapter: this,
+      threadId,
+      messageId: reaction.message.id,
+      emoji: normalizedEmoji,
+      rawEmoji: reaction.emoji.id ? `<:${emojiName}:${reaction.emoji.id}>` : emojiName,
+      added,
+      user: {
+        userId: user.id,
+        userName: user.username,
+        fullName: user.username,
+        isBot: user.bot === true,
+        // Match pattern from handleForwardedReaction
+        isMe: user.id === this.applicationId
+      },
+      raw: {
+        emoji: reaction.emoji,
+        message_id: reaction.message.id,
+        channel_id: reaction.message.channelId,
+        guild_id: reaction.message.guildId,
+        user_id: user.id
+      }
+    };
+    this.chat.processReaction(reactionEvent);
+  }
+  /**
+   * Normalize a Discord emoji to our standard EmojiValue format.
+   */
+  normalizeDiscordEmoji(emojiName) {
+    const unicodeToName = {
+      "\u{1F44D}": "thumbs_up",
+      "\u{1F44E}": "thumbs_down",
+      "\u2764\uFE0F": "heart",
+      "\u2764": "heart",
+      "\u{1F525}": "fire",
+      "\u{1F680}": "rocket",
+      "\u{1F64C}": "raised_hands",
+      "\u2705": "check",
+      "\u274C": "x",
+      "\u{1F44B}": "wave",
+      "\u{1F914}": "thinking",
+      "\u{1F60A}": "smile",
+      "\u{1F602}": "laugh",
+      "\u{1F389}": "party",
+      "\u2B50": "star",
+      "\u2728": "sparkles",
+      "\u{1F440}": "eyes",
+      "\u{1F4AF}": "100"
+    };
+    const normalizedName = unicodeToName[emojiName] || emojiName;
+    return getEmoji(normalizedName);
+  }
+};
+function createDiscordAdapter(config) {
+  return new DiscordAdapter(config);
+}
+export {
+  DiscordAdapter,
+  DiscordFormatConverter,
+  DiscordFormatConverter as DiscordMarkdownConverter,
+  cardToDiscordPayload,
+  cardToFallbackText,
+  createDiscordAdapter
+};
+//# sourceMappingURL=index.js.map