@elizaos/plugin-discord 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/index.js

@@ -1,29 +1,17 @@
 // src/index.ts
 import {
-  ChannelType as ChannelType10,
-  createUniqueUuid as createUniqueUuid6,
-  logger as logger7,
-  Role,
-  Service
+  logger as logger8
 } from "@elizaos/core";
-import {
-  ChannelType as DiscordChannelType4,
-  Client as DiscordJsClient,
-  Events as Events2,
-  GatewayIntentBits,
-  Partials,
-  PermissionsBitField as PermissionsBitField2
-} from "discord.js";
 
 // src/actions/chatWithAttachments.ts
+import fs from "node:fs";
 import {
   ChannelType,
-  composePrompt,
   ModelTypes,
+  composePromptFromState,
   parseJSONObjectFromText,
   trimTokens
 } from "@elizaos/core";
-import * as fs from "node:fs";
 var summarizationTemplate = `# Summarized so far (we are adding to this)
 {{currentSummary}}
 
@@ -49,7 +37,7 @@ Your response must be formatted as a JSON block with this structure:
 \`\`\`
 `;
 var getAttachmentIds = async (runtime, _message, state) => {
-  const prompt = composePrompt({
+  const prompt = composePromptFromState({
     state,
     template: attachmentIdsTemplate
   });
@@ -65,7 +53,7 @@ var getAttachmentIds = async (runtime, _message, state) => {
   }
   return null;
 };
-var summarizeAction = {
+var chatWithAttachments = {
   name: "CHAT_WITH_ATTACHMENTS",
   similes: [
     "CHAT_WITH_ATTACHMENT",
@@ -86,7 +74,7 @@ var summarizeAction = {
   ],
   description: "Answer a user request informed by specific attachments based on their IDs. If a user asks to chat with a PDF, or wants more specific information about a link or video or anything else they've attached, this is the action to use.",
   validate: async (_runtime, message, _state) => {
-    const room = await _runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = await _runtime.getRoom(message.roomId);
     if (room?.type !== ChannelType.GROUP) {
       return false;
     }
@@ -166,7 +154,7 @@ ${attachment.text}`).join("\n\n");
       chunkSize,
       runtime
     );
-    const prompt = composePrompt({
+    const prompt = composePromptFromState({
       state,
       // make sure it fits, we can pad the tokens a bit
       // Get the model's tokenizer based on the current model being used
@@ -213,7 +201,7 @@ ${currentSummary.trim()}
         });
         await fs.promises.writeFile(summaryFilename, currentSummary, "utf8");
         console.log("File written successfully");
-        await runtime.getDatabaseAdapter().setCache(summaryFilename, currentSummary);
+        await runtime.setCache(summaryFilename, currentSummary);
         console.log("Cache set operation completed");
         await callback(
           {
@@ -297,14 +285,14 @@ ${currentSummary.trim()}
     ]
   ]
 };
-var chatWithAttachments_default = summarizeAction;
+var chatWithAttachments_default = chatWithAttachments;
 
 // src/actions/downloadMedia.ts
 import {
-  composePrompt as composePrompt2,
   ModelTypes as ModelTypes2,
-  parseJSONObjectFromText as parseJSONObjectFromText2,
-  ServiceTypes
+  ServiceTypes,
+  composePromptFromState as composePromptFromState2,
+  parseJSONObjectFromText as parseJSONObjectFromText2
 } from "@elizaos/core";
 var mediaUrlTemplate = `# Messages we are searching for a media URL
 {{recentMessages}}
@@ -320,7 +308,7 @@ Your response must be formatted as a JSON block with this structure:
 \`\`\`
 `;
 var getMediaUrl = async (runtime, _message, state) => {
-  const prompt = composePrompt2({
+  const prompt = composePromptFromState2({
     state,
     template: mediaUrlTemplate
   });
@@ -335,7 +323,7 @@ var getMediaUrl = async (runtime, _message, state) => {
   }
   return null;
 };
-var downloadMedia_default = {
+var downloadMedia = {
   name: "DOWNLOAD_MEDIA",
   similes: [
     "DOWNLOAD_VIDEO",
@@ -453,15 +441,15 @@ var downloadMedia_default = {
 };
 
 // src/actions/summarizeConversation.ts
+import fs2 from "node:fs";
 import {
-  composePrompt as composePrompt3,
-  getEntityDetails,
   ModelTypes as ModelTypes3,
+  composePromptFromState as composePromptFromState3,
+  getEntityDetails,
   parseJSONObjectFromText as parseJSONObjectFromText3,
   splitChunks,
   trimTokens as trimTokens2
 } from "@elizaos/core";
-import * as fs2 from "node:fs";
 var summarizationTemplate2 = `# Summarized so far (we are adding to this)
 {{currentSummary}}
 
@@ -490,7 +478,7 @@ Your response must be formatted as a JSON block with this structure:
 \`\`\`
 `;
 var getDateRange = async (runtime, _message, state) => {
-  const prompt = composePrompt3({
+  const prompt = composePromptFromState3({
     state,
     template: dateRangeTemplate
   });
@@ -533,7 +521,7 @@ var getDateRange = async (runtime, _message, state) => {
     }
   }
 };
-var summarizeAction2 = {
+var summarize = {
   name: "SUMMARIZE_CONVERSATION",
   similes: [
     "RECAP",
@@ -656,7 +644,7 @@ ${attachments}`;
         chunkSize + 500,
         runtime
       );
-      const prompt = composePrompt3({
+      const prompt = composePromptFromState3({
         state,
         // make sure it fits, we can pad the tokens a bit
         template
@@ -695,7 +683,7 @@ ${currentSummary.trim()}
     } else if (currentSummary.trim()) {
       const summaryDir = "cache";
       const summaryFilename = `${summaryDir}/conversation_summary_${Date.now()}`;
-      await runtime.getDatabaseAdapter().setCache(summaryFilename, currentSummary);
+      await runtime.setCache(summaryFilename, currentSummary);
       await fs2.promises.mkdir(summaryDir, { recursive: true });
       await fs2.promises.writeFile(summaryFilename, currentSummary, "utf8");
       await callback(
@@ -781,12 +769,11 @@ ${currentSummary.trim()}
     ]
   ]
 };
-var summarizeConversation_default = summarizeAction2;
 
 // src/actions/transcribeMedia.ts
 import {
-  composePrompt as composePrompt4,
   ModelTypes as ModelTypes4,
+  composePromptFromState as composePromptFromState4,
   parseJSONObjectFromText as parseJSONObjectFromText4
 } from "@elizaos/core";
 var mediaAttachmentIdTemplate = `# Messages we are transcribing
@@ -803,7 +790,7 @@ Your response must be formatted as a JSON block with this structure:
 \`\`\`
 `;
 var getMediaAttachmentId = async (runtime, _message, state) => {
-  const prompt = composePrompt4({
+  const prompt = composePromptFromState4({
     state,
     template: mediaAttachmentIdTemplate
   });
@@ -819,7 +806,7 @@ var getMediaAttachmentId = async (runtime, _message, state) => {
   }
   return null;
 };
-var transcribeMediaAction = {
+var transcribeMedia = {
   name: "TRANSCRIBE_MEDIA",
   similes: [
     "TRANSCRIBE_AUDIO",
@@ -913,7 +900,7 @@ ${mediaTranscript.trim()}
       await callback(callbackData);
     } else if (callbackData.text) {
       const transcriptFilename = `content/transcript_${Date.now()}`;
-      await runtime.getDatabaseAdapter().setCache(transcriptFilename, callbackData.text);
+      await runtime.setCache(transcriptFilename, callbackData.text);
       await callback(
         {
           ...callbackData,
@@ -959,15 +946,14 @@ ${mediaTranscript.trim()}
     ]
   ]
 };
-var transcribeMedia_default = transcribeMediaAction;
 
 // src/actions/voiceJoin.ts
 import {
   ChannelType as ChannelType2,
-  composePrompt as composePrompt5,
+  ModelTypes as ModelTypes5,
+  composePromptFromState as composePromptFromState5,
   createUniqueUuid as createUniqueUuid2,
-  logger,
-  ModelTypes as ModelTypes5
+  logger
 } from "@elizaos/core";
 import {
   ChannelType as DiscordChannelType
@@ -979,7 +965,7 @@ var ServiceTypes2 = {
 };
 
 // src/actions/voiceJoin.ts
-var voiceJoin_default = {
+var joinVoice = {
   name: "JOIN_VOICE",
   similes: [
     "JOIN_VOICE",
@@ -993,7 +979,7 @@ var voiceJoin_default = {
     if (message.content.source !== "discord") {
       return false;
     }
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = state.data.room ?? await runtime.getRoom(message.roomId);
     if (room?.type !== ChannelType2.GROUP) {
       return false;
     }
@@ -1006,7 +992,7 @@ var voiceJoin_default = {
   },
   description: "Join a voice channel to participate in voice chat.",
   handler: async (runtime, message, state, _options, callback) => {
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = state.data.room ?? await runtime.getRoom(message.roomId);
     if (!room) {
       throw new Error("No room found");
     }
@@ -1090,7 +1076,7 @@ You should only respond with the name of the voice channel or none, no commentar
       userMessage: message.content.text,
       voiceChannels: voiceChannels.map((channel) => channel.name).join("\n")
     };
-    const prompt = composePrompt5({
+    const prompt = composePromptFromState5({
       template: messageTemplate,
       state: guessState
     });
@@ -1272,7 +1258,7 @@ import {
   logger as logger2
 } from "@elizaos/core";
 import { BaseGuildVoiceChannel } from "discord.js";
-var voiceLeave_default = {
+var leaveVoice = {
   name: "LEAVE_VOICE",
   similes: [
     "LEAVE_VOICE",
@@ -1291,7 +1277,7 @@ var voiceLeave_default = {
       logger2.error("Discord client not found");
       return false;
     }
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = state.data.room ?? await runtime.getRoom(message.roomId);
     if (room?.type !== ChannelType3.GROUP) {
       return false;
     }
@@ -1300,7 +1286,7 @@ var voiceLeave_default = {
   },
   description: "Leave the current voice channel.",
   handler: async (runtime, message, _state, _options) => {
-    const room = await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = await runtime.getRoom(message.roomId);
     if (!room) {
       throw new Error("No room found");
     }
@@ -1519,6 +1505,187 @@ var voiceLeave_default = {
   ]
 };
 
+// src/providers/channelState.ts
+import { ChannelType as ChannelType4 } from "@elizaos/core";
+var channelStateProvider = {
+  name: "channelState",
+  get: async (runtime, message, state) => {
+    const room = state.data?.room ?? await runtime.getRoom(message.roomId);
+    if (!room) {
+      throw new Error("No room found");
+    }
+    if (message.content.source !== "discord") {
+      return {
+        data: null,
+        values: {},
+        text: ""
+      };
+    }
+    const agentName = state?.agentName || "The agent";
+    const senderName = state?.senderName || "someone";
+    let responseText = "";
+    let channelType = "";
+    let serverName = "";
+    let channelId = "";
+    const serverId = room.serverId;
+    if (room.type === ChannelType4.DM) {
+      channelType = "DM";
+      responseText = `${agentName} is currently in a direct message conversation with ${senderName}. ${agentName} should engage in conversation, should respond to messages that are addressed to them and only ignore messages that seem to not require a response.`;
+    } else {
+      channelType = "GROUP";
+      if (!serverId) {
+        console.error("No server ID found");
+        return {
+          data: {
+            room,
+            channelType
+          },
+          values: {
+            channelType
+          },
+          text: ""
+        };
+      }
+      channelId = room.channelId;
+      const discordService = runtime.getService(
+        ServiceTypes2.DISCORD
+      );
+      if (!discordService) {
+        console.warn("No discord client found");
+        return {
+          data: {
+            room,
+            channelType,
+            serverId
+          },
+          values: {
+            channelType,
+            serverId
+          },
+          text: ""
+        };
+      }
+      const guild = discordService.client.guilds.cache.get(serverId);
+      serverName = guild.name;
+      responseText = `${agentName} is currently having a conversation in the channel \`@${channelId} in the server \`${serverName}\` (@${serverId})`;
+      responseText += `
+${agentName} is in a room with other users and should be self-conscious and only participate when directly addressed or when the conversation is relevant to them.`;
+    }
+    return {
+      data: {
+        room,
+        channelType,
+        serverId,
+        serverName,
+        channelId
+      },
+      values: {
+        channelType,
+        serverName,
+        channelId
+      },
+      text: responseText
+    };
+  }
+};
+
+// src/providers/voiceState.ts
+import { getVoiceConnection } from "@discordjs/voice";
+import { ChannelType as ChannelType5 } from "@elizaos/core";
+var voiceStateProvider = {
+  name: "voiceState",
+  get: async (runtime, message, state) => {
+    const room = await runtime.getRoom(message.roomId);
+    if (!room) {
+      throw new Error("No room found");
+    }
+    if (room.type !== ChannelType5.GROUP) {
+      return {
+        data: {
+          isInVoiceChannel: false,
+          room
+        },
+        values: {
+          isInVoiceChannel: "false",
+          roomType: room.type
+        },
+        text: ""
+      };
+    }
+    const serverId = room.serverId;
+    if (!serverId) {
+      throw new Error("No server ID found 10");
+    }
+    const connection = getVoiceConnection(serverId);
+    const agentName = state?.agentName || "The agent";
+    if (!connection) {
+      return {
+        data: {
+          isInVoiceChannel: false,
+          room,
+          serverId
+        },
+        values: {
+          isInVoiceChannel: "false",
+          serverId
+        },
+        text: `${agentName} is not currently in a voice channel`
+      };
+    }
+    const worldId = room.worldId;
+    const world = await runtime.getWorld(worldId);
+    if (!world) {
+      throw new Error("No world found");
+    }
+    const worldName = world.name;
+    const roomType = room.type;
+    const channelId = room.channelId;
+    const channelName = room.name;
+    if (!channelId) {
+      return {
+        data: {
+          isInVoiceChannel: true,
+          room,
+          serverId,
+          world,
+          connection
+        },
+        values: {
+          isInVoiceChannel: "true",
+          serverId,
+          worldName,
+          roomType
+        },
+        text: `${agentName} is in an invalid voice channel`
+      };
+    }
+    return {
+      data: {
+        isInVoiceChannel: true,
+        room,
+        serverId,
+        world,
+        connection,
+        channelId,
+        channelName
+      },
+      values: {
+        isInVoiceChannel: "true",
+        serverId,
+        worldName,
+        roomType,
+        channelId,
+        channelName
+      },
+      text: `${agentName} is currently in the voice channel: ${channelName} (ID: ${channelId})`
+    };
+  }
+};
+
+// src/service.ts
+import { ChannelType as ChannelType9, EventTypes as EventTypes2, Role, Service, createUniqueUuid as createUniqueUuid6, logger as logger6 } from "@elizaos/core";
+import { ChannelType as DiscordChannelType4, Client as DiscordJsClient, Events, GatewayIntentBits, Partials, PermissionsBitField as PermissionsBitField2 } from "discord.js";
+
 // src/constants.ts
 var MESSAGE_CONSTANTS = {
   MAX_MESSAGES: 10,
@@ -1535,16 +1702,18 @@ var DISCORD_SERVICE_NAME = "discord";
 
 // src/messages.ts
 import {
-  ChannelType as ChannelType5,
+  ChannelType as ChannelType7,
+  EventTypes,
+  ServiceTypes as ServiceTypes4,
   createUniqueUuid as createUniqueUuid4,
-  logger as logger4,
-  ServiceTypes as ServiceTypes4
+  logger as logger4
 } from "@elizaos/core";
 import {
   ChannelType as DiscordChannelType2
 } from "discord.js";
 
 // src/attachments.ts
+import fs3 from "node:fs";
 import { trimTokens as trimTokens3 } from "@elizaos/core";
 import { parseJSONObjectFromText as parseJSONObjectFromText5 } from "@elizaos/core";
 import {
@@ -1553,7 +1722,6 @@ import {
 } from "@elizaos/core";
 import { Collection } from "discord.js";
 import ffmpeg from "fluent-ffmpeg";
-import fs3 from "node:fs";
 async function generateSummary(runtime, text) {
   text = await trimTokens3(text, 1e5, runtime);
   const prompt = `Please generate a concise summary for the following text:
@@ -1587,9 +1755,19 @@ async function generateSummary(runtime, text) {
 var AttachmentManager = class {
   attachmentCache = /* @__PURE__ */ new Map();
   runtime;
+  /**
+   * Constructor for creating a new instance of the class.
+   *
+   * @param {IAgentRuntime} runtime The runtime object to be injected into the instance.
+   */
   constructor(runtime) {
     this.runtime = runtime;
   }
+  /**
+   * Processes attachments and returns an array of Media objects.
+   * @param {Collection<string, Attachment> | Attachment[]} attachments - The attachments to be processed
+   * @returns {Promise<Media[]>} - An array of processed Media objects
+   */
   async processAttachments(attachments) {
     const processedAttachments = [];
     const attachmentCollection = attachments instanceof Collection ? attachments : new Collection(attachments.map((att) => [att.id, att]));
@@ -1601,6 +1779,15 @@ var AttachmentManager = class {
     }
     return processedAttachments;
   }
+  /**
+   * Processes the provided attachment to generate a media object.
+   * If the media for the attachment URL is already cached, it will return the cached media.
+   * Otherwise, it will determine the type of attachment (PDF, text, audio, video, image, generic)
+   * and call the corresponding processing method to generate the media object.
+   *
+   * @param attachment The attachment to process
+   * @returns A promise that resolves to a Media object representing the attachment, or null if the attachment could not be processed
+   */
   async processAttachment(attachment) {
     if (this.attachmentCache.has(attachment.url)) {
       return this.attachmentCache.get(attachment.url);
@@ -1624,6 +1811,11 @@ var AttachmentManager = class {
     }
     return media;
   }
+  /**
+   * Asynchronously processes an audio or video attachment provided as input and returns a Media object.
+   * @param {Attachment} attachment - The attachment object containing information about the audio/video file.
+   * @returns {Promise<Media>} A Promise that resolves to a Media object representing the processed audio/video attachment.
+   */
   async processAudioVideoAttachment(attachment) {
     try {
       const response = await fetch(attachment.url);
@@ -1666,6 +1858,12 @@ var AttachmentManager = class {
       };
     }
   }
+  /**
+   * Extracts the audio stream from the provided MP4 data and converts it to MP3 format.
+   *
+   * @param {ArrayBuffer} mp4Data - The MP4 data to extract audio from
+   * @returns {Promise<Buffer>} - A Promise that resolves with the converted audio data as a Buffer
+   */
   async extractAudioFromMP4(mp4Data) {
     const tempMP4File = `temp_${Date.now()}.mp4`;
     const tempAudioFile = `temp_${Date.now()}.mp3`;
@@ -1689,6 +1887,17 @@ var AttachmentManager = class {
       }
     }
   }
+  /**
+   * Processes a PDF attachment by fetching the PDF file from the specified URL,
+   * converting it to text, generating a summary, and returning a Media object
+   * with the extracted information.
+   * If an error occurs during processing, a placeholder Media object is returned
+   * with an error message.
+   *
+   * @param {Attachment} attachment - The PDF attachment to process.
+   * @returns {Promise<Media>} A promise that resolves to a Media object representing
+   * the processed PDF attachment.
+   */
   async processPdfAttachment(attachment) {
     try {
       const response = await fetch(attachment.url);
@@ -1715,6 +1924,11 @@ var AttachmentManager = class {
       };
     }
   }
+  /**
+   * Processes a plaintext attachment by fetching its content, generating a summary, and returning a Media object.
+   * @param {Attachment} attachment - The attachment object to process.
+   * @returns {Promise<Media>} A promise that resolves to a Media object representing the processed plaintext attachment.
+   */
   async processPlaintextAttachment(attachment) {
     try {
       const response = await fetch(attachment.url);
@@ -1740,6 +1954,14 @@ var AttachmentManager = class {
       };
     }
   }
+  /**
+   * Process the image attachment by fetching description and title using the IMAGE_DESCRIPTION model.
+   * If successful, returns a Media object populated with the details. If unsuccessful, creates a fallback
+   * Media object and logs the error.
+   *
+   * @param {Attachment} attachment - The attachment object containing the image details.
+   * @returns {Promise<Media>} A promise that resolves to a Media object.
+   */
   async processImageAttachment(attachment) {
     try {
       const { description, title } = await this.runtime.useModel(
@@ -1759,6 +1981,12 @@ var AttachmentManager = class {
       return this.createFallbackImageMedia(attachment);
     }
   }
+  /**
+   * Creates a fallback Media object for image attachments that could not be recognized.
+   *
+   * @param {Attachment} attachment - The attachment object containing image details.
+   * @returns {Media} - The fallback Media object with basic information about the image attachment.
+   */
   createFallbackImageMedia(attachment) {
     return {
       id: attachment.id,
@@ -1769,6 +1997,12 @@ var AttachmentManager = class {
       text: `This is an image attachment. File name: ${attachment.name}, Size: ${attachment.size} bytes, Content type: ${attachment.contentType}`
     };
   }
+  /**
+   * Process a video attachment to extract video information.
+   * @param {Attachment} attachment - The attachment object containing video information.
+   * @returns {Promise<Media>} A promise that resolves to a Media object with video details.
+   * @throws {Error} If video service is not available.
+   */
   async processVideoAttachment(attachment) {
     const videoService = this.runtime.getService(
       ServiceTypes3.VIDEO
@@ -1799,6 +2033,11 @@ var AttachmentManager = class {
       text: "Video content not available"
     };
   }
+  /**
+   * Process a generic attachment and return a Media object with specified properties.
+   * @param {Attachment} attachment - The attachment object to process.
+   * @returns {Promise<Media>} A Promise that resolves to a Media object with specified properties.
+   */
   async processGenericAttachment(attachment) {
     return {
       id: attachment.id,
@@ -1815,11 +2054,11 @@ var AttachmentManager = class {
 import {
   ModelTypes as ModelTypes7,
   logger as logger3,
-  trimTokens as trimTokens4,
-  parseJSONObjectFromText as parseJSONObjectFromText6
+  parseJSONObjectFromText as parseJSONObjectFromText6,
+  trimTokens as trimTokens4
 } from "@elizaos/core";
 import {
-  ChannelType as ChannelType4,
+  ChannelType as ChannelType6,
   PermissionsBitField,
   ThreadChannel
 } from "discord.js";
@@ -1896,7 +2135,7 @@ function canSendMessage(channel) {
       reason: "No channel given"
     };
   }
-  if (channel.type === ChannelType4.DM) {
+  if (channel.type === ChannelType6.DM) {
     return {
       canSend: true,
       reason: null
@@ -1940,12 +2179,21 @@ var MessageManager = class {
   runtime;
   attachmentManager;
   getChannelType;
+  /**
+   * Constructor for a new instance of MyClass.
+   * @param {any} discordClient - The Discord client object.
+   */
   constructor(discordClient) {
     this.client = discordClient.client;
     this.runtime = discordClient.runtime;
     this.attachmentManager = new AttachmentManager(this.runtime);
     this.getChannelType = discordClient.getChannelType;
   }
+  /**
+   * Handles incoming Discord messages and processes them accordingly.
+   *
+   * @param {DiscordMessage} message - The Discord message to be handled
+   */
   async handleMessage(message) {
     if (this.runtime.character.settings?.discord?.allowedChannelIds && !this.runtime.character.settings.discord.allowedChannelIds.some(
       (id) => id === message.channel.id
@@ -1973,7 +2221,7 @@ var MessageManager = class {
       type = await this.getChannelType(message.channel);
       serverId = guild.id;
     } else {
-      type = ChannelType5.DM;
+      type = ChannelType7.DM;
       serverId = void 0;
     }
     await this.runtime.ensureConnection({
@@ -2062,7 +2310,7 @@ var MessageManager = class {
           return [];
         }
       };
-      this.runtime.emitEvent(["DISCORD_MESSAGE_RECEIVED", "MESSAGE_RECEIVED"], {
+      this.runtime.emitEvent(["DISCORD_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, EventTypes.MESSAGE_RECEIVED], {
         runtime: this.runtime,
         message: newMessage,
         callback
@@ -2071,6 +2319,13 @@ var MessageManager = class {
       console.error("Error handling message:", error);
     }
   }
+  /**
+   * Processes the message content, mentions, code blocks, attachments, and URLs to generate
+   * processed content and media attachments.
+   *
+   * @param {DiscordMessage} message The message to process
+   * @returns {Promise<{ processedContent: string; attachments: Media[] }>} Processed content and media attachments
+   */
   async processMessage(message) {
     let processedContent = message.content;
     let attachments = [];
@@ -2152,6 +2407,13 @@ var MessageManager = class {
     }
     return { processedContent, attachments };
   }
+  /**
+   * Asynchronously fetches the bot's username and discriminator from Discord API.
+   *
+   * @param {string} botToken The token of the bot to authenticate the request
+   * @returns {Promise<string>} A promise that resolves with the bot's username and discriminator
+   * @throws {Error} If there is an error while fetching the bot details
+   */
   async fetchBotName(botToken) {
     const url = "https://discord.com/api/v10/users/@me";
     const response = await fetch(url, {
@@ -2169,526 +2431,103 @@ var MessageManager = class {
   }
 };
 
-// src/providers/channelState.ts
-import { ChannelType as ChannelType6 } from "@elizaos/core";
-var channelStateProvider = {
-  name: "channelState",
-  get: async (runtime, message, state) => {
-    const room = state.data?.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
-    if (!room) {
-      throw new Error("No room found");
-    }
-    if (message.content.source !== "discord") {
-      return {
-        data: null,
-        values: {},
-        text: ""
-      };
-    }
-    const agentName = state?.agentName || "The agent";
-    const senderName = state?.senderName || "someone";
-    let responseText = "";
-    let channelType = "";
-    let serverName = "";
-    let channelId = "";
-    const serverId = room.serverId;
-    if (room.type === ChannelType6.DM) {
-      channelType = "DM";
-      responseText = `${agentName} is currently in a direct message conversation with ${senderName}. ${agentName} should engage in conversation, should respond to messages that are addressed to them and only ignore messages that seem to not require a response.`;
-    } else {
-      channelType = "GROUP";
-      if (!serverId) {
-        console.error("No server ID found");
-        return {
-          data: {
-            room,
-            channelType
-          },
-          values: {
-            channelType
-          },
-          text: ""
-        };
-      }
-      channelId = room.channelId;
-      const discordService = runtime.getService(
-        ServiceTypes2.DISCORD
-      );
-      if (!discordService) {
-        console.warn("No discord client found");
-        return {
-          data: {
-            room,
-            channelType,
-            serverId
-          },
-          values: {
-            channelType,
-            serverId
-          },
-          text: ""
-        };
-      }
-      const guild = discordService.client.guilds.cache.get(serverId);
-      serverName = guild.name;
-      responseText = `${agentName} is currently having a conversation in the channel \`@${channelId} in the server \`${serverName}\` (@${serverId})`;
-      responseText += `
-${agentName} is in a room with other users and should be self-conscious and only participate when directly addressed or when the conversation is relevant to them.`;
-    }
-    return {
-      data: {
-        room,
-        channelType,
-        serverId,
-        serverName,
-        channelId
-      },
-      values: {
-        channelType,
-        serverName,
-        channelId
-      },
-      text: responseText
-    };
-  }
-};
-var channelState_default = channelStateProvider;
-
-// src/providers/voiceState.ts
-import { getVoiceConnection } from "@discordjs/voice";
-import { ChannelType as ChannelType7 } from "@elizaos/core";
-var voiceStateProvider = {
-  name: "voiceState",
-  get: async (runtime, message, state) => {
-    const room = await runtime.getDatabaseAdapter().getRoom(message.roomId);
-    if (!room) {
-      throw new Error("No room found");
-    }
-    if (room.type !== ChannelType7.GROUP) {
-      return {
-        data: {
-          isInVoiceChannel: false,
-          room
-        },
-        values: {
-          isInVoiceChannel: "false",
-          roomType: room.type
-        },
-        text: ""
-      };
-    }
-    const serverId = room.serverId;
-    if (!serverId) {
-      throw new Error("No server ID found 10");
-    }
-    const connection = getVoiceConnection(serverId);
-    const agentName = state?.agentName || "The agent";
-    if (!connection) {
-      return {
-        data: {
-          isInVoiceChannel: false,
-          room,
-          serverId
-        },
-        values: {
-          isInVoiceChannel: "false",
-          serverId
-        },
-        text: `${agentName} is not currently in a voice channel`
-      };
-    }
-    const worldId = room.worldId;
-    const world = await runtime.getDatabaseAdapter().getWorld(worldId);
-    if (!world) {
-      throw new Error("No world found");
-    }
-    const worldName = world.name;
-    const roomType = room.type;
-    const channelId = room.channelId;
-    const channelName = room.name;
-    if (!channelId) {
-      return {
-        data: {
-          isInVoiceChannel: true,
-          room,
-          serverId,
-          world,
-          connection
-        },
-        values: {
-          isInVoiceChannel: "true",
-          serverId,
-          worldName,
-          roomType
-        },
-        text: `${agentName} is in an invalid voice channel`
-      };
-    }
-    return {
-      data: {
-        isInVoiceChannel: true,
-        room,
-        serverId,
-        world,
-        connection,
-        channelId,
-        channelName
-      },
-      values: {
-        isInVoiceChannel: "true",
-        serverId,
-        worldName,
-        roomType,
-        channelId,
-        channelName
-      },
-      text: `${agentName} is currently in the voice channel: ${channelName} (ID: ${channelId})`
-    };
-  }
-};
-var voiceState_default = voiceStateProvider;
-
-// src/tests.ts
+// src/voice.ts
+import { EventEmitter } from "node:events";
+import { pipeline } from "node:stream";
 import {
-  AudioPlayerStatus,
   NoSubscriberBehavior,
+  StreamType,
   VoiceConnectionStatus,
   createAudioPlayer,
   createAudioResource,
-  entersState
+  entersState,
+  getVoiceConnections,
+  joinVoiceChannel
 } from "@discordjs/voice";
 import {
+  ChannelType as ChannelType8,
   ModelTypes as ModelTypes8,
+  createUniqueUuid as createUniqueUuid5,
   logger as logger5
 } from "@elizaos/core";
-import { ChannelType as ChannelType8, Events } from "discord.js";
-var TEST_IMAGE_URL = "https://github.com/elizaOS/awesome-eliza/blob/main/assets/eliza-logo.jpg?raw=true";
-var DiscordTestSuite = class {
-  name = "discord";
-  discordClient = null;
-  tests;
-  constructor() {
-    this.tests = [
-      {
-        name: "Initialize Discord Client",
-        fn: this.testCreatingDiscordClient.bind(this)
-      },
-      {
-        name: "Slash Commands - Join Voice",
-        fn: this.testJoinVoiceSlashCommand.bind(this)
-      },
-      {
-        name: "Voice Playback & TTS",
-        fn: this.testTextToSpeechPlayback.bind(this)
-      },
-      {
-        name: "Send Message with Attachments",
-        fn: this.testSendingTextMessage.bind(this)
-      },
-      {
-        name: "Handle Incoming Messages",
-        fn: this.testHandlingMessage.bind(this)
-      },
-      {
-        name: "Slash Commands - Leave Voice",
-        fn: this.testLeaveVoiceSlashCommand.bind(this)
+import {
+  ChannelType as DiscordChannelType3
+} from "discord.js";
+import prism from "prism-media";
+var DECODE_FRAME_SIZE = 1024;
+var DECODE_SAMPLE_RATE = 16e3;
+var AudioMonitor = class {
+  readable;
+  buffers = [];
+  maxSize;
+  lastFlagged = -1;
+  ended = false;
+  /**
+   * Constructs an AudioMonitor instance.
+   * @param {Readable} readable - The readable stream to monitor for audio data.
+   * @param {number} maxSize - The maximum size of the audio buffer.
+   * @param {function} onStart - The callback function to be called when audio starts.
+   * @param {function} callback - The callback function to process audio data.
+   */
+  constructor(readable, maxSize, onStart, callback) {
+    this.readable = readable;
+    this.maxSize = maxSize;
+    this.readable.on("data", (chunk) => {
+      if (this.lastFlagged < 0) {
+        this.lastFlagged = this.buffers.length;
       }
-    ];
-  }
-  async testCreatingDiscordClient(runtime) {
-    try {
-      this.discordClient = runtime.getService(
-        ServiceTypes2.DISCORD
+      this.buffers.push(chunk);
+      const currentSize = this.buffers.reduce(
+        (acc, cur) => acc + cur.length,
+        0
       );
-      if (this.discordClient.client.isReady()) {
-        logger5.success("DiscordService is already ready.");
-      } else {
-        logger5.info("Waiting for DiscordService to be ready...");
-        await new Promise((resolve, reject) => {
-          this.discordClient.client.once(Events.ClientReady, resolve);
-          this.discordClient.client.once(Events.Error, reject);
-        });
+      while (currentSize > this.maxSize) {
+        this.buffers.shift();
+        this.lastFlagged--;
       }
-    } catch (error) {
-      throw new Error(`Error in test creating Discord client: ${error}`);
-    }
+    });
+    this.readable.on("end", () => {
+      logger5.log("AudioMonitor ended");
+      this.ended = true;
+      if (this.lastFlagged < 0) return;
+      callback(this.getBufferFromStart());
+      this.lastFlagged = -1;
+    });
+    this.readable.on("speakingStopped", () => {
+      if (this.ended) return;
+      logger5.log("Speaking stopped");
+      if (this.lastFlagged < 0) return;
+      callback(this.getBufferFromStart());
+    });
+    this.readable.on("speakingStarted", () => {
+      if (this.ended) return;
+      onStart();
+      logger5.log("Speaking started");
+      this.reset();
+    });
   }
-  async testJoinVoiceSlashCommand(runtime) {
-    try {
-      await this.waitForVoiceManagerReady(this.discordClient);
-      const channel = await this.getTestChannel(runtime);
-      if (!channel || !channel.isTextBased()) {
-        throw new Error("Invalid test channel for slash command test.");
-      }
-      const fakeJoinInteraction = {
-        isCommand: () => true,
-        commandName: "joinchannel",
-        options: {
-          get: (name) => name === "channel" ? { value: channel.id } : null
-        },
-        guild: channel.guild,
-        deferReply: async () => {
-        },
-        editReply: async (message) => {
-          logger5.info(`JoinChannel Slash Command Response: ${message}`);
-        }
-      };
-      await this.discordClient.voiceManager.handleJoinChannelCommand(
-        fakeJoinInteraction
-      );
-      logger5.success("Slash command test completed successfully.");
-    } catch (error) {
-      throw new Error(`Error in slash commands test: ${error}`);
-    }
-  }
-  async testLeaveVoiceSlashCommand(runtime) {
-    try {
-      await this.waitForVoiceManagerReady(this.discordClient);
-      const channel = await this.getTestChannel(runtime);
-      if (!channel || !channel.isTextBased()) {
-        throw new Error("Invalid test channel for slash command test.");
-      }
-      const fakeLeaveInteraction = {
-        isCommand: () => true,
-        commandName: "leavechannel",
-        guildId: channel.guildId,
-        reply: async (message) => {
-          logger5.info(`LeaveChannel Slash Command Response: ${message}`);
-        }
-      };
-      await this.discordClient.voiceManager.handleLeaveChannelCommand(
-        fakeLeaveInteraction
-      );
-      logger5.success("Slash command test completed successfully.");
-    } catch (error) {
-      throw new Error(`Error in slash commands test: ${error}`);
-    }
-  }
-  async testTextToSpeechPlayback(runtime) {
-    try {
-      await this.waitForVoiceManagerReady(this.discordClient);
-      const channel = await this.getTestChannel(runtime);
-      if (!channel || channel.type !== ChannelType8.GuildVoice) {
-        throw new Error("Invalid voice channel.");
-      }
-      await this.discordClient.voiceManager.joinChannel(channel);
-      const guild = await this.getActiveGuild(this.discordClient);
-      const guildId = guild.id;
-      const connection = this.discordClient.voiceManager.getVoiceConnection(guildId);
-      try {
-        await entersState(connection, VoiceConnectionStatus.Ready, 1e4);
-        logger5.success(`Voice connection is ready in guild: ${guildId}`);
-      } catch (error) {
-        throw new Error(`Voice connection failed to become ready: ${error}`);
-      }
-      let responseStream = null;
-      try {
-        responseStream = await runtime.useModel(
-          ModelTypes8.TEXT_TO_SPEECH,
-          `Hi! I'm ${runtime.character.name}! How are you doing today?`
-        );
-      } catch (_error) {
-        throw new Error("No text to speech service found");
-      }
-      if (!responseStream) {
-        throw new Error("TTS response stream is null or undefined.");
-      }
-      await this.playAudioStream(responseStream, connection);
-    } catch (error) {
-      throw new Error(`Error in TTS playback test: ${error}`);
-    }
-  }
-  async testSendingTextMessage(runtime) {
-    try {
-      const channel = await this.getTestChannel(runtime);
-      await this.sendMessageToChannel(
-        channel,
-        "Testing Message",
-        [TEST_IMAGE_URL]
-      );
-    } catch (error) {
-      throw new Error(`Error in sending text message: ${error}`);
-    }
-  }
-  async testHandlingMessage(runtime) {
-    try {
-      const channel = await this.getTestChannel(runtime);
-      const fakeMessage = {
-        content: `Hello, ${runtime.character.name}! How are you?`,
-        author: {
-          id: "mock-user-id",
-          username: "MockUser",
-          bot: false
-        },
-        channel,
-        id: "mock-message-id",
-        createdTimestamp: Date.now(),
-        mentions: {
-          has: () => false
-        },
-        reference: null,
-        attachments: []
-      };
-      await this.discordClient.messageManager.handleMessage(fakeMessage);
-    } catch (error) {
-      throw new Error(`Error in sending text message: ${error}`);
-    }
-  }
-  // #############################
-  //     Utility Functions
-  // #############################
-  async getTestChannel(runtime) {
-    const channelId = this.validateChannelId(runtime);
-    const channel = await this.discordClient.client.channels.fetch(channelId);
-    if (!channel) throw new Error("no test channel found!");
-    return channel;
-  }
-  async sendMessageToChannel(channel, messageContent, files) {
-    try {
-      if (!channel || !channel.isTextBased()) {
-        throw new Error(
-          "Channel is not a text-based channel or does not exist."
-        );
-      }
-      await sendMessageInChunks(
-        channel,
-        messageContent,
-        null,
-        files
-      );
-    } catch (error) {
-      throw new Error(`Error sending message: ${error}`);
-    }
-  }
-  async playAudioStream(responseStream, connection) {
-    const audioPlayer = createAudioPlayer({
-      behaviors: {
-        noSubscriber: NoSubscriberBehavior.Pause
-      }
-    });
-    const audioResource = createAudioResource(responseStream);
-    audioPlayer.play(audioResource);
-    connection.subscribe(audioPlayer);
-    logger5.success("TTS playback started successfully.");
-    await new Promise((resolve, reject) => {
-      audioPlayer.once(AudioPlayerStatus.Idle, () => {
-        logger5.info("TTS playback finished.");
-        resolve();
-      });
-      audioPlayer.once("error", (error) => {
-        reject(error);
-        throw new Error(`TTS playback error: ${error}`);
-      });
-    });
-  }
-  async getActiveGuild(discordClient) {
-    const guilds = await discordClient.client.guilds.fetch();
-    const fullGuilds = await Promise.all(guilds.map((guild) => guild.fetch()));
-    const activeGuild = fullGuilds.find((g) => g.members.me?.voice.channelId);
-    if (!activeGuild) {
-      throw new Error("No active voice connection found for the bot.");
-    }
-    return activeGuild;
-  }
-  async waitForVoiceManagerReady(discordClient) {
-    if (!discordClient) {
-      throw new Error("Discord client is not initialized.");
-    }
-    if (!discordClient.voiceManager.isReady()) {
-      await new Promise((resolve, reject) => {
-        discordClient.voiceManager.once("ready", resolve);
-        discordClient.voiceManager.once("error", reject);
-      });
-    }
-  }
-  validateChannelId(runtime) {
-    const testChannelId = runtime.getSetting("DISCORD_TEST_CHANNEL_ID") || process.env.DISCORD_TEST_CHANNEL_ID;
-    if (!testChannelId) {
-      throw new Error(
-        "DISCORD_TEST_CHANNEL_ID is not set. Please provide a valid channel ID in the environment variables."
-      );
-    }
-    return testChannelId;
-  }
-};
-
-// src/voice.ts
-import {
-  NoSubscriberBehavior as NoSubscriberBehavior2,
-  StreamType,
-  VoiceConnectionStatus as VoiceConnectionStatus2,
-  createAudioPlayer as createAudioPlayer2,
-  createAudioResource as createAudioResource2,
-  entersState as entersState2,
-  getVoiceConnections,
-  joinVoiceChannel
-} from "@discordjs/voice";
-import {
-  ChannelType as ChannelType9,
-  ModelTypes as ModelTypes9,
-  createUniqueUuid as createUniqueUuid5,
-  logger as logger6
-} from "@elizaos/core";
-import {
-  ChannelType as DiscordChannelType3
-} from "discord.js";
-import { EventEmitter } from "node:events";
-import { pipeline } from "node:stream";
-import prism from "prism-media";
-var DECODE_FRAME_SIZE = 1024;
-var DECODE_SAMPLE_RATE = 16e3;
-var AudioMonitor = class {
-  readable;
-  buffers = [];
-  maxSize;
-  lastFlagged = -1;
-  ended = false;
-  constructor(readable, maxSize, onStart, callback) {
-    this.readable = readable;
-    this.maxSize = maxSize;
-    this.readable.on("data", (chunk) => {
-      if (this.lastFlagged < 0) {
-        this.lastFlagged = this.buffers.length;
-      }
-      this.buffers.push(chunk);
-      const currentSize = this.buffers.reduce(
-        (acc, cur) => acc + cur.length,
-        0
-      );
-      while (currentSize > this.maxSize) {
-        this.buffers.shift();
-        this.lastFlagged--;
-      }
-    });
-    this.readable.on("end", () => {
-      logger6.log("AudioMonitor ended");
-      this.ended = true;
-      if (this.lastFlagged < 0) return;
-      callback(this.getBufferFromStart());
-      this.lastFlagged = -1;
-    });
-    this.readable.on("speakingStopped", () => {
-      if (this.ended) return;
-      logger6.log("Speaking stopped");
-      if (this.lastFlagged < 0) return;
-      callback(this.getBufferFromStart());
-    });
-    this.readable.on("speakingStarted", () => {
-      if (this.ended) return;
-      onStart();
-      logger6.log("Speaking started");
-      this.reset();
-    });
-  }
-  stop() {
-    this.readable.removeAllListeners("data");
-    this.readable.removeAllListeners("end");
-    this.readable.removeAllListeners("speakingStopped");
-    this.readable.removeAllListeners("speakingStarted");
+  /**
+   * Stops listening to "data", "end", "speakingStopped", and "speakingStarted" events on the readable stream.
+   */
+  stop() {
+    this.readable.removeAllListeners("data");
+    this.readable.removeAllListeners("end");
+    this.readable.removeAllListeners("speakingStopped");
+    this.readable.removeAllListeners("speakingStarted");
   }
+  /**
+   * Check if the item is flagged.
+   * @returns {boolean} True if the item was flagged, false otherwise.
+   */
   isFlagged() {
     return this.lastFlagged >= 0;
   }
+  /**
+   * Returns a Buffer containing all buffers starting from the last flagged index.
+   * If the last flagged index is less than 0, returns null.
+   *
+   * @returns {Buffer | null} The concatenated Buffer or null
+   */
   getBufferFromFlag() {
     if (this.lastFlagged < 0) {
       return null;
@@ -2696,14 +2535,26 @@ var AudioMonitor = class {
     const buffer = Buffer.concat(this.buffers.slice(this.lastFlagged));
     return buffer;
   }
+  /**
+   * Concatenates all buffers in the array and returns a single buffer.
+   *
+   * @returns {Buffer} The concatenated buffer from the start.
+   */
   getBufferFromStart() {
     const buffer = Buffer.concat(this.buffers);
     return buffer;
   }
+  /**
+   * Resets the buffers array and sets lastFlagged to -1.
+   */
   reset() {
     this.buffers = [];
     this.lastFlagged = -1;
   }
+  /**
+   * Check if the object has ended.
+   * @returns {boolean} Returns true if the object has ended; false otherwise.
+   */
   isEnded() {
     return this.ended;
   }
@@ -2719,6 +2570,12 @@ var VoiceManager = class extends EventEmitter {
   connections = /* @__PURE__ */ new Map();
   activeMonitors = /* @__PURE__ */ new Map();
   ready;
+  /**
+   * Constructor for initializing a new instance of the class.
+   *
+   * @param {DiscordService} service - The Discord service to use.
+   * @param {IAgentRuntime} runtime - The runtime for the agent.
+   */
   constructor(service, runtime) {
     super();
     this.client = service.client;
@@ -2727,21 +2584,41 @@ var VoiceManager = class extends EventEmitter {
       this.setReady(true);
     });
   }
+  /**
+   * Asynchronously retrieves the type of the channel.
+   * @param {Channel} channel - The channel to get the type for.
+   * @returns {Promise<ChannelType>} The type of the channel.
+   */
   async getChannelType(channel) {
     switch (channel.type) {
       case DiscordChannelType3.GuildVoice:
       case DiscordChannelType3.GuildStageVoice:
-        return ChannelType9.VOICE_GROUP;
+        return ChannelType8.VOICE_GROUP;
     }
   }
+  /**
+   * Set the ready status of the VoiceManager.
+   * @param {boolean} status - The status to set.
+   */
   setReady(status) {
     this.ready = status;
     this.emit("ready");
-    logger6.success(`VoiceManager is now ready: ${this.ready}`);
+    logger5.debug(`VoiceManager is now ready: ${this.ready}`);
   }
+  /**
+   * Check if the object is ready.
+   *
+   * @returns {boolean} True if the object is ready, false otherwise.
+   */
   isReady() {
     return this.ready;
   }
+  /**
+   * Handle voice state update event.
+   * @param {VoiceState} oldState - The old voice state of the member.
+   * @param {VoiceState} newState - The new voice state of the member.
+   * @returns {void}
+   */
   async handleVoiceStateUpdate(oldState, newState) {
     const oldChannelId = oldState.channelId;
     const newChannelId = newState.channelId;
@@ -2763,6 +2640,10 @@ var VoiceManager = class extends EventEmitter {
       );
     }
   }
+  /**
+   * Joins a voice channel and sets up the necessary connection and event listeners.
+   * @param {BaseGuildVoiceChannel} channel - The voice channel to join
+   */
   async joinChannel(channel) {
     const oldConnection = this.getVoiceConnection(channel.guildId);
     if (oldConnection) {
@@ -2784,38 +2665,38 @@ var VoiceManager = class extends EventEmitter {
     });
     try {
       await Promise.race([
-        entersState2(connection, VoiceConnectionStatus2.Ready, 2e4),
-        entersState2(connection, VoiceConnectionStatus2.Signalling, 2e4)
+        entersState(connection, VoiceConnectionStatus.Ready, 2e4),
+        entersState(connection, VoiceConnectionStatus.Signalling, 2e4)
       ]);
-      logger6.log(
+      logger5.log(
         `Voice connection established in state: ${connection.state.status}`
       );
       connection.on("stateChange", async (oldState, newState) => {
-        logger6.log(
+        logger5.log(
           `Voice connection state changed from ${oldState.status} to ${newState.status}`
         );
-        if (newState.status === VoiceConnectionStatus2.Disconnected) {
-          logger6.log("Handling disconnection...");
+        if (newState.status === VoiceConnectionStatus.Disconnected) {
+          logger5.log("Handling disconnection...");
           try {
             await Promise.race([
-              entersState2(connection, VoiceConnectionStatus2.Signalling, 5e3),
-              entersState2(connection, VoiceConnectionStatus2.Connecting, 5e3)
+              entersState(connection, VoiceConnectionStatus.Signalling, 5e3),
+              entersState(connection, VoiceConnectionStatus.Connecting, 5e3)
             ]);
-            logger6.log("Reconnecting to channel...");
+            logger5.log("Reconnecting to channel...");
           } catch (e) {
-            logger6.log(`Disconnection confirmed - cleaning up...${e}`);
+            logger5.log(`Disconnection confirmed - cleaning up...${e}`);
             connection.destroy();
             this.connections.delete(channel.id);
           }
-        } else if (newState.status === VoiceConnectionStatus2.Destroyed) {
+        } else if (newState.status === VoiceConnectionStatus.Destroyed) {
           this.connections.delete(channel.id);
-        } else if (!this.connections.has(channel.id) && (newState.status === VoiceConnectionStatus2.Ready || newState.status === VoiceConnectionStatus2.Signalling)) {
+        } else if (!this.connections.has(channel.id) && (newState.status === VoiceConnectionStatus.Ready || newState.status === VoiceConnectionStatus.Signalling)) {
           this.connections.set(channel.id, connection);
         }
       });
       connection.on("error", (error) => {
-        logger6.log("Voice connection error:", error);
-        logger6.log("Connection error - will attempt to recover...");
+        logger5.log("Voice connection error:", error);
+        logger5.log("Connection error - will attempt to recover...");
       });
       this.connections.set(channel.id, connection);
       const me = channel.guild.members.me;
@@ -2824,7 +2705,7 @@ var VoiceManager = class extends EventEmitter {
           await me.voice.setDeaf(false);
           await me.voice.setMute(false);
         } catch (error) {
-          logger6.log("Failed to modify voice state:", error);
+          logger5.log("Failed to modify voice state:", error);
         }
       }
       connection.receiver.speaking.on("start", async (entityId) => {
@@ -2848,12 +2729,17 @@ var VoiceManager = class extends EventEmitter {
         }
       });
     } catch (error) {
-      logger6.log("Failed to establish voice connection:", error);
+      logger5.log("Failed to establish voice connection:", error);
       connection.destroy();
       this.connections.delete(channel.id);
       throw error;
     }
   }
+  /**
+   * Retrieves the voice connection for a given guild ID.
+   * @param {string} guildId - The ID of the guild to get the voice connection for.
+   * @returns {VoiceConnection | undefined} The voice connection for the specified guild ID, or undefined if not found.
+   */
   getVoiceConnection(guildId) {
     const connections = getVoiceConnections(this.client.user.id);
     if (!connections) {
@@ -2864,6 +2750,12 @@ var VoiceManager = class extends EventEmitter {
     );
     return connection;
   }
+  /**
+   * Monitor a member's audio stream for volume activity and speaking thresholds.
+   *
+   * @param {GuildMember} member - The member whose audio stream is being monitored.
+   * @param {BaseGuildVoiceChannel} channel - The voice channel in which the member is connected.
+   */
   async monitorMember(member, channel) {
     const entityId = member?.id;
     const userName = member?.user?.username;
@@ -2944,6 +2836,12 @@ var VoiceManager = class extends EventEmitter {
       opusDecoder
     );
   }
+  /**
+   * Leaves the specified voice channel and stops monitoring all members in that channel.
+   * If there is an active connection in the channel, it will be destroyed.
+   *
+   * @param {BaseGuildVoiceChannel} channel - The voice channel to leave.
+   */
   leaveChannel(channel) {
     const connection = this.connections.get(channel.id);
     if (connection) {
@@ -2957,6 +2855,10 @@ var VoiceManager = class extends EventEmitter {
     }
     console.log(`Left voice channel: ${channel.name} (${channel.id})`);
   }
+  /**
+   * Stop monitoring a specific member by their member ID.
+   * @param {string} memberId - The ID of the member to stop monitoring.
+   */
   stopMonitoringMember(memberId) {
     const monitorInfo = this.activeMonitors.get(memberId);
     if (monitorInfo) {
@@ -2966,10 +2868,18 @@ var VoiceManager = class extends EventEmitter {
       console.log(`Stopped monitoring user ${memberId}`);
     }
   }
+  /**
+   * Asynchronously debounces the process transcription function to prevent rapid execution.
+   *
+   * @param {UUID} entityId - The ID of the entity related to the transcription.
+   * @param {string} name - The name of the entity for transcription.
+   * @param {string} userName - The username of the user initiating the transcription.
+   * @param {BaseGuildVoiceChannel} channel - The voice channel where the transcription is happening.
+   */
   async debouncedProcessTranscription(entityId, name, userName, channel) {
     const DEBOUNCE_TRANSCRIPTION_THRESHOLD = 1500;
     if (this.activeAudioPlayer?.state?.status === "idle") {
-      logger6.log("Cleaning up idle audio player.");
+      logger5.log("Cleaning up idle audio player.");
       this.cleanupAudioPlayer(this.activeAudioPlayer);
     }
     if (this.activeAudioPlayer || this.processingVoice) {
@@ -3000,6 +2910,15 @@ var VoiceManager = class extends EventEmitter {
       }
     }, DEBOUNCE_TRANSCRIPTION_THRESHOLD);
   }
+  /**
+   * Handle user audio stream for monitoring purposes.
+   *
+   * @param {UUID} userId - The unique identifier of the user.
+   * @param {string} name - The name of the user.
+   * @param {string} userName - The username of the user.
+   * @param {BaseGuildVoiceChannel} channel - The voice channel the user is in.
+   * @param {Readable} audioStream - The audio stream to monitor.
+   */
   async handleUserStream(userId, name, userName, channel, audioStream) {
     const entityId = createUniqueUuid5(this.runtime, userId);
     console.log(`Starting audio monitor for user: ${entityId}`);
@@ -3039,6 +2958,16 @@ var VoiceManager = class extends EventEmitter {
       }
     );
   }
+  /**
+   * Process the transcription of audio data for a user.
+   *
+   * @param {UUID} entityId - The unique ID of the user entity.
+   * @param {string} channelId - The ID of the channel where the transcription is taking place.
+   * @param {BaseGuildVoiceChannel} channel - The voice channel where the user is speaking.
+   * @param {string} name - The name of the user.
+   * @param {string} userName - The username of the user.
+   * @returns {Promise<void>}
+   */
   async processTranscription(entityId, channelId, channel, name, userName) {
     const state = this.userStates.get(entityId);
     if (!state || state.buffers.length === 0) return;
@@ -3053,7 +2982,7 @@ var VoiceManager = class extends EventEmitter {
       const wavBuffer = await this.convertOpusToWav(inputBuffer);
       console.log("Starting transcription...");
       const transcriptionText = await this.runtime.useModel(
-        ModelTypes9.TRANSCRIPTION,
+        ModelTypes8.TRANSCRIPTION,
         wavBuffer
       );
       if (transcriptionText && isValidTranscription(transcriptionText)) {
@@ -3076,6 +3005,17 @@ var VoiceManager = class extends EventEmitter {
       console.error(`Error transcribing audio for user ${entityId}:`, error);
     }
   }
+  /**
+   * Handles a voice message received in a Discord channel.
+   *
+   * @param {string} message - The message content.
+   * @param {UUID} entityId - The entity ID associated with the message.
+   * @param {string} channelId - The ID of the Discord channel where the message was received.
+   * @param {BaseGuildVoiceChannel} channel - The Discord channel where the message was received.
+   * @param {string} name - The name associated with the message.
+   * @param {string} userName - The user name associated with the message.
+   * @returns {Promise<{text: string, actions: string[]}>} Object containing the resulting text and actions.
+   */
   async handleMessage(message, entityId, channelId, channel, name, userName) {
     try {
       if (!message || message.trim() === "" || message.length < 3) {
@@ -3134,7 +3074,7 @@ var VoiceManager = class extends EventEmitter {
           if (responseMemory.content.text?.trim()) {
             await this.runtime.getMemoryManager("messages").createMemory(responseMemory);
             const responseStream = await this.runtime.useModel(
-              ModelTypes9.TEXT_TO_SPEECH,
+              ModelTypes8.TEXT_TO_SPEECH,
               content.text
             );
             if (responseStream) {
@@ -3159,6 +3099,12 @@ var VoiceManager = class extends EventEmitter {
       console.error("Error processing voice message:", error);
     }
   }
+  /**
+   * Asynchronously converts an Opus audio Buffer to a WAV audio Buffer.
+   *
+   * @param {Buffer} pcmBuffer - The Opus audio Buffer to convert to WAV.
+   * @returns {Promise<Buffer>} A Promise that resolves with the converted WAV audio Buffer.
+   */
   async convertOpusToWav(pcmBuffer) {
     try {
       const wavHeader = getWavHeader(pcmBuffer.length, DECODE_SAMPLE_RATE);
@@ -3169,6 +3115,11 @@ var VoiceManager = class extends EventEmitter {
       throw error;
     }
   }
+  /**
+   * Scans the given Discord guild to select a suitable voice channel to join.
+   *
+   * @param {Guild} guild The Discord guild to scan for voice channels.
+   */
   async scanGuild(guild) {
     let chosenChannel = null;
     try {
@@ -3196,12 +3147,19 @@ var VoiceManager = class extends EventEmitter {
         console.log(`Joining channel: ${chosenChannel.name}`);
         await this.joinChannel(chosenChannel);
       } else {
-        console.warn("No suitable voice channel found to join.");
+        logger5.debug("Warning: No suitable voice channel found to join.");
       }
     } catch (error) {
       console.error("Error selecting or joining a voice channel:", error);
     }
   }
+  /**
+   * Play an audio stream for a given entity ID.
+   *
+   * @param {UUID} entityId - The ID of the entity to play the audio for.
+   * @param {Readable} audioStream - The audio stream to play.
+   * @returns {void}
+   */
   async playAudioStream(entityId, audioStream) {
     const connection = this.connections.get(entityId);
     if (connection == null) {
@@ -3209,15 +3167,15 @@ var VoiceManager = class extends EventEmitter {
       return;
     }
     this.cleanupAudioPlayer(this.activeAudioPlayer);
-    const audioPlayer = createAudioPlayer2({
+    const audioPlayer = createAudioPlayer({
       behaviors: {
-        noSubscriber: NoSubscriberBehavior2.Pause
+        noSubscriber: NoSubscriberBehavior.Pause
       }
     });
     this.activeAudioPlayer = audioPlayer;
     connection.subscribe(audioPlayer);
     const audioStartTime = Date.now();
-    const resource = createAudioResource2(audioStream, {
+    const resource = createAudioResource(audioStream, {
       inputType: StreamType.Arbitrary
     });
     audioPlayer.play(resource);
@@ -3234,6 +3192,12 @@ var VoiceManager = class extends EventEmitter {
       }
     );
   }
+  /**
+   * Cleans up the provided audio player by stopping it, removing all listeners,
+   * and resetting the active audio player if it matches the provided player.
+   *
+   * @param {AudioPlayer} audioPlayer - The audio player to be cleaned up.
+   */
   cleanupAudioPlayer(audioPlayer) {
     if (!audioPlayer) return;
     audioPlayer.stop();
@@ -3242,6 +3206,12 @@ var VoiceManager = class extends EventEmitter {
       this.activeAudioPlayer = null;
     }
   }
+  /**
+   * Asynchronously handles the join channel command in an interaction.
+   *
+   * @param {any} interaction - The interaction object representing the user's input.
+   * @returns {Promise<void>} - A promise that resolves once the join channel command is handled.
+   */
   async handleJoinChannelCommand(interaction) {
     try {
       await interaction.deferReply();
@@ -3269,6 +3239,12 @@ var VoiceManager = class extends EventEmitter {
       await interaction.editReply("Failed to join the voice channel.").catch(console.error);
     }
   }
+  /**
+   * Handles the leave channel command by destroying the voice connection if it exists.
+   *
+   * @param {any} interaction The interaction object representing the command invocation.
+   * @returns {void}
+   */
   async handleLeaveChannelCommand(interaction) {
     const connection = this.getVoiceConnection(interaction.guildId);
     if (!connection) {
@@ -3285,7 +3261,7 @@ var VoiceManager = class extends EventEmitter {
   }
 };
 
-// src/index.ts
+// src/service.ts
 var DiscordService = class _DiscordService extends Service {
   static serviceType = DISCORD_SERVICE_NAME;
   capabilityDescription = "The agent is able to send and receive messages on discord";
@@ -3293,49 +3269,91 @@ var DiscordService = class _DiscordService extends Service {
   character;
   messageManager;
   voiceManager;
+  /**
+   * Constructor for Discord client.
+   * Initializes the Discord client with specified intents and partials,
+   * sets up event listeners, and ensures all servers exist.
+   *
+   * @param {IAgentRuntime} runtime - The AgentRuntime instance
+   */
   constructor(runtime) {
     super(runtime);
-    logger7.log("Discord client constructor was engaged");
-    this.client = new DiscordJsClient({
-      intents: [
-        GatewayIntentBits.Guilds,
-        GatewayIntentBits.GuildMembers,
-        GatewayIntentBits.GuildPresences,
-        GatewayIntentBits.DirectMessages,
-        GatewayIntentBits.GuildVoiceStates,
-        GatewayIntentBits.MessageContent,
-        GatewayIntentBits.GuildMessages,
-        GatewayIntentBits.DirectMessageTyping,
-        GatewayIntentBits.GuildMessageTyping,
-        GatewayIntentBits.GuildMessageReactions
-      ],
-      partials: [
-        Partials.Channel,
-        Partials.Message,
-        Partials.User,
-        Partials.Reaction
-      ]
-    });
-    this.runtime = runtime;
-    this.voiceManager = new VoiceManager(this, runtime);
-    this.messageManager = new MessageManager(this);
-    this.client.once(Events2.ClientReady, this.onClientReady.bind(this));
-    this.client.login(runtime.getSetting("DISCORD_API_TOKEN"));
-    this.setupEventListeners();
-    const ensureAllServersExist = async (runtime2) => {
-      const guilds = await this.client.guilds.fetch();
-      for (const [, guild] of guilds) {
-        await this.ensureAllChannelsExist(runtime2, guild);
-      }
-    };
-    ensureAllServersExist(this.runtime);
+    const token = runtime.getSetting("DISCORD_API_TOKEN");
+    if (!token || token.trim() === "") {
+      logger6.warn(
+        "Discord API Token not provided - Discord functionality will be unavailable"
+      );
+      this.client = null;
+      return;
+    }
+    try {
+      this.client = new DiscordJsClient({
+        intents: [
+          GatewayIntentBits.Guilds,
+          GatewayIntentBits.GuildMembers,
+          GatewayIntentBits.GuildPresences,
+          GatewayIntentBits.DirectMessages,
+          GatewayIntentBits.GuildVoiceStates,
+          GatewayIntentBits.MessageContent,
+          GatewayIntentBits.GuildMessages,
+          GatewayIntentBits.DirectMessageTyping,
+          GatewayIntentBits.GuildMessageTyping,
+          GatewayIntentBits.GuildMessageReactions
+        ],
+        partials: [
+          Partials.Channel,
+          Partials.Message,
+          Partials.User,
+          Partials.Reaction
+        ]
+      });
+      this.runtime = runtime;
+      this.voiceManager = new VoiceManager(this, runtime);
+      this.messageManager = new MessageManager(this);
+      this.client.once(Events.ClientReady, this.onClientReady.bind(this));
+      this.client.login(token).catch((error) => {
+        logger6.error(`Failed to login to Discord: ${error.message}`);
+        this.client = null;
+      });
+      this.setupEventListeners();
+      const ensureAllServersExist = async (runtime2) => {
+        const guilds = await this.client.guilds.fetch();
+        for (const [, guild] of guilds) {
+          await this.ensureAllChannelsExist(runtime2, guild);
+        }
+      };
+      ensureAllServersExist(this.runtime);
+    } catch (error) {
+      logger6.error(`Error initializing Discord client: ${error.message}`);
+      this.client = null;
+    }
   }
+  /**
+   * Ensures that all channels exist in the database for a given guild.
+   * @param {IAgentRuntime} runtime - The agent runtime object.
+   * @param {OAuth2Guild} guild - The OAuth2Guild object for which channels need to be ensured.
+   * @returns {Promise<void>} - A Promise that resolves once all channels are ensured.
+   */
   async ensureAllChannelsExist(runtime, guild) {
-    const guildObj = await guild.fetch();
-    const guildChannels = await guild.fetch();
+    let guildObj;
+    let guildChannels;
+    let retries = 3;
+    while (retries > 0) {
+      try {
+        guildObj = await guild.fetch();
+        guildChannels = await guild.fetch();
+        break;
+      } catch (error) {
+        retries--;
+        if (retries === 0) {
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      }
+    }
     for (const [, channel] of guildChannels.channels.cache) {
       const roomId = createUniqueUuid6(this.runtime, channel.id);
-      const room = await runtime.getDatabaseAdapter().getRoom(roomId);
+      const room = await runtime.getRoom(roomId);
       if (room) {
         continue;
       }
@@ -3352,595 +3370,1090 @@ var DiscordService = class _DiscordService extends Service {
             [ownerId]: Role.OWNER
           }
         }
-      });
-      await runtime.ensureRoomExists({
-        id: roomId,
-        name: channel.name,
-        source: "discord",
-        type: ChannelType10.GROUP,
-        channelId: channel.id,
-        serverId: guild.id,
-        worldId
-      });
+      });
+      await runtime.ensureRoomExists({
+        id: roomId,
+        name: channel.name,
+        source: "discord",
+        type: ChannelType9.GROUP,
+        channelId: channel.id,
+        serverId: guild.id,
+        worldId
+      });
+    }
+  }
+  /**
+   * Set up event listeners for the client
+   */
+  setupEventListeners() {
+    if (!this.client) {
+      return;
+    }
+    this.client.on("messageCreate", (message) => {
+      if (message.author.id === this.client?.user?.id || message.author.bot) {
+        return;
+      }
+      try {
+        this.messageManager.handleMessage(message);
+      } catch (error) {
+        logger6.error(`Error handling message: ${error}`);
+      }
+    });
+    this.client.on("messageReactionAdd", async (reaction, user) => {
+      if (user.id === this.client?.user?.id) {
+        return;
+      }
+      try {
+        await this.handleReactionAdd(reaction, user);
+      } catch (error) {
+        logger6.error(`Error handling reaction add: ${error}`);
+      }
+    });
+    this.client.on("messageReactionRemove", async (reaction, user) => {
+      if (user.id === this.client?.user?.id) {
+        return;
+      }
+      try {
+        await this.handleReactionRemove(reaction, user);
+      } catch (error) {
+        logger6.error(`Error handling reaction remove: ${error}`);
+      }
+    });
+    this.client.on("guildCreate", async (guild) => {
+      try {
+        await this.handleGuildCreate(guild);
+      } catch (error) {
+        logger6.error(`Error handling guild create: ${error}`);
+      }
+    });
+    this.client.on("guildMemberAdd", async (member) => {
+      try {
+        await this.handleGuildMemberAdd(member);
+      } catch (error) {
+        logger6.error(`Error handling guild member add: ${error}`);
+      }
+    });
+    this.client.on("interactionCreate", async (interaction) => {
+      try {
+        await this.handleInteractionCreate(interaction);
+      } catch (error) {
+        logger6.error(`Error handling interaction: ${error}`);
+      }
+    });
+  }
+  /**
+   * Handles the event when a new member joins a guild.
+   *
+   * @param {GuildMember} member - The GuildMember object representing the new member that joined the guild.
+   * @returns {Promise<void>} - A Promise that resolves once the event handling is complete.
+   */
+  async handleGuildMemberAdd(member) {
+    logger6.log(`New member joined: ${member.user.username}`);
+    const guild = member.guild;
+    const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
+    this.runtime.emitEvent([EventTypes2.ENTITY_JOINED], {
+      runtime: this.runtime,
+      entityId: createUniqueUuid6(this.runtime, member.id),
+      worldId: createUniqueUuid6(this.runtime, guild.id),
+      source: "discord",
+      metadata: {
+        originalId: member.id,
+        username: tag,
+        displayName: member.displayName || member.user.username,
+        roles: member.roles.cache.map((r) => r.name),
+        joinedAt: member.joinedAt?.getTime()
+      }
+    });
+    this.runtime.emitEvent(["DISCORD_USER_JOINED" /* ENTITY_JOINED */], {
+      runtime: this.runtime,
+      entityId: createUniqueUuid6(this.runtime, member.id),
+      member,
+      guild
+    });
+  }
+  /**
+   *
+   * Start the Discord service
+   * @param {IAgentRuntime} runtime - The runtime for the agent
+   * @returns {Promise<DiscordService>} A promise that resolves to a DiscordService instance
+   *
+   */
+  static async start(runtime) {
+    const token = runtime.getSetting("DISCORD_API_TOKEN");
+    if (!token || token.trim() === "") {
+      throw new Error("Discord API Token not provided");
+    }
+    const maxRetries = 5;
+    let retryCount = 0;
+    let lastError = null;
+    while (retryCount < maxRetries) {
+      try {
+        const service = new _DiscordService(runtime);
+        if (!service.client) {
+          throw new Error("Failed to initialize Discord client");
+        }
+        await new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error("Discord client ready timeout"));
+          }, 3e4);
+          service.client?.once("ready", () => {
+            clearTimeout(timeout);
+            resolve();
+          });
+        });
+        return service;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        logger6.error(`Discord initialization attempt ${retryCount + 1} failed: ${lastError.message}`);
+        retryCount++;
+        if (retryCount < maxRetries) {
+          const delay = 2 ** retryCount * 1e3;
+          logger6.info(`Retrying Discord initialization in ${delay / 1e3} seconds...`);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw new Error(`Discord initialization failed after ${maxRetries} attempts. Last error: ${lastError?.message}`);
+  }
+  /**
+   * Stops the Discord client associated with the given runtime.
+   *
+   * @param {IAgentRuntime} runtime - The runtime associated with the Discord client.
+   * @returns {void}
+   */
+  static async stop(runtime) {
+    const client = runtime.getService(DISCORD_SERVICE_NAME);
+    if (!client) {
+      logger6.error("DiscordService not found");
+      return;
+    }
+    try {
+      await client.stop();
+    } catch (e) {
+      logger6.error("client-discord instance stop err", e);
+    }
+  }
+  /**
+   * Asynchronously stops the client by destroying it.
+   *
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    await this.client?.destroy();
+  }
+  /**
+   * Handle the event when the client is ready.
+   * @param {Object} readyClient - The ready client object containing user information.
+   * @param {string} readyClient.user.tag - The username and discriminator of the client user.
+   * @param {string} readyClient.user.id - The user ID of the client.
+   * @returns {Promise<void>}
+   */
+  async onClientReady(readyClient) {
+    logger6.success(`DISCORD: Logged in as ${readyClient.user?.tag}`);
+    const commands = [
+      {
+        name: "joinchannel",
+        description: "Join a voice channel",
+        options: [
+          {
+            name: "channel",
+            type: 7,
+            // CHANNEL type
+            description: "The voice channel to join",
+            required: true,
+            channel_types: [2]
+            // GuildVoice type
+          }
+        ]
+      },
+      {
+        name: "leavechannel",
+        description: "Leave the current voice channel"
+      }
+    ];
+    try {
+      await this.client?.application?.commands.set(commands);
+      logger6.success("DISCORD: Slash commands registered");
+    } catch (error) {
+      console.error("Error registering slash commands:", error);
+    }
+    const requiredPermissions = [
+      // Text Permissions
+      PermissionsBitField2.Flags.ViewChannel,
+      PermissionsBitField2.Flags.SendMessages,
+      PermissionsBitField2.Flags.SendMessagesInThreads,
+      PermissionsBitField2.Flags.CreatePrivateThreads,
+      PermissionsBitField2.Flags.CreatePublicThreads,
+      PermissionsBitField2.Flags.EmbedLinks,
+      PermissionsBitField2.Flags.AttachFiles,
+      PermissionsBitField2.Flags.AddReactions,
+      PermissionsBitField2.Flags.UseExternalEmojis,
+      PermissionsBitField2.Flags.UseExternalStickers,
+      PermissionsBitField2.Flags.MentionEveryone,
+      PermissionsBitField2.Flags.ManageMessages,
+      PermissionsBitField2.Flags.ReadMessageHistory,
+      // Voice Permissions
+      PermissionsBitField2.Flags.Connect,
+      PermissionsBitField2.Flags.Speak,
+      PermissionsBitField2.Flags.UseVAD,
+      PermissionsBitField2.Flags.PrioritySpeaker
+    ].reduce((a, b) => a | b, 0n);
+    logger6.success("Use this URL to add the bot to your server:");
+    logger6.success(
+      `https://discord.com/api/oauth2/authorize?client_id=${readyClient.user?.id}&permissions=${requiredPermissions}&scope=bot%20applications.commands`
+    );
+    await this.onReady();
+  }
+  /**
+   * Asynchronously retrieves the type of a given channel.
+   *
+   * @param {Channel} channel - The channel for which to determine the type.
+   * @returns {Promise<ChannelType>} A Promise that resolves with the type of the channel.
+   */
+  async getChannelType(channel) {
+    switch (channel.type) {
+      case DiscordChannelType4.DM:
+        return ChannelType9.DM;
+      case DiscordChannelType4.GuildText:
+        return ChannelType9.GROUP;
+      case DiscordChannelType4.GuildVoice:
+        return ChannelType9.VOICE_GROUP;
+    }
+  }
+  /**
+   * Handles the addition of a reaction on a message.
+   *
+   * @param {MessageReaction | PartialMessageReaction} reaction The reaction that was added.
+   * @param {User | PartialUser} user The user who added the reaction.
+   * @returns {void}
+   */
+  async handleReactionAdd(reaction, user) {
+    try {
+      logger6.log("Reaction added");
+      if (!reaction || !user) {
+        logger6.warn("Invalid reaction or user");
+        return;
+      }
+      let emoji = reaction.emoji.name;
+      if (!emoji && reaction.emoji.id) {
+        emoji = `<:${reaction.emoji.name}:${reaction.emoji.id}>`;
+      }
+      if (reaction.partial) {
+        try {
+          await reaction.fetch();
+        } catch (error) {
+          logger6.error("Failed to fetch partial reaction:", error);
+          return;
+        }
+      }
+      const timestamp = Date.now();
+      const roomId = createUniqueUuid6(
+        this.runtime,
+        reaction.message.channel.id
+      );
+      const entityId = createUniqueUuid6(this.runtime, user.id);
+      const reactionUUID = createUniqueUuid6(
+        this.runtime,
+        `${reaction.message.id}-${user.id}-${emoji}-${timestamp}`
+      );
+      if (!entityId || !roomId) {
+        logger6.error("Invalid user ID or room ID", {
+          entityId,
+          roomId
+        });
+        return;
+      }
+      const messageContent = reaction.message.content || "";
+      const truncatedContent = messageContent.length > 50 ? `${messageContent.substring(0, 50)}...` : messageContent;
+      const reactionMessage = `*Added <${emoji}> to: "${truncatedContent}"*`;
+      const userName = reaction.message.author?.username || "unknown";
+      const name = reaction.message.author?.displayName || userName;
+      await this.runtime.ensureConnection({
+        entityId,
+        roomId,
+        userName,
+        name,
+        source: "discord",
+        channelId: reaction.message.channel.id,
+        serverId: reaction.message.guild?.id,
+        type: await this.getChannelType(reaction.message.channel)
+      });
+      const inReplyTo = createUniqueUuid6(this.runtime, reaction.message.id);
+      const memory = {
+        id: reactionUUID,
+        entityId,
+        agentId: this.runtime.agentId,
+        content: {
+          // name,
+          // userName,
+          text: reactionMessage,
+          source: "discord",
+          inReplyTo,
+          channelType: await this.getChannelType(
+            reaction.message.channel
+          )
+        },
+        roomId,
+        createdAt: timestamp
+      };
+      const callback = async (content) => {
+        if (!reaction.message.channel) {
+          logger6.error("No channel found for reaction message");
+          return;
+        }
+        await reaction.message.channel.send(content.text);
+        return [];
+      };
+      this.runtime.emitEvent(
+        ["DISCORD_REACTION_RECEIVED", "REACTION_RECEIVED"],
+        {
+          runtime: this.runtime,
+          message: memory,
+          callback
+        }
+      );
+    } catch (error) {
+      logger6.error("Error handling reaction:", error);
+    }
+  }
+  /**
+   * Handles the removal of a reaction on a message.
+   *
+   * @param {MessageReaction | PartialMessageReaction} reaction - The reaction that was removed.
+   * @param {User | PartialUser} user - The user who removed the reaction.
+   * @returns {Promise<void>} - A Promise that resolves after handling the reaction removal.
+   */
+  async handleReactionRemove(reaction, user) {
+    try {
+      logger6.log("Reaction removed");
+      let emoji = reaction.emoji.name;
+      if (!emoji && reaction.emoji.id) {
+        emoji = `<:${reaction.emoji.name}:${reaction.emoji.id}>`;
+      }
+      if (reaction.partial) {
+        try {
+          await reaction.fetch();
+        } catch (error) {
+          logger6.error(
+            "Something went wrong when fetching the message:",
+            error
+          );
+          return;
+        }
+      }
+      const messageContent = reaction.message.content || "";
+      const truncatedContent = messageContent.length > 50 ? `${messageContent.substring(0, 50)}...` : messageContent;
+      const reactionMessage = `*Removed <${emoji}> from: "${truncatedContent}"*`;
+      const roomId = createUniqueUuid6(
+        this.runtime,
+        reaction.message.channel.id
+      );
+      const entityId = createUniqueUuid6(this.runtime, user.id);
+      const timestamp = Date.now();
+      const reactionUUID = createUniqueUuid6(
+        this.runtime,
+        `${reaction.message.id}-${user.id}-${emoji}-${timestamp}`
+      );
+      const userName = reaction.message.author?.username || "unknown";
+      const name = reaction.message.author?.displayName || userName;
+      await this.runtime.ensureConnection({
+        entityId,
+        roomId,
+        userName,
+        name,
+        source: "discord",
+        channelId: reaction.message.channel.id,
+        serverId: reaction.message.guild?.id,
+        type: await this.getChannelType(reaction.message.channel)
+      });
+      const memory = {
+        id: reactionUUID,
+        entityId,
+        agentId: this.runtime.agentId,
+        content: {
+          // name,
+          // userName,
+          text: reactionMessage,
+          source: "discord",
+          inReplyTo: createUniqueUuid6(this.runtime, reaction.message.id),
+          channelType: await this.getChannelType(
+            reaction.message.channel
+          )
+        },
+        roomId,
+        createdAt: Date.now()
+      };
+      const callback = async (content) => {
+        if (!reaction.message.channel) {
+          logger6.error("No channel found for reaction message");
+          return;
+        }
+        await reaction.message.channel.send(content.text);
+        return [];
+      };
+      this.runtime.emitEvent(["DISCORD_REACTION_RECEIVED" /* REACTION_RECEIVED */], {
+        runtime: this.runtime,
+        message: memory,
+        callback
+      });
+    } catch (error) {
+      logger6.error("Error handling reaction removal:", error);
+    }
+  }
+  /**
+   * Handles the event when the bot joins a guild. It logs the guild name, fetches additional information about the guild, scans the guild for voice data, creates standardized world data structure, generates unique IDs, and emits events to the runtime.
+   * @param {Guild} guild - The guild that the bot has joined.
+   * @returns {Promise<void>}
+   */
+  async handleGuildCreate(guild) {
+    logger6.log(`Joined guild ${guild.name}`);
+    const fullGuild = await guild.fetch();
+    this.voiceManager.scanGuild(guild);
+    const ownerId = createUniqueUuid6(this.runtime, fullGuild.ownerId);
+    const worldId = createUniqueUuid6(this.runtime, fullGuild.id);
+    const standardizedData = {
+      runtime: this.runtime,
+      rooms: await this.buildStandardizedRooms(fullGuild, worldId),
+      users: await this.buildStandardizedUsers(fullGuild),
+      world: {
+        id: worldId,
+        name: fullGuild.name,
+        agentId: this.runtime.agentId,
+        serverId: fullGuild.id,
+        metadata: {
+          ownership: fullGuild.ownerId ? { ownerId } : void 0,
+          roles: {
+            [ownerId]: Role.OWNER
+          }
+        }
+      },
+      source: "discord"
+    };
+    this.runtime.emitEvent(["DISCORD_WORLD_JOINED" /* WORLD_JOINED */], {
+      runtime: this.runtime,
+      server: fullGuild,
+      source: "discord"
+    });
+    this.runtime.emitEvent([EventTypes2.WORLD_JOINED], standardizedData);
+  }
+  /**
+   * Handles interactions created by the user, specifically commands.
+   * @param {any} interaction - The interaction object received
+   * @returns {void}
+   */
+  async handleInteractionCreate(interaction) {
+    if (!interaction.isCommand()) return;
+    switch (interaction.commandName) {
+      case "joinchannel":
+        await this.voiceManager.handleJoinChannelCommand(interaction);
+        break;
+      case "leavechannel":
+        await this.voiceManager.handleLeaveChannelCommand(interaction);
+        break;
+    }
+  }
+  /**
+   * Builds a standardized list of rooms from Discord guild channels
+   */
+  /**
+   * Build standardized rooms for a guild based on text and voice channels.
+   *
+   * @param {Guild} guild The guild to build rooms for.
+   * @param {UUID} _worldId The ID of the world to associate with the rooms.
+   * @returns {Promise<any[]>} An array of standardized room objects.
+   */
+  async buildStandardizedRooms(guild, _worldId) {
+    const rooms = [];
+    for (const [channelId, channel] of guild.channels.cache) {
+      if (channel.type === DiscordChannelType4.GuildText || channel.type === DiscordChannelType4.GuildVoice) {
+        const roomId = createUniqueUuid6(this.runtime, channelId);
+        let channelType;
+        switch (channel.type) {
+          case DiscordChannelType4.GuildText:
+            channelType = ChannelType9.GROUP;
+            break;
+          case DiscordChannelType4.GuildVoice:
+            channelType = ChannelType9.VOICE_GROUP;
+            break;
+          default:
+            channelType = ChannelType9.GROUP;
+        }
+        let participants = [];
+        if (guild.memberCount < 1e3 && channel.type === DiscordChannelType4.GuildText) {
+          try {
+            participants = Array.from(guild.members.cache.values()).filter(
+              (member) => channel.permissionsFor(member)?.has(PermissionsBitField2.Flags.ViewChannel)
+            ).map((member) => createUniqueUuid6(this.runtime, member.id));
+          } catch (error) {
+            logger6.warn(
+              `Failed to get participants for channel ${channel.name}:`,
+              error
+            );
+          }
+        }
+        rooms.push({
+          id: roomId,
+          name: channel.name,
+          type: channelType,
+          channelId: channel.id,
+          participants
+        });
+      }
+    }
+    return rooms;
+  }
+  /**
+   * Builds a standardized list of users from Discord guild members
+   */
+  async buildStandardizedUsers(guild) {
+    const entities = [];
+    const botId = this.client?.user?.id;
+    if (guild.memberCount > 1e3) {
+      logger6.info(
+        `Using optimized user sync for large guild ${guild.name} (${guild.memberCount} members)`
+      );
+      try {
+        for (const [, member] of guild.members.cache) {
+          const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
+          if (member.id !== botId) {
+            entities.push({
+              id: createUniqueUuid6(this.runtime, member.id),
+              names: Array.from(
+                /* @__PURE__ */ new Set([
+                  member.user.username,
+                  member.displayName,
+                  member.user.globalName
+                ])
+              ),
+              agentId: this.runtime.agentId,
+              metadata: {
+                default: {
+                  username: tag,
+                  name: member.displayName || member.user.username
+                },
+                discord: member.user.globalName ? {
+                  username: tag,
+                  name: member.displayName || member.user.username,
+                  globalName: member.user.globalName,
+                  userId: member.id
+                } : {
+                  username: tag,
+                  name: member.displayName || member.user.username,
+                  userId: member.id
+                }
+              }
+            });
+          }
+        }
+        if (entities.length < 100) {
+          logger6.info(`Adding online members for ${guild.name}`);
+          const onlineMembers = await guild.members.fetch({ limit: 100 });
+          for (const [, member] of onlineMembers) {
+            if (member.id !== botId) {
+              const entityId = createUniqueUuid6(this.runtime, member.id);
+              if (!entities.some((u) => u.id === entityId)) {
+                const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
+                entities.push({
+                  id: entityId,
+                  names: Array.from(
+                    /* @__PURE__ */ new Set([
+                      member.user.username,
+                      member.displayName,
+                      member.user.globalName
+                    ])
+                  ),
+                  agentId: this.runtime.agentId,
+                  metadata: {
+                    default: {
+                      username: tag,
+                      name: member.displayName || member.user.username
+                    },
+                    discord: member.user.globalName ? {
+                      username: tag,
+                      name: member.displayName || member.user.username,
+                      globalName: member.user.globalName,
+                      userId: member.id
+                    } : {
+                      username: tag,
+                      name: member.displayName || member.user.username,
+                      userId: member.id
+                    }
+                  }
+                });
+              }
+            }
+          }
+        }
+      } catch (error) {
+        logger6.error(`Error fetching members for ${guild.name}:`, error);
+      }
+    } else {
+      try {
+        let members = guild.members.cache;
+        if (members.size === 0) {
+          members = await guild.members.fetch();
+        }
+        for (const [, member] of members) {
+          if (member.id !== botId) {
+            const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
+            entities.push({
+              id: createUniqueUuid6(this.runtime, member.id),
+              names: Array.from(
+                /* @__PURE__ */ new Set([
+                  member.user.username,
+                  member.displayName,
+                  member.user.globalName
+                ])
+              ),
+              agentId: this.runtime.agentId,
+              metadata: {
+                default: {
+                  username: tag,
+                  name: member.displayName || member.user.username
+                },
+                discord: member.user.globalName ? {
+                  username: tag,
+                  name: member.displayName || member.user.username,
+                  globalName: member.user.globalName,
+                  userId: member.id
+                } : {
+                  username: tag,
+                  name: member.displayName || member.user.username,
+                  userId: member.id
+                }
+              }
+            });
+          }
+        }
+      } catch (error) {
+        logger6.error(`Error fetching members for ${guild.name}:`, error);
+      }
     }
+    return entities;
   }
-  setupEventListeners() {
-    this.client.on("guildCreate", this.handleGuildCreate.bind(this));
-    this.client.on(
-      Events2.MessageReactionAdd,
-      this.handleReactionAdd.bind(this)
-    );
-    this.client.on(
-      Events2.MessageReactionRemove,
-      this.handleReactionRemove.bind(this)
-    );
-    this.client.on(Events2.GuildMemberAdd, this.handleGuildMemberAdd.bind(this));
-    this.client.on(
-      "voiceStateUpdate",
-      this.voiceManager.handleVoiceStateUpdate.bind(this.voiceManager)
-    );
-    this.client.on(
-      "userStream",
-      this.voiceManager.handleUserStream.bind(this.voiceManager)
-    );
-    this.client.on(
-      Events2.MessageCreate,
-      this.messageManager.handleMessage.bind(this.messageManager)
-    );
-    this.client.on(
-      Events2.InteractionCreate,
-      this.handleInteractionCreate.bind(this)
-    );
-  }
-  async handleGuildMemberAdd(member) {
-    logger7.log(`New member joined: ${member.user.username}`);
-    const guild = member.guild;
-    const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
-    this.runtime.emitEvent("USER_JOINED", {
-      runtime: this.runtime,
-      entityId: createUniqueUuid6(this.runtime, member.id),
-      user: {
-        id: member.id,
-        username: tag,
-        displayName: member.displayName || member.user.username
-      },
-      serverId: guild.id,
-      channelId: null,
-      // No specific channel for server joins
-      channelType: ChannelType10.WORLD,
-      source: "discord"
-    });
-    this.runtime.emitEvent("DISCORD_USER_JOINED", {
-      runtime: this.runtime,
-      entityId: createUniqueUuid6(this.runtime, member.id),
-      member,
-      guild
-    });
-  }
-  static async start(runtime) {
-    const client = new _DiscordService(runtime);
-    return client;
-  }
-  static async stop(runtime) {
-    const client = runtime.getService(DISCORD_SERVICE_NAME);
-    if (!client) {
-      logger7.error("DiscordService not found");
-      return;
-    }
-    try {
-      await client.stop();
-    } catch (e) {
-      logger7.error("client-discord instance stop err", e);
+  async onReady() {
+    logger6.log("DISCORD ON READY");
+    const guilds = await this.client?.guilds.fetch();
+    for (const [, guild] of guilds) {
+      const fullGuild = await guild.fetch();
+      await this.voiceManager.scanGuild(fullGuild);
+      setTimeout(async () => {
+        const fullGuild2 = await guild.fetch();
+        logger6.log("DISCORD SERVER CONNECTED", fullGuild2.name);
+        this.runtime.emitEvent(["DISCORD_SERVER_CONNECTED" /* WORLD_CONNECTED */], {
+          runtime: this.runtime,
+          server: fullGuild2,
+          source: "discord"
+        });
+        const worldId = createUniqueUuid6(this.runtime, fullGuild2.id);
+        const ownerId = createUniqueUuid6(this.runtime, fullGuild2.ownerId);
+        const standardizedData = {
+          name: fullGuild2.name,
+          runtime: this.runtime,
+          rooms: await this.buildStandardizedRooms(fullGuild2, worldId),
+          entities: await this.buildStandardizedUsers(fullGuild2),
+          world: {
+            id: worldId,
+            name: fullGuild2.name,
+            agentId: this.runtime.agentId,
+            serverId: fullGuild2.id,
+            metadata: {
+              ownership: fullGuild2.ownerId ? { ownerId } : void 0,
+              roles: {
+                [ownerId]: Role.OWNER
+              }
+            }
+          },
+          source: "discord"
+        };
+        this.runtime.emitEvent([EventTypes2.WORLD_CONNECTED], standardizedData);
+      }, 1e3);
     }
+    this.client?.emit("voiceManagerReady");
   }
-  async stop() {
-    await this.client.destroy();
-  }
-  async onClientReady(readyClient) {
-    logger7.success(`Logged in as ${readyClient.user?.tag}`);
-    const commands = [
+};
+
+// src/tests.ts
+import {
+  AudioPlayerStatus,
+  NoSubscriberBehavior as NoSubscriberBehavior2,
+  VoiceConnectionStatus as VoiceConnectionStatus2,
+  createAudioPlayer as createAudioPlayer2,
+  createAudioResource as createAudioResource2,
+  entersState as entersState2
+} from "@discordjs/voice";
+import {
+  ModelTypes as ModelTypes9,
+  logger as logger7
+} from "@elizaos/core";
+import { ChannelType as ChannelType10, Events as Events2 } from "discord.js";
+var TEST_IMAGE_URL = "https://github.com/elizaOS/awesome-eliza/blob/main/assets/eliza-logo.jpg?raw=true";
+var DiscordTestSuite = class {
+  name = "discord";
+  discordClient = null;
+  tests;
+  /**
+   * Constructor for initializing the tests array with test cases to be executed.
+   *
+   * @constructor
+   * @this {TestSuite}
+   */
+  constructor() {
+    this.tests = [
       {
-        name: "joinchannel",
-        description: "Join a voice channel",
-        options: [
-          {
-            name: "channel",
-            type: 7,
-            // CHANNEL type
-            description: "The voice channel to join",
-            required: true,
-            channel_types: [2]
-            // GuildVoice type
-          }
-        ]
+        name: "Initialize Discord Client",
+        fn: this.testCreatingDiscordClient.bind(this)
       },
       {
-        name: "leavechannel",
-        description: "Leave the current voice channel"
+        name: "Slash Commands - Join Voice",
+        fn: this.testJoinVoiceSlashCommand.bind(this)
+      },
+      {
+        name: "Voice Playback & TTS",
+        fn: this.testTextToSpeechPlayback.bind(this)
+      },
+      {
+        name: "Send Message with Attachments",
+        fn: this.testSendingTextMessage.bind(this)
+      },
+      {
+        name: "Handle Incoming Messages",
+        fn: this.testHandlingMessage.bind(this)
+      },
+      {
+        name: "Slash Commands - Leave Voice",
+        fn: this.testLeaveVoiceSlashCommand.bind(this)
       }
     ];
+  }
+  /**
+   * Asynchronously tests the creation of Discord client using the provided runtime.
+   *
+   * @param {IAgentRuntime} runtime - The agent runtime used to obtain the Discord service.
+   * @returns {Promise<void>} - A Promise that resolves once the Discord client is ready.
+   * @throws {Error} - If an error occurs while creating the Discord client.
+   */
+  async testCreatingDiscordClient(runtime) {
     try {
-      await this.client.application?.commands.set(commands);
-      logger7.success("Slash commands registered");
+      this.discordClient = runtime.getService(
+        ServiceTypes2.DISCORD
+      );
+      if (this.discordClient.client.isReady()) {
+        logger7.success("DiscordService is already ready.");
+      } else {
+        logger7.info("Waiting for DiscordService to be ready...");
+        await new Promise((resolve, reject) => {
+          this.discordClient.client.once(Events2.ClientReady, resolve);
+          this.discordClient.client.once(Events2.Error, reject);
+        });
+      }
     } catch (error) {
-      console.error("Error registering slash commands:", error);
+      throw new Error(`Error in test creating Discord client: ${error}`);
     }
-    const requiredPermissions = [
-      // Text Permissions
-      PermissionsBitField2.Flags.ViewChannel,
-      PermissionsBitField2.Flags.SendMessages,
-      PermissionsBitField2.Flags.SendMessagesInThreads,
-      PermissionsBitField2.Flags.CreatePrivateThreads,
-      PermissionsBitField2.Flags.CreatePublicThreads,
-      PermissionsBitField2.Flags.EmbedLinks,
-      PermissionsBitField2.Flags.AttachFiles,
-      PermissionsBitField2.Flags.AddReactions,
-      PermissionsBitField2.Flags.UseExternalEmojis,
-      PermissionsBitField2.Flags.UseExternalStickers,
-      PermissionsBitField2.Flags.MentionEveryone,
-      PermissionsBitField2.Flags.ManageMessages,
-      PermissionsBitField2.Flags.ReadMessageHistory,
-      // Voice Permissions
-      PermissionsBitField2.Flags.Connect,
-      PermissionsBitField2.Flags.Speak,
-      PermissionsBitField2.Flags.UseVAD,
-      PermissionsBitField2.Flags.PrioritySpeaker
-    ].reduce((a, b) => a | b, 0n);
-    logger7.success("Use this URL to add the bot to your server:");
-    logger7.success(
-      `https://discord.com/api/oauth2/authorize?client_id=${readyClient.user?.id}&permissions=${requiredPermissions}&scope=bot%20applications.commands`
-    );
-    await this.onReady();
   }
-  async getChannelType(channel) {
-    switch (channel.type) {
-      case DiscordChannelType4.DM:
-        return ChannelType10.DM;
-      case DiscordChannelType4.GuildText:
-        return ChannelType10.GROUP;
-      case DiscordChannelType4.GuildVoice:
-        return ChannelType10.VOICE_GROUP;
+  /**
+   * Asynchronously tests the join voice slash command functionality.
+   *
+   * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+   * @returns {Promise<void>} - A promise that resolves once the test is complete.
+   * @throws {Error} - If there is an error in executing the slash command test.
+   */
+  async testJoinVoiceSlashCommand(runtime) {
+    try {
+      await this.waitForVoiceManagerReady(this.discordClient);
+      const channel = await this.getTestChannel(runtime);
+      if (!channel || !channel.isTextBased()) {
+        throw new Error("Invalid test channel for slash command test.");
+      }
+      const fakeJoinInteraction = {
+        isCommand: () => true,
+        commandName: "joinchannel",
+        options: {
+          get: (name) => name === "channel" ? { value: channel.id } : null
+        },
+        guild: channel.guild,
+        deferReply: async () => {
+        },
+        editReply: async (message) => {
+          logger7.info(`JoinChannel Slash Command Response: ${message}`);
+        }
+      };
+      await this.discordClient.voiceManager.handleJoinChannelCommand(
+        fakeJoinInteraction
+      );
+      logger7.success("Slash command test completed successfully.");
+    } catch (error) {
+      throw new Error(`Error in slash commands test: ${error}`);
+    }
+  }
+  /**
+   * Asynchronously tests the leave voice channel slash command.
+   *
+   * @param {IAgentRuntime} runtime - The Agent Runtime instance.
+   * @returns {Promise<void>} A promise that resolves when the test is complete.
+   */
+  async testLeaveVoiceSlashCommand(runtime) {
+    try {
+      await this.waitForVoiceManagerReady(this.discordClient);
+      const channel = await this.getTestChannel(runtime);
+      if (!channel || !channel.isTextBased()) {
+        throw new Error("Invalid test channel for slash command test.");
+      }
+      const fakeLeaveInteraction = {
+        isCommand: () => true,
+        commandName: "leavechannel",
+        guildId: channel.guildId,
+        reply: async (message) => {
+          logger7.info(`LeaveChannel Slash Command Response: ${message}`);
+        }
+      };
+      await this.discordClient.voiceManager.handleLeaveChannelCommand(
+        fakeLeaveInteraction
+      );
+      logger7.success("Slash command test completed successfully.");
+    } catch (error) {
+      throw new Error(`Error in slash commands test: ${error}`);
     }
   }
-  async handleReactionAdd(reaction, user) {
+  /**
+   * Test Text to Speech playback.
+   * @param {IAgentRuntime} runtime - The Agent Runtime instance.
+   * @throws {Error} - If voice channel is invalid, voice connection fails to become ready, or no text to speech service found.
+   */
+  async testTextToSpeechPlayback(runtime) {
     try {
-      logger7.log("Reaction added");
-      if (!reaction || !user) {
-        logger7.warn("Invalid reaction or user");
-        return;
+      await this.waitForVoiceManagerReady(this.discordClient);
+      const channel = await this.getTestChannel(runtime);
+      if (!channel || channel.type !== ChannelType10.GuildVoice) {
+        throw new Error("Invalid voice channel.");
       }
-      let emoji = reaction.emoji.name;
-      if (!emoji && reaction.emoji.id) {
-        emoji = `<:${reaction.emoji.name}:${reaction.emoji.id}>`;
+      await this.discordClient.voiceManager.joinChannel(channel);
+      const guild = await this.getActiveGuild(this.discordClient);
+      const guildId = guild.id;
+      const connection = this.discordClient.voiceManager.getVoiceConnection(guildId);
+      try {
+        await entersState2(connection, VoiceConnectionStatus2.Ready, 1e4);
+        logger7.success(`Voice connection is ready in guild: ${guildId}`);
+      } catch (error) {
+        throw new Error(`Voice connection failed to become ready: ${error}`);
       }
-      if (reaction.partial) {
-        try {
-          await reaction.fetch();
-        } catch (error) {
-          logger7.error("Failed to fetch partial reaction:", error);
-          return;
-        }
+      let responseStream = null;
+      try {
+        responseStream = await runtime.useModel(
+          ModelTypes9.TEXT_TO_SPEECH,
+          `Hi! I'm ${runtime.character.name}! How are you doing today?`
+        );
+      } catch (_error) {
+        throw new Error("No text to speech service found");
       }
-      const timestamp = Date.now();
-      const roomId = createUniqueUuid6(
-        this.runtime,
-        reaction.message.channel.id
-      );
-      const entityId = createUniqueUuid6(this.runtime, user.id);
-      const reactionUUID = createUniqueUuid6(
-        this.runtime,
-        `${reaction.message.id}-${user.id}-${emoji}-${timestamp}`
-      );
-      if (!entityId || !roomId) {
-        logger7.error("Invalid user ID or room ID", {
-          entityId,
-          roomId
-        });
-        return;
+      if (!responseStream) {
+        throw new Error("TTS response stream is null or undefined.");
       }
-      const messageContent = reaction.message.content || "";
-      const truncatedContent = messageContent.length > 50 ? `${messageContent.substring(0, 50)}...` : messageContent;
-      const reactionMessage = `*Added <${emoji}> to: "${truncatedContent}"*`;
-      const userName = reaction.message.author?.username || "unknown";
-      const name = reaction.message.author?.displayName || userName;
-      await this.runtime.ensureConnection({
-        entityId,
-        roomId,
-        userName,
-        name,
-        source: "discord",
-        channelId: reaction.message.channel.id,
-        serverId: reaction.message.guild?.id,
-        type: await this.getChannelType(reaction.message.channel)
-      });
-      const inReplyTo = createUniqueUuid6(this.runtime, reaction.message.id);
-      const memory = {
-        id: reactionUUID,
-        entityId,
-        agentId: this.runtime.agentId,
-        content: {
-          // name,
-          // userName,
-          text: reactionMessage,
-          source: "discord",
-          inReplyTo,
-          channelType: await this.getChannelType(
-            reaction.message.channel
-          )
+      await this.playAudioStream(responseStream, connection);
+    } catch (error) {
+      throw new Error(`Error in TTS playback test: ${error}`);
+    }
+  }
+  /**
+   * Asynchronously tests sending a text message to a specified channel.
+   *
+   * @param {IAgentRuntime} runtime - The runtime for the agent.
+   * @returns {Promise<void>} A Promise that resolves when the message is sent successfully.
+   * @throws {Error} If there is an error in sending the text message.
+   */
+  async testSendingTextMessage(runtime) {
+    try {
+      const channel = await this.getTestChannel(runtime);
+      await this.sendMessageToChannel(
+        channel,
+        "Testing Message",
+        [TEST_IMAGE_URL]
+      );
+    } catch (error) {
+      throw new Error(`Error in sending text message: ${error}`);
+    }
+  }
+  /**
+   * Asynchronously handles sending a test message using the given runtime and mock user data.
+   *
+   * @param {IAgentRuntime} runtime - The agent runtime object.
+   * @returns {Promise<void>} A Promise that resolves once the message is handled.
+   */
+  async testHandlingMessage(runtime) {
+    try {
+      const channel = await this.getTestChannel(runtime);
+      const fakeMessage = {
+        content: `Hello, ${runtime.character.name}! How are you?`,
+        author: {
+          id: "mock-user-id",
+          username: "MockUser",
+          bot: false
         },
-        roomId,
-        createdAt: timestamp
-      };
-      const callback = async (content) => {
-        if (!reaction.message.channel) {
-          logger7.error("No channel found for reaction message");
-          return;
-        }
-        await reaction.message.channel.send(content.text);
-        return [];
+        channel,
+        id: "mock-message-id",
+        createdTimestamp: Date.now(),
+        mentions: {
+          has: () => false
+        },
+        reference: null,
+        attachments: []
       };
-      this.runtime.emitEvent(
-        ["DISCORD_REACTION_RECEIVED", "REACTION_RECEIVED"],
-        {
-          runtime: this.runtime,
-          message: memory,
-          callback
-        }
-      );
+      await this.discordClient.messageManager.handleMessage(fakeMessage);
     } catch (error) {
-      logger7.error("Error handling reaction:", error);
+      throw new Error(`Error in sending text message: ${error}`);
     }
   }
-  async handleReactionRemove(reaction, user) {
+  // #############################
+  //     Utility Functions
+  // #############################
+  /**
+   * Asynchronously retrieves the test channel associated with the provided runtime.
+   *
+   * @param {IAgentRuntime} runtime - The runtime object containing necessary information.
+   * @returns {Promise<Channel>} The test channel retrieved from the Discord client.
+   * @throws {Error} If no test channel is found.
+   */
+  async getTestChannel(runtime) {
+    const channelId = this.validateChannelId(runtime);
+    const channel = await this.discordClient.client.channels.fetch(channelId);
+    if (!channel) throw new Error("no test channel found!");
+    return channel;
+  }
+  /**
+   * Async function to send a message to a text-based channel.
+   *
+   * @param {TextChannel} channel - The text-based channel the message is being sent to.
+   * @param {string} messageContent - The content of the message being sent.
+   * @param {any[]} files - An array of files to include in the message.
+   * @throws {Error} If the channel is not a text-based channel or does not exist.
+   * @throws {Error} If there is an error sending the message.
+   */
+  async sendMessageToChannel(channel, messageContent, files) {
     try {
-      logger7.log("Reaction removed");
-      let emoji = reaction.emoji.name;
-      if (!emoji && reaction.emoji.id) {
-        emoji = `<:${reaction.emoji.name}:${reaction.emoji.id}>`;
-      }
-      if (reaction.partial) {
-        try {
-          await reaction.fetch();
-        } catch (error) {
-          logger7.error(
-            "Something went wrong when fetching the message:",
-            error
-          );
-          return;
-        }
+      if (!channel || !channel.isTextBased()) {
+        throw new Error(
+          "Channel is not a text-based channel or does not exist."
+        );
       }
-      const messageContent = reaction.message.content || "";
-      const truncatedContent = messageContent.length > 50 ? `${messageContent.substring(0, 50)}...` : messageContent;
-      const reactionMessage = `*Removed <${emoji}> from: "${truncatedContent}"*`;
-      const roomId = createUniqueUuid6(
-        this.runtime,
-        reaction.message.channel.id
-      );
-      const entityId = createUniqueUuid6(this.runtime, user.id);
-      const timestamp = Date.now();
-      const reactionUUID = createUniqueUuid6(
-        this.runtime,
-        `${reaction.message.id}-${user.id}-${emoji}-${timestamp}`
+      await sendMessageInChunks(
+        channel,
+        messageContent,
+        null,
+        files
       );
-      const userName = reaction.message.author?.username || "unknown";
-      const name = reaction.message.author?.displayName || userName;
-      await this.runtime.ensureConnection({
-        entityId,
-        roomId,
-        userName,
-        name,
-        source: "discord",
-        channelId: reaction.message.channel.id,
-        serverId: reaction.message.guild?.id,
-        type: await this.getChannelType(reaction.message.channel)
+    } catch (error) {
+      throw new Error(`Error sending message: ${error}`);
+    }
+  }
+  /**
+   * Play an audio stream from a given response stream using the provided VoiceConnection.
+   *
+   * @param {any} responseStream - The response stream to play as audio.
+   * @param {VoiceConnection} connection - The VoiceConnection to use for playing the audio.
+   * @returns {Promise<void>} - A Promise that resolves when the TTS playback is finished.
+   */
+  async playAudioStream(responseStream, connection) {
+    const audioPlayer = createAudioPlayer2({
+      behaviors: {
+        noSubscriber: NoSubscriberBehavior2.Pause
+      }
+    });
+    const audioResource = createAudioResource2(responseStream);
+    audioPlayer.play(audioResource);
+    connection.subscribe(audioPlayer);
+    logger7.success("TTS playback started successfully.");
+    await new Promise((resolve, reject) => {
+      audioPlayer.once(AudioPlayerStatus.Idle, () => {
+        logger7.info("TTS playback finished.");
+        resolve();
       });
-      const memory = {
-        id: reactionUUID,
-        entityId,
-        agentId: this.runtime.agentId,
-        content: {
-          // name,
-          // userName,
-          text: reactionMessage,
-          source: "discord",
-          inReplyTo: createUniqueUuid6(this.runtime, reaction.message.id),
-          channelType: await this.getChannelType(
-            reaction.message.channel
-          )
-        },
-        roomId,
-        createdAt: Date.now()
-      };
-      const callback = async (content) => {
-        if (!reaction.message.channel) {
-          logger7.error("No channel found for reaction message");
-          return;
-        }
-        await reaction.message.channel.send(content.text);
-        return [];
-      };
-      this.runtime.emitEvent(["DISCORD_REACTION_EVENT", "REACTION_RECEIVED"], {
-        runtime: this.runtime,
-        message: memory,
-        callback
+      audioPlayer.once("error", (error) => {
+        reject(error);
+        throw new Error(`TTS playback error: ${error}`);
       });
-    } catch (error) {
-      logger7.error("Error handling reaction removal:", error);
-    }
-  }
-  async handleGuildCreate(guild) {
-    logger7.log(`Joined guild ${guild.name}`);
-    const fullGuild = await guild.fetch();
-    this.voiceManager.scanGuild(guild);
-    const ownerId = createUniqueUuid6(this.runtime, fullGuild.ownerId);
-    const worldId = createUniqueUuid6(this.runtime, fullGuild.id);
-    const standardizedData = {
-      runtime: this.runtime,
-      rooms: await this.buildStandardizedRooms(fullGuild, worldId),
-      users: await this.buildStandardizedUsers(fullGuild),
-      world: {
-        id: worldId,
-        name: fullGuild.name,
-        agentId: this.runtime.agentId,
-        serverId: fullGuild.id,
-        metadata: {
-          ownership: fullGuild.ownerId ? { ownerId } : void 0,
-          roles: {
-            [ownerId]: Role.OWNER
-          }
-        }
-      },
-      source: "discord"
-    };
-    this.runtime.emitEvent(["DISCORD_SERVER_JOINED"], {
-      runtime: this.runtime,
-      server: fullGuild,
-      source: "discord"
     });
-    this.runtime.emitEvent(["SERVER_JOINED"], standardizedData);
   }
-  async handleInteractionCreate(interaction) {
-    if (!interaction.isCommand()) return;
-    switch (interaction.commandName) {
-      case "joinchannel":
-        await this.voiceManager.handleJoinChannelCommand(interaction);
-        break;
-      case "leavechannel":
-        await this.voiceManager.handleLeaveChannelCommand(interaction);
-        break;
+  /**
+   * Retrieves the active guild where the bot is currently connected to a voice channel.
+   *
+   * @param {DiscordService} discordClient The DiscordService instance used to interact with the Discord API.
+   * @returns {Promise<Guild>} The active guild where the bot is currently connected to a voice channel.
+   * @throws {Error} If no active voice connection is found for the bot.
+   */
+  async getActiveGuild(discordClient) {
+    const guilds = await discordClient.client.guilds.fetch();
+    const fullGuilds = await Promise.all(guilds.map((guild) => guild.fetch()));
+    const activeGuild = fullGuilds.find((g) => g.members.me?.voice.channelId);
+    if (!activeGuild) {
+      throw new Error("No active voice connection found for the bot.");
     }
+    return activeGuild;
   }
   /**
-   * Builds a standardized list of rooms from Discord guild channels
+   * Waits for the VoiceManager in the Discord client to be ready.
+   *
+   * @param {DiscordService} discordClient - The Discord client to check for VoiceManager readiness.
+   * @throws {Error} If the Discord client is not initialized.
+   * @returns {Promise<void>} A promise that resolves when the VoiceManager is ready.
    */
-  async buildStandardizedRooms(guild, _worldId) {
-    const rooms = [];
-    for (const [channelId, channel] of guild.channels.cache) {
-      if (channel.type === DiscordChannelType4.GuildText || channel.type === DiscordChannelType4.GuildVoice) {
-        const roomId = createUniqueUuid6(this.runtime, channelId);
-        let channelType;
-        switch (channel.type) {
-          case DiscordChannelType4.GuildText:
-            channelType = ChannelType10.GROUP;
-            break;
-          case DiscordChannelType4.GuildVoice:
-            channelType = ChannelType10.VOICE_GROUP;
-            break;
-          default:
-            channelType = ChannelType10.GROUP;
-        }
-        let participants = [];
-        if (guild.memberCount < 1e3 && channel.type === DiscordChannelType4.GuildText) {
-          try {
-            participants = Array.from(guild.members.cache.values()).filter(
-              (member) => channel.permissionsFor(member)?.has(PermissionsBitField2.Flags.ViewChannel)
-            ).map((member) => createUniqueUuid6(this.runtime, member.id));
-          } catch (error) {
-            logger7.warn(
-              `Failed to get participants for channel ${channel.name}:`,
-              error
-            );
-          }
-        }
-        rooms.push({
-          id: roomId,
-          name: channel.name,
-          type: channelType,
-          channelId: channel.id,
-          participants
-        });
-      }
+  async waitForVoiceManagerReady(discordClient) {
+    if (!discordClient) {
+      throw new Error("Discord client is not initialized.");
+    }
+    if (!discordClient.voiceManager.isReady()) {
+      await new Promise((resolve, reject) => {
+        discordClient.voiceManager.once("ready", resolve);
+        discordClient.voiceManager.once("error", reject);
+      });
     }
-    return rooms;
   }
   /**
-   * Builds a standardized list of users from Discord guild members
+   * Validates the Discord test channel ID by checking if it is set in the runtime or environment variables.
+   * If the test channel ID is not set, an error is thrown.
+   *
+   * @param {IAgentRuntime} runtime The runtime object containing the settings and environment variables.
+   * @returns {string} The validated Discord test channel ID.
    */
-  async buildStandardizedUsers(guild) {
-    const entities = [];
-    const botId = this.client.user?.id;
-    if (guild.memberCount > 1e3) {
-      logger7.info(
-        `Using optimized user sync for large guild ${guild.name} (${guild.memberCount} members)`
+  validateChannelId(runtime) {
+    const testChannelId = runtime.getSetting("DISCORD_TEST_CHANNEL_ID") || process.env.DISCORD_TEST_CHANNEL_ID;
+    if (!testChannelId) {
+      throw new Error(
+        "DISCORD_TEST_CHANNEL_ID is not set. Please provide a valid channel ID in the environment variables."
       );
-      try {
-        for (const [, member] of guild.members.cache) {
-          const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
-          if (member.id !== botId) {
-            entities.push({
-              id: createUniqueUuid6(this.runtime, member.id),
-              names: Array.from(
-                /* @__PURE__ */ new Set([
-                  member.user.username,
-                  member.displayName,
-                  member.user.globalName
-                ])
-              ),
-              agentId: this.runtime.agentId,
-              metadata: {
-                default: {
-                  username: tag,
-                  name: member.displayName || member.user.username
-                },
-                discord: member.user.globalName ? {
-                  username: tag,
-                  name: member.displayName || member.user.username,
-                  globalName: member.user.globalName,
-                  userId: member.id
-                } : {
-                  username: tag,
-                  name: member.displayName || member.user.username,
-                  userId: member.id
-                }
-              }
-            });
-          }
-        }
-        if (entities.length < 100) {
-          logger7.info(`Adding online members for ${guild.name}`);
-          const onlineMembers = await guild.members.fetch({ limit: 100 });
-          for (const [, member] of onlineMembers) {
-            if (member.id !== botId) {
-              const entityId = createUniqueUuid6(this.runtime, member.id);
-              if (!entities.some((u) => u.id === entityId)) {
-                const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
-                entities.push({
-                  id: entityId,
-                  names: Array.from(
-                    /* @__PURE__ */ new Set([
-                      member.user.username,
-                      member.displayName,
-                      member.user.globalName
-                    ])
-                  ),
-                  agentId: this.runtime.agentId,
-                  metadata: {
-                    default: {
-                      username: tag,
-                      name: member.displayName || member.user.username
-                    },
-                    discord: member.user.globalName ? {
-                      username: tag,
-                      name: member.displayName || member.user.username,
-                      globalName: member.user.globalName,
-                      userId: member.id
-                    } : {
-                      username: tag,
-                      name: member.displayName || member.user.username,
-                      userId: member.id
-                    }
-                  }
-                });
-              }
-            }
-          }
-        }
-      } catch (error) {
-        logger7.error(`Error fetching members for ${guild.name}:`, error);
-      }
-    } else {
-      try {
-        let members = guild.members.cache;
-        if (members.size === 0) {
-          members = await guild.members.fetch();
-        }
-        for (const [, member] of members) {
-          if (member.id !== botId) {
-            const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
-            entities.push({
-              id: createUniqueUuid6(this.runtime, member.id),
-              names: Array.from(
-                /* @__PURE__ */ new Set([
-                  member.user.username,
-                  member.displayName,
-                  member.user.globalName
-                ])
-              ),
-              agentId: this.runtime.agentId,
-              metadata: {
-                default: {
-                  username: tag,
-                  name: member.displayName || member.user.username
-                },
-                discord: member.user.globalName ? {
-                  username: tag,
-                  name: member.displayName || member.user.username,
-                  globalName: member.user.globalName,
-                  userId: member.id
-                } : {
-                  username: tag,
-                  name: member.displayName || member.user.username,
-                  userId: member.id
-                }
-              }
-            });
-          }
-        }
-      } catch (error) {
-        logger7.error(`Error fetching members for ${guild.name}:`, error);
-      }
-    }
-    return entities;
-  }
-  async onReady() {
-    logger7.log("DISCORD ON READY");
-    const guilds = await this.client.guilds.fetch();
-    for (const [, guild] of guilds) {
-      const fullGuild = await guild.fetch();
-      await this.voiceManager.scanGuild(fullGuild);
-      setTimeout(async () => {
-        const fullGuild2 = await guild.fetch();
-        logger7.log("DISCORD SERVER CONNECTED", fullGuild2.name);
-        this.runtime.emitEvent(["DISCORD_SERVER_CONNECTED"], {
-          runtime: this.runtime,
-          server: fullGuild2,
-          source: "discord"
-        });
-        const worldId = createUniqueUuid6(this.runtime, fullGuild2.id);
-        const ownerId = createUniqueUuid6(this.runtime, fullGuild2.ownerId);
-        const standardizedData = {
-          name: fullGuild2.name,
-          runtime: this.runtime,
-          rooms: await this.buildStandardizedRooms(fullGuild2, worldId),
-          users: await this.buildStandardizedUsers(fullGuild2),
-          world: {
-            id: worldId,
-            name: fullGuild2.name,
-            agentId: this.runtime.agentId,
-            serverId: fullGuild2.id,
-            metadata: {
-              ownership: fullGuild2.ownerId ? { ownerId } : void 0,
-              roles: {
-                [ownerId]: Role.OWNER
-              }
-            }
-          },
-          source: "discord"
-        };
-        this.runtime.emitEvent(["SERVER_CONNECTED"], standardizedData);
-      }, 1e3);
     }
-    this.client.emit("voiceManagerReady");
+    return testChannelId;
   }
 };
+
+// src/index.ts
 var discordPlugin = {
   name: "discord",
   description: "Discord client plugin",
   services: [DiscordService],
   actions: [
     chatWithAttachments_default,
-    downloadMedia_default,
-    voiceJoin_default,
-    voiceLeave_default,
-    summarizeConversation_default,
-    transcribeMedia_default
+    downloadMedia,
+    joinVoice,
+    leaveVoice,
+    summarize,
+    transcribeMedia
   ],
-  providers: [channelState_default, voiceState_default],
-  tests: [new DiscordTestSuite()]
+  providers: [channelStateProvider, voiceStateProvider],
+  tests: [new DiscordTestSuite()],
+  init: async (config, runtime) => {
+    const token = runtime.getSetting("DISCORD_API_TOKEN");
+    if (!token || token.trim() === "") {
+      logger8.warn(
+        "Discord API Token not provided - Discord plugin is loaded but will not be functional"
+      );
+      logger8.warn(
+        "To enable Discord functionality, please provide DISCORD_API_TOKEN in your .eliza/.env file"
+      );
+    }
+  }
 };
 var index_default = discordPlugin;
 export {
-  DiscordService,
   index_default as default
 };
 //# sourceMappingURL=index.js.map