@agentforge-ai/channels-discord 0.6.0

package/dist/index.js

@@ -0,0 +1,875 @@
+// src/discord-adapter.ts
+import {
+  Client,
+  GatewayIntentBits,
+  Partials,
+  Routes,
+  ChannelType,
+  Events
+} from "discord.js";
+import { REST } from "@discordjs/rest";
+import {
+  ChannelAdapter,
+  MessageNormalizer
+} from "@agentforge-ai/core";
+
+// src/types.ts
+var DISCORD_BOT_COMMANDS = [
+  { name: "start", description: "Start a new conversation with the AI agent" },
+  { name: "new", description: "Reset the current conversation thread" },
+  { name: "help", description: "Show available commands and usage information" }
+];
+
+// src/discord-adapter.ts
+var DiscordAdapter = class extends ChannelAdapter {
+  platform = "discord";
+  client = null;
+  adapterConfig = null;
+  botUserId = "";
+  // Rate limiting
+  messageTimestamps = [];
+  rateLimitPerSecond = 5;
+  // ----- Lifecycle -----
+  async connect(config) {
+    const botToken = config.credentials.botToken;
+    if (!botToken) {
+      throw new Error("Discord bot token is required in credentials.botToken");
+    }
+    this.adapterConfig = {
+      botToken,
+      clientId: config.credentials.clientId ?? config.settings?.clientId,
+      guildId: config.credentials.guildId ?? config.settings?.guildId,
+      registerCommands: config.settings?.registerCommands ?? true,
+      mentionOnly: config.settings?.mentionOnly ?? false,
+      respondToDMs: config.settings?.respondToDMs ?? true,
+      rateLimitPerSecond: config.settings?.rateLimitPerSecond ?? 5
+    };
+    this.rateLimitPerSecond = this.adapterConfig.rateLimitPerSecond;
+    const intents = [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.DirectMessages,
+      GatewayIntentBits.GuildMessageReactions
+    ];
+    this.client = new Client({
+      intents,
+      partials: [Partials.Channel, Partials.Message]
+    });
+    this.registerClientEvents();
+    await this.client.login(botToken);
+    await this.waitForReady();
+    if (this.adapterConfig.registerCommands && this.adapterConfig.clientId) {
+      await this.registerSlashCommands(
+        botToken,
+        this.adapterConfig.clientId,
+        DISCORD_BOT_COMMANDS,
+        this.adapterConfig.guildId
+      );
+    }
+  }
+  async disconnect() {
+    if (this.client) {
+      this.client.removeAllListeners();
+      this.client.destroy();
+      this.client = null;
+    }
+    this.botUserId = "";
+    this.adapterConfig = null;
+  }
+  // ----- Message Sending -----
+  async sendMessage(message) {
+    try {
+      await this.enforceRateLimit();
+      const targetChannelId = message.threadId ?? message.chatId;
+      const channel = await this.resolveChannel(targetChannelId);
+      if (!channel) {
+        return { success: false, error: `Channel ${targetChannelId} not found` };
+      }
+      if (message.showTyping) {
+        await this.sendTypingIndicator(message.chatId);
+        if (message.typingDurationMs) {
+          await this.sleep(message.typingDurationMs);
+        }
+      }
+      const sendableChannel = channel;
+      const payload = this.buildMessagePayload(message);
+      const sent = await sendableChannel.send(payload);
+      return {
+        success: true,
+        platformMessageId: sent.id,
+        deliveredAt: sent.createdAt
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  // ----- Capabilities -----
+  getCapabilities() {
+    return {
+      supportedMedia: ["image", "audio", "video", "file"],
+      maxTextLength: 2e3,
+      supportsThreads: true,
+      supportsReactions: true,
+      supportsEditing: true,
+      supportsDeleting: true,
+      supportsTypingIndicator: true,
+      supportsReadReceipts: false,
+      supportsActions: false,
+      supportsGroupChat: true,
+      supportsMarkdown: true,
+      maxFileSize: 25 * 1024 * 1024,
+      // 25MB
+      platformSpecific: {
+        supportsEmbeds: true,
+        supportsSlashCommands: true,
+        supportsThreads: true,
+        supportsForums: true,
+        supportsNitroFileSize: 500 * 1024 * 1024
+        // 500MB for Nitro servers
+      }
+    };
+  }
+  // ----- Health Check -----
+  async healthCheck() {
+    if (!this.client || !this.client.isReady()) {
+      return { status: "disconnected", details: "Discord client is not ready" };
+    }
+    try {
+      const user = this.client.user;
+      if (user) {
+        return {
+          status: "healthy",
+          details: `Bot ${user.tag} (ID: ${user.id}) is connected`
+        };
+      }
+      return { status: "degraded", details: "Client ready but user is null" };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        details: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  // ----- Optional Overrides -----
+  async editMessage(platformMessageId, message) {
+    try {
+      if (!message.text && !message.platformOptions?.embeds) {
+        return { success: false, error: "Text or embeds are required for editing" };
+      }
+      const targetChannelId = message.threadId ?? message.chatId;
+      if (!targetChannelId) {
+        return { success: false, error: "chatId is required for editing" };
+      }
+      const channel = await this.resolveChannel(targetChannelId);
+      if (!channel) {
+        return { success: false, error: `Channel ${targetChannelId} not found` };
+      }
+      const textChannel = channel;
+      const msg = await textChannel.messages.fetch(platformMessageId);
+      const editPayload = this.buildMessagePayload(message);
+      await msg.edit(editPayload);
+      return { success: true, platformMessageId };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async deleteMessage(platformMessageId, chatId) {
+    try {
+      const channel = await this.resolveChannel(chatId);
+      if (!channel) return false;
+      const textChannel = channel;
+      const msg = await textChannel.messages.fetch(platformMessageId);
+      await msg.delete();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async sendTypingIndicator(chatId) {
+    try {
+      const channel = await this.resolveChannel(chatId);
+      if (!channel) return;
+      const sendable = channel;
+      await sendable.sendTyping();
+    } catch {
+    }
+  }
+  async addReaction(platformMessageId, chatId, emoji) {
+    try {
+      const channel = await this.resolveChannel(chatId);
+      if (!channel) return false;
+      const textChannel = channel;
+      const msg = await textChannel.messages.fetch(platformMessageId);
+      await msg.react(emoji);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ----- Internal: Client Events -----
+  registerClientEvents() {
+    if (!this.client) return;
+    this.client.on(Events.MessageCreate, (message) => {
+      this.handleDiscordMessage(message);
+    });
+    this.client.on(Events.MessageUpdate, (_old, newMessage) => {
+      if (newMessage.partial) return;
+      this.handleDiscordMessage(newMessage, true);
+    });
+    this.client.on(Events.InteractionCreate, (interaction) => {
+      if (interaction.isChatInputCommand()) {
+        this.handleSlashCommand(interaction);
+      }
+    });
+    this.client.on(Events.Error, (error) => {
+      this.emit({
+        type: "error",
+        data: { error, recoverable: true }
+      });
+    });
+  }
+  // ----- Internal: Message Handling -----
+  handleDiscordMessage(message, isEdit = false) {
+    if (message.author.id === this.botUserId) return;
+    if (message.author.bot) return;
+    if (message.guild && this.adapterConfig?.mentionOnly) {
+      if (!this.isBotMentioned(message)) return;
+    }
+    if (!message.guild && !this.adapterConfig?.respondToDMs) return;
+    const normalized = this.normalizeDiscordMessage(message, isEdit);
+    if (isEdit) {
+      this.emit({ type: "message_edited", data: normalized });
+    } else {
+      this.emitMessage(normalized);
+    }
+  }
+  handleSlashCommand(interaction) {
+    const normalized = this.normalizeSlashCommand(interaction);
+    this.emitMessage(normalized);
+  }
+  // ----- Internal: Message Normalization -----
+  normalizeDiscordMessage(message, isEdit) {
+    const chatId = message.channelId;
+    const threadId = message.thread?.id;
+    const chatType = this.mapChannelType(message.channel);
+    let text = message.content;
+    if (this.botUserId && text) {
+      text = text.replace(new RegExp(`<@!?${this.botUserId}>`, "g"), "").trim();
+    }
+    const media = this.extractMedia(message);
+    return MessageNormalizer.normalize({
+      platformMessageId: message.id,
+      channelId: this.config?.id ?? "",
+      platform: "discord",
+      chatId,
+      chatType,
+      senderId: message.author.id,
+      senderName: message.member?.displayName ?? message.author.displayName,
+      senderUsername: message.author.username,
+      senderAvatar: message.author.displayAvatarURL(),
+      text: text || void 0,
+      media,
+      replyToId: message.reference?.messageId,
+      threadId: threadId ?? (chatType === "thread" ? chatId : void 0),
+      rawData: {
+        guildId: message.guildId,
+        channelId: message.channelId,
+        messageType: message.type
+      },
+      timestamp: message.createdAt,
+      isEdit
+    });
+  }
+  normalizeSlashCommand(interaction) {
+    const chatType = this.mapChannelType(interaction.channel);
+    return MessageNormalizer.normalize({
+      platformMessageId: interaction.id,
+      channelId: this.config?.id ?? "",
+      platform: "discord",
+      chatId: interaction.channelId,
+      chatType,
+      senderId: interaction.user.id,
+      senderName: interaction.member ? interaction.member.displayName ?? interaction.user.displayName : interaction.user.displayName,
+      senderUsername: interaction.user.username,
+      senderAvatar: interaction.user.displayAvatarURL(),
+      text: `/${interaction.commandName}`,
+      rawData: {
+        guildId: interaction.guildId,
+        channelId: interaction.channelId,
+        interactionId: interaction.id,
+        commandName: interaction.commandName,
+        isSlashCommand: true
+      },
+      timestamp: interaction.createdAt
+    });
+  }
+  extractMedia(message) {
+    if (message.attachments.size === 0) return void 0;
+    const media = [];
+    for (const attachment of message.attachments.values()) {
+      const mimeType = attachment.contentType ?? void 0;
+      const mediaType = this.mapMimeTypeToMediaType(mimeType);
+      media.push({
+        type: mediaType,
+        url: attachment.url,
+        fileName: attachment.name ?? void 0,
+        mimeType,
+        sizeBytes: attachment.size,
+        width: attachment.width ?? void 0,
+        height: attachment.height ?? void 0
+      });
+    }
+    return media.length > 0 ? media : void 0;
+  }
+  mapMimeTypeToMediaType(mimeType) {
+    if (!mimeType) return "file";
+    if (mimeType.startsWith("image/")) return "image";
+    if (mimeType.startsWith("audio/")) return "audio";
+    if (mimeType.startsWith("video/")) return "video";
+    return "file";
+  }
+  mapChannelType(channel) {
+    if (!channel) return "channel";
+    switch (channel.type) {
+      case ChannelType.DM:
+      case ChannelType.GroupDM:
+        return "dm";
+      case ChannelType.PublicThread:
+      case ChannelType.PrivateThread:
+      case ChannelType.AnnouncementThread:
+        return "thread";
+      case ChannelType.GuildText:
+      case ChannelType.GuildAnnouncement:
+      case ChannelType.GuildForum:
+      case ChannelType.GuildVoice:
+        return "channel";
+      default:
+        return "channel";
+    }
+  }
+  // ----- Internal: Message Payload Builder -----
+  buildMessagePayload(message) {
+    const payload = {};
+    if (message.text) {
+      payload["content"] = message.text;
+    }
+    const embeds = message.platformOptions?.embeds;
+    if (embeds) {
+      payload["embeds"] = embeds;
+    }
+    if (message.replyToMessageId) {
+      payload["reply"] = { messageReference: message.replyToMessageId };
+    }
+    return payload;
+  }
+  // ----- Internal: @Mention Detection -----
+  isBotMentioned(message) {
+    if (!this.botUserId) return false;
+    return message.mentions.users.has(this.botUserId);
+  }
+  // ----- Internal: Channel Resolution -----
+  async resolveChannel(channelId) {
+    if (!this.client) return null;
+    try {
+      const cached = this.client.channels.cache.get(channelId);
+      if (cached) return cached;
+      return await this.client.channels.fetch(channelId);
+    } catch {
+      return null;
+    }
+  }
+  // ----- Internal: Slash Command Registration -----
+  async registerSlashCommands(botToken, clientId, commands, guildId) {
+    try {
+      const rest = new REST({ version: "10" }).setToken(botToken);
+      const route = guildId ? Routes.applicationGuildCommands(clientId, guildId) : Routes.applicationCommands(clientId);
+      await rest.put(route, { body: commands });
+    } catch {
+      this.emit({
+        type: "error",
+        data: {
+          error: new Error("Failed to register Discord slash commands"),
+          recoverable: true
+        }
+      });
+    }
+  }
+  // ----- Internal: Ready Wait -----
+  waitForReady() {
+    return new Promise((resolve, reject) => {
+      if (!this.client) {
+        reject(new Error("Discord client is not initialized"));
+        return;
+      }
+      if (this.client.isReady()) {
+        this.botUserId = this.client.user.id;
+        resolve();
+        return;
+      }
+      const onReady = () => {
+        this.botUserId = this.client.user.id;
+        resolve();
+      };
+      const onError = (error) => {
+        reject(error);
+      };
+      this.client.once(Events.ClientReady, onReady);
+      this.client.once(Events.Error, onError);
+      const timeout = setTimeout(() => {
+        this.client?.off(Events.ClientReady, onReady);
+        this.client?.off(Events.Error, onError);
+        reject(new Error("Discord client did not become ready within 30 seconds"));
+      }, 3e4);
+      this.client.once(Events.ClientReady, () => clearTimeout(timeout));
+    });
+  }
+  // ----- Internal: Rate Limiting -----
+  async enforceRateLimit() {
+    const now = Date.now();
+    this.messageTimestamps = this.messageTimestamps.filter((t) => now - t < 1e3);
+    if (this.messageTimestamps.length >= this.rateLimitPerSecond) {
+      const oldestInWindow = this.messageTimestamps[0];
+      const waitMs = 1e3 - (now - oldestInWindow);
+      if (waitMs > 0) {
+        await this.sleep(waitMs);
+      }
+    }
+    this.messageTimestamps.push(Date.now());
+  }
+  // ----- Utility -----
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/discord-channel.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function createLogger(level = "info") {
+  const threshold = LOG_LEVELS[level] ?? 1;
+  const prefix = "[agentforge:discord]";
+  return {
+    debug: (...args) => {
+      if (threshold <= 0) console.log(`${prefix} [DEBUG]`, ...args);
+    },
+    info: (...args) => {
+      if (threshold <= 1) console.log(`${prefix}`, ...args);
+    },
+    warn: (...args) => {
+      if (threshold <= 2) console.warn(`${prefix} [WARN]`, ...args);
+    },
+    error: (...args) => {
+      if (threshold <= 3) console.error(`${prefix} [ERROR]`, ...args);
+    }
+  };
+}
+var ConvexHttpApi = class {
+  baseUrl;
+  constructor(deploymentUrl) {
+    this.baseUrl = deploymentUrl.replace(/\/$/, "");
+  }
+  async query(functionPath, args = {}) {
+    const url = `${this.baseUrl}/api/query`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: functionPath, args })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Convex query ${functionPath} failed: ${response.status} ${text}`);
+    }
+    const data = await response.json();
+    if (data.status === "error") {
+      throw new Error(`Convex query ${functionPath} error: ${data.errorMessage}`);
+    }
+    return data.value;
+  }
+  async mutation(functionPath, args = {}) {
+    const url = `${this.baseUrl}/api/mutation`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: functionPath, args })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Convex mutation ${functionPath} failed: ${response.status} ${text}`);
+    }
+    const data = await response.json();
+    if (data.status === "error") {
+      throw new Error(`Convex mutation ${functionPath} error: ${data.errorMessage}`);
+    }
+    return data.value;
+  }
+  async action(functionPath, args = {}) {
+    const url = `${this.baseUrl}/api/action`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: functionPath, args })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Convex action ${functionPath} failed: ${response.status} ${text}`);
+    }
+    const data = await response.json();
+    if (data.status === "error") {
+      throw new Error(`Convex action ${functionPath} error: ${data.errorMessage}`);
+    }
+    return data.value;
+  }
+};
+var DiscordChannel = class {
+  adapter;
+  convex;
+  config;
+  threadMap = /* @__PURE__ */ new Map();
+  logger;
+  processingMessages = /* @__PURE__ */ new Set();
+  isRunning = false;
+  constructor(config) {
+    this.config = config;
+    this.adapter = new DiscordAdapter();
+    this.convex = new ConvexHttpApi(config.convexUrl);
+    this.logger = createLogger(config.logLevel);
+  }
+  /**
+   * Start the Discord channel bot.
+   * Connects to Discord and begins listening for messages.
+   */
+  async start() {
+    if (this.isRunning) {
+      this.logger.warn("Discord channel is already running");
+      return;
+    }
+    this.logger.info("Starting Discord channel...");
+    this.logger.info(`Agent ID: ${this.config.agentId}`);
+    this.logger.info(`Convex URL: ${this.config.convexUrl}`);
+    try {
+      const agent = await this.convex.query("agents:get", { id: this.config.agentId });
+      if (!agent) {
+        throw new Error(
+          `Agent "${this.config.agentId}" not found in Convex. Create it first with: agentforge agents create`
+        );
+      }
+      const agentData = agent;
+      this.logger.info(`Agent: ${agentData.name} (${agentData.model} via ${agentData.provider})`);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not found")) {
+        throw error;
+      }
+      this.logger.warn("Could not verify agent (Convex may be unreachable). Continuing...");
+    }
+    this.adapter.on(this.handleEvent.bind(this));
+    const channelConfig = {
+      id: `discord-${this.config.agentId}`,
+      platform: "discord",
+      orgId: "default",
+      agentId: this.config.agentId,
+      enabled: true,
+      credentials: {
+        botToken: this.config.botToken,
+        ...this.config.clientId ? { clientId: this.config.clientId } : {},
+        ...this.config.guildId ? { guildId: this.config.guildId } : {}
+      },
+      settings: {
+        mentionOnly: this.config.mentionOnly ?? false,
+        respondToDMs: this.config.respondToDMs ?? true,
+        registerCommands: true
+      },
+      autoReconnect: true,
+      reconnectIntervalMs: 5e3,
+      maxReconnectAttempts: 20
+    };
+    await this.adapter.start(channelConfig);
+    this.isRunning = true;
+    this.logger.info("Discord channel started successfully!");
+    this.logger.info("Bot is listening for messages...");
+    this.logger.info("Press Ctrl+C to stop.");
+  }
+  /**
+   * Stop the Discord channel bot.
+   */
+  async stop() {
+    if (!this.isRunning) return;
+    this.logger.info("Stopping Discord channel...");
+    await this.adapter.stop();
+    this.isRunning = false;
+    this.threadMap.clear();
+    this.processingMessages.clear();
+    this.logger.info("Discord channel stopped.");
+  }
+  /**
+   * Get the current thread map (for debugging).
+   */
+  getThreadMap() {
+    return this.threadMap;
+  }
+  /**
+   * Get the underlying DiscordAdapter instance.
+   */
+  getAdapter() {
+    return this.adapter;
+  }
+  /**
+   * Check if the channel is running.
+   */
+  get running() {
+    return this.isRunning;
+  }
+  // ----- Internal: Event Handling -----
+  async handleEvent(event) {
+    switch (event.type) {
+      case "message":
+        await this.handleInboundMessage(event.data);
+        break;
+      case "connection_state":
+        this.logger.debug("Connection state:", event.data.state);
+        break;
+      case "error":
+        this.logger.error("Adapter error:", event.data.error.message);
+        break;
+      default:
+        this.logger.debug("Unhandled event type:", event.type);
+    }
+  }
+  async handleInboundMessage(message) {
+    if (!message.text?.trim()) {
+      this.logger.debug("Skipping empty message");
+      return;
+    }
+    const dedupKey = `${message.chatId}:${message.platformMessageId}`;
+    if (this.processingMessages.has(dedupKey)) {
+      this.logger.debug("Skipping duplicate message:", dedupKey);
+      return;
+    }
+    this.processingMessages.add(dedupKey);
+    const senderName = message.sender.displayName ?? message.sender.username ?? "Unknown";
+    this.logger.info(`Message from ${senderName} (channel ${message.chatId}): ${message.text}`);
+    try {
+      if (message.text.startsWith("/start")) {
+        await this.handleStartCommand(message);
+        return;
+      }
+      if (message.text.startsWith("/new")) {
+        this.threadMap.delete(message.chatId);
+        await this.adapter.sendMessage({
+          chatId: message.chatId,
+          text: "New conversation started. Send me a message!"
+        });
+        return;
+      }
+      if (message.text.startsWith("/help")) {
+        await this.handleHelpCommand(message);
+        return;
+      }
+      await this.routeToAgent(message);
+    } catch (error) {
+      this.logger.error("Error handling message:", error);
+      try {
+        await this.adapter.sendMessage({
+          chatId: message.chatId,
+          text: "Sorry, I encountered an error processing your message. Please try again."
+        });
+      } catch {
+        this.logger.error("Failed to send error message to user");
+      }
+    } finally {
+      setTimeout(() => {
+        this.processingMessages.delete(dedupKey);
+      }, 3e4);
+    }
+  }
+  // ----- Internal: Agent Routing -----
+  /**
+   * Route a message through the AgentForge chat pipeline:
+   * 1. Get or create a Convex thread for this Discord channel
+   * 2. Call chat.sendMessage action
+   * 3. Send the agent response back to Discord
+   */
+  async routeToAgent(message) {
+    await this.adapter.sendTypingIndicator(message.chatId);
+    const threadId = await this.getOrCreateThread(
+      message.chatId,
+      message.sender.displayName
+    );
+    const userId = this.config.userId ?? `discord:${message.sender.platformUserId}`;
+    this.logger.debug(`Sending to agent ${this.config.agentId}, thread ${threadId}`);
+    const result = await this.convex.action("chat:sendMessage", {
+      agentId: this.config.agentId,
+      threadId,
+      content: message.text,
+      userId
+    });
+    if (result?.response) {
+      const chunks = this.splitMessage(result.response, 2e3);
+      for (const chunk of chunks) {
+        await this.adapter.sendMessage({
+          chatId: message.chatId,
+          text: chunk,
+          replyToMessageId: chunks.length === 1 ? message.platformMessageId : void 0
+        });
+      }
+      if (result.usage) {
+        this.logger.debug(`Tokens used: ${result.usage.totalTokens}`);
+      }
+    } else {
+      await this.adapter.sendMessage({
+        chatId: message.chatId,
+        text: "I received your message but couldn't generate a response. Please try again."
+      });
+    }
+  }
+  // ----- Internal: Thread Management -----
+  /**
+   * Get or create a Convex thread for a Discord channel.
+   * Threads are cached in memory and created lazily.
+   */
+  async getOrCreateThread(channelId, senderName) {
+    const cached = this.threadMap.get(channelId);
+    if (cached) return cached;
+    const threadName = senderName ? `Discord: ${senderName}` : `Discord Channel ${channelId}`;
+    const userId = this.config.userId ?? `discord:${channelId}`;
+    const threadId = await this.convex.mutation("chat:createThread", {
+      agentId: this.config.agentId,
+      name: threadName,
+      userId
+    });
+    this.threadMap.set(channelId, threadId);
+    this.logger.info(`Created new thread ${threadId} for channel ${channelId}`);
+    try {
+      await this.convex.mutation("logs:add", {
+        level: "info",
+        source: "discord",
+        message: `New Discord conversation started by ${senderName ?? channelId}`,
+        metadata: { channelId, threadId, agentId: this.config.agentId },
+        userId
+      });
+    } catch {
+    }
+    return threadId;
+  }
+  // ----- Internal: Command Handlers -----
+  async handleStartCommand(message) {
+    this.threadMap.delete(message.chatId);
+    let agentName = "AI Assistant";
+    try {
+      const agent = await this.convex.query("agents:get", { id: this.config.agentId });
+      if (agent) {
+        agentName = agent.name;
+      }
+    } catch {
+    }
+    await this.adapter.sendMessage({
+      chatId: message.chatId,
+      text: `Welcome! I'm **${agentName}**, powered by AgentForge.
+
+Send me a message and I'll respond using AI.
+
+**Commands:**
+/new \u2014 Start a new conversation
+/help \u2014 Show help information`
+    });
+  }
+  async handleHelpCommand(message) {
+    await this.adapter.sendMessage({
+      chatId: message.chatId,
+      text: `**AgentForge Discord Bot**
+
+Just send me a message and I'll respond using AI.
+
+**Commands:**
+/start \u2014 Reset and show welcome message
+/new \u2014 Start a fresh conversation thread
+/help \u2014 Show this help message
+
+*Powered by AgentForge \u2014 agentforge.dev*`
+    });
+  }
+  // ----- Internal: Utilities -----
+  /**
+   * Split a long message into chunks that fit Discord's 2000 char limit.
+   */
+  splitMessage(text, maxLength) {
+    if (text.length <= maxLength) return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+      if (remaining.length <= maxLength) {
+        chunks.push(remaining);
+        break;
+      }
+      let splitIdx = remaining.lastIndexOf("\n\n", maxLength);
+      if (splitIdx === -1 || splitIdx < maxLength / 2) {
+        splitIdx = remaining.lastIndexOf("\n", maxLength);
+      }
+      if (splitIdx === -1 || splitIdx < maxLength / 2) {
+        splitIdx = remaining.lastIndexOf(" ", maxLength);
+      }
+      if (splitIdx === -1 || splitIdx < maxLength / 2) {
+        splitIdx = maxLength;
+      }
+      chunks.push(remaining.substring(0, splitIdx));
+      remaining = remaining.substring(splitIdx).trimStart();
+    }
+    return chunks;
+  }
+};
+async function startDiscordChannel(overrides = {}) {
+  const botToken = overrides.botToken ?? process.env.DISCORD_BOT_TOKEN;
+  const convexUrl = overrides.convexUrl ?? process.env.CONVEX_URL;
+  const agentId = overrides.agentId ?? process.env.AGENTFORGE_AGENT_ID;
+  if (!botToken) {
+    throw new Error(
+      "DISCORD_BOT_TOKEN is required. Set it in your .env file or pass it as botToken in the config."
+    );
+  }
+  if (!convexUrl) {
+    throw new Error(
+      "CONVEX_URL is required. Set it in your .env file or pass it as convexUrl in the config."
+    );
+  }
+  if (!agentId) {
+    throw new Error(
+      "Agent ID is required. Pass it as agentId in the config or set AGENTFORGE_AGENT_ID env var."
+    );
+  }
+  const channel = new DiscordChannel({
+    botToken,
+    convexUrl,
+    agentId,
+    clientId: overrides.clientId ?? process.env.DISCORD_CLIENT_ID,
+    guildId: overrides.guildId ?? process.env.DISCORD_GUILD_ID,
+    mentionOnly: overrides.mentionOnly,
+    respondToDMs: overrides.respondToDMs,
+    userId: overrides.userId,
+    logLevel: overrides.logLevel
+  });
+  const shutdown = async () => {
+    console.log("\nShutting down Discord channel...");
+    await channel.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await channel.start();
+  return channel;
+}
+export {
+  DiscordAdapter,
+  DiscordChannel,
+  startDiscordChannel
+};
+//# sourceMappingURL=index.js.map