@elizaos/plugin-discord 1.0.0-beta.8 → 1.0.3

package/dist/index.js

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/index.ts
 import { logger as logger8 } from "@elizaos/core";
 
@@ -134,14 +141,21 @@ var chatWithAttachments = {
       return;
     }
     const { objective, attachmentIds } = attachmentData;
-    const attachments = state.data.recentMessages.filter((msg) => msg.content.attachments && msg.content.attachments.length > 0).flatMap((msg) => msg.content.attachments).filter(
-      (attachment) => attachmentIds.map((attch) => attch.toLowerCase().slice(0, 5)).includes(attachment.id.toLowerCase().slice(0, 5)) || // or check the other way
+    const conversationLength = runtime.getConversationLength();
+    const recentMessages = await runtime.getMemories({
+      tableName: "messages",
+      roomId: message.roomId,
+      count: conversationLength,
+      unique: false
+    });
+    const attachments = recentMessages.filter((msg) => msg.content.attachments && msg.content.attachments.length > 0).flatMap((msg) => msg.content.attachments).filter(
+      (attachment) => attachment && (attachmentIds.map((attch) => attch.toLowerCase().slice(0, 5)).includes(attachment.id.toLowerCase().slice(0, 5)) || // or check the other way
       attachmentIds.some((id) => {
         const attachmentId = id.toLowerCase().slice(0, 5);
-        return attachment.id.toLowerCase().includes(attachmentId);
-      })
+        return attachment && attachment.id.toLowerCase().includes(attachmentId);
+      }))
     );
-    const attachmentsWithText = attachments.map((attachment) => `# ${attachment.title}
+    const attachmentsWithText = attachments.filter((attachment) => !!attachment).map((attachment) => `# ${attachment.title}
 ${attachment.text}`).join("\n\n");
     let currentSummary = "";
     const chunkSize = 8192;
@@ -328,6 +342,10 @@ var downloadMedia = {
   },
   handler: async (runtime, message, state, _options, callback) => {
     const videoService = runtime.getService(ServiceType.VIDEO);
+    if (!videoService) {
+      console.error("Video service not found");
+      return;
+    }
     const mediaUrl = await getMediaUrl(runtime, message, state);
     if (!mediaUrl) {
       console.error("Couldn't get media URL from messages");
@@ -850,7 +868,14 @@ var transcribeMedia = {
       );
       return;
     }
-    const attachment = state.data.recentMessages.filter((msg) => msg.content.attachments && msg.content.attachments.length > 0).flatMap((msg) => msg.content.attachments).find((attachment2) => attachment2.id.toLowerCase() === attachmentId.toLowerCase());
+    const conversationLength = runtime.getConversationLength();
+    const recentMessages = await runtime.getMemories({
+      tableName: "messages",
+      roomId: message.roomId,
+      count: conversationLength,
+      unique: false
+    });
+    const attachment = recentMessages.filter((msg) => msg.content.attachments && msg.content.attachments.length > 0).flatMap((msg) => msg.content.attachments).find((attachment2) => attachment2?.id.toLowerCase() === attachmentId.toLowerCase());
     if (!attachment) {
       console.error(`Couldn't find attachment with ID ${attachmentId}`);
       await runtime.createMemory(
@@ -962,7 +987,7 @@ var joinVoice = {
       return false;
     }
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
-    if (room?.type !== ChannelType2.GROUP) {
+    if (room?.type !== ChannelType2.GROUP && room?.type !== ChannelType2.VOICE_GROUP) {
       return false;
     }
     const client = runtime.getService(ServiceType2.DISCORD);
@@ -975,10 +1000,11 @@ var joinVoice = {
   description: "Join a voice channel to participate in voice chat.",
   handler: async (runtime, message, state, _options, callback) => {
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
+    const messageContent = message?.content?.text?.toLowerCase() ?? "";
     if (!room) {
       throw new Error("No room found");
     }
-    if (room.type !== ChannelType2.GROUP) {
+    if (room?.type !== ChannelType2.GROUP && room?.type !== ChannelType2.VOICE_GROUP) {
       return false;
     }
     const serverId = room.serverId;
@@ -997,7 +1023,6 @@ var joinVoice = {
     );
     const targetChannel = voiceChannels.find((channel) => {
       const name = channel.name.toLowerCase();
-      const messageContent = message?.content?.text;
       const replacedName = name.replace(/[^a-z0-9 ]/g, "");
       return name.includes(messageContent) || messageContent.includes(name) || replacedName.includes(messageContent) || messageContent.includes(replacedName);
     });
@@ -1011,7 +1036,8 @@ var joinVoice = {
       (member2) => createUniqueUuid2(runtime, member2.id) === message.entityId
     );
     if (member?.voice?.channel) {
-      voiceManager.joinChannel(member?.voice?.channel);
+      const userVoiceChannel = member.voice.channel;
+      voiceManager.joinChannel(userVoiceChannel);
       await runtime.createMemory(
         {
           entityId: message.entityId,
@@ -1019,7 +1045,7 @@ var joinVoice = {
           roomId: message.roomId,
           content: {
             source: "discord",
-            thought: `I joined the voice channel ${member?.voice?.channel?.name}`,
+            thought: `I joined the voice channel ${userVoiceChannel.name}`,
             actions: ["JOIN_VOICE_STARTED"]
           },
           metadata: {
@@ -1032,10 +1058,10 @@ var joinVoice = {
         {
           entityId: message.entityId,
           agentId: message.agentId,
-          roomId: createUniqueUuid2(runtime, targetChannel.id),
+          roomId: createUniqueUuid2(runtime, userVoiceChannel.id),
           content: {
             source: "discord",
-            thought: `I joined the voice channel ${targetChannel.name}`,
+            thought: `I joined the voice channel ${userVoiceChannel.name}`,
             actions: ["JOIN_VOICE_STARTED"]
           },
           metadata: {
@@ -1084,7 +1110,7 @@ You should only respond with the name of the voice channel or none, no commentar
             roomId: message.roomId,
             content: {
               source: "discord",
-              thought: `I joined the voice channel ${member?.voice?.channel?.name}`,
+              thought: `I joined the voice channel ${targetChannel2.name}`,
               actions: ["JOIN_VOICE_STARTED"]
             },
             metadata: {
@@ -1269,7 +1295,7 @@ var leaveVoice = {
       return false;
     }
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
-    if (room?.type !== ChannelType3.GROUP) {
+    if (room?.type !== ChannelType3.GROUP && room?.type !== ChannelType3.VOICE_GROUP) {
       return false;
     }
     const isConnectedToVoice = service.client.voice.adapters.size > 0;
@@ -1281,7 +1307,7 @@ var leaveVoice = {
     if (!room) {
       throw new Error("No room found");
     }
-    if (room.type !== ChannelType3.GROUP) {
+    if (room?.type !== ChannelType3.GROUP && room?.type !== ChannelType3.VOICE_GROUP) {
       throw new Error("Not a group");
     }
     const serverId = room.serverId;
@@ -1517,7 +1543,7 @@ var channelStateProvider = {
     }
     if (message.content.source !== "discord") {
       return {
-        data: null,
+        data: {},
         values: {},
         text: ""
       };
@@ -1564,7 +1590,24 @@ var channelStateProvider = {
           text: ""
         };
       }
-      const guild = discordService.client.guilds.cache.get(serverId);
+      const guild = discordService.client?.guilds.cache.get(serverId);
+      if (!guild) {
+        console.warn(`Guild not found for serverId: ${serverId}`);
+        return {
+          data: {
+            room,
+            channelType,
+            serverId,
+            channelId
+          },
+          values: {
+            channelType,
+            serverId,
+            channelId
+          },
+          text: ""
+        };
+      }
       serverName = guild.name;
       responseText = `${agentName} is currently having a conversation in the channel \`@${channelId} in the server \`${serverName}\` (@${serverId})`;
       responseText += `
@@ -1729,10 +1772,7 @@ import {
 import fs3 from "node:fs";
 import { trimTokens as trimTokens3 } from "@elizaos/core";
 import { parseJSONObjectFromText as parseJSONObjectFromText5 } from "@elizaos/core";
-import {
-  ModelType as ModelType6,
-  ServiceType as ServiceType3
-} from "@elizaos/core";
+import { ModelType as ModelType6, ServiceType as ServiceType3 } from "@elizaos/core";
 import { Collection } from "discord.js";
 import ffmpeg from "fluent-ffmpeg";
 async function generateSummary(runtime, text) {
@@ -1814,7 +1854,7 @@ var AttachmentManager = class {
       media = await this.processAudioVideoAttachment(attachment);
     } else if (attachment.contentType?.startsWith("image/")) {
       media = await this.processImageAttachment(attachment);
-    } else if (attachment.contentType?.startsWith("video/") || this.runtime.getService(ServiceType3.VIDEO).isVideoUrl(attachment.url)) {
+    } else if (attachment.contentType?.startsWith("video/") || this.runtime.getService(ServiceType3.VIDEO)?.isVideoUrl(attachment.url)) {
       media = await this.processVideoAttachment(attachment);
     } else {
       media = await this.processGenericAttachment(attachment);
@@ -1852,7 +1892,9 @@ var AttachmentManager = class {
         text: transcription || "Audio/video content not available"
       };
     } catch (error) {
-      console.error(`Error processing audio/video attachment: ${error.message}`);
+      if (error instanceof Error) {
+        console.error(`Error processing audio/video attachment: ${error.message}`);
+      }
       return {
         id: attachment.id,
         url: attachment.url,
@@ -1907,7 +1949,11 @@ var AttachmentManager = class {
     try {
       const response = await fetch(attachment.url);
       const pdfBuffer = await response.arrayBuffer();
-      const text = await this.runtime.getService(ServiceType3.PDF).convertPdfToText(Buffer.from(pdfBuffer));
+      const pdfService = this.runtime.getService(ServiceType3.PDF);
+      if (!pdfService) {
+        throw new Error("PDF service not found");
+      }
+      const text = await pdfService.convertPdfToText(Buffer.from(pdfBuffer));
       const { title, description } = await generateSummary(this.runtime, text);
       return {
         id: attachment.id,
@@ -1918,7 +1964,9 @@ var AttachmentManager = class {
         text
       };
     } catch (error) {
-      console.error(`Error processing PDF attachment: ${error.message}`);
+      if (error instanceof Error) {
+        console.error(`Error processing PDF attachment: ${error.message}`);
+      }
       return {
         id: attachment.id,
         url: attachment.url,
@@ -1948,7 +1996,11 @@ var AttachmentManager = class {
         text
       };
     } catch (error) {
-      console.error(`Error processing plaintext attachment: ${error.message}`);
+      if (error instanceof Error) {
+        console.error(`Error processing plaintext attachment: ${error.message}`);
+      } else {
+        console.error(`An unknown error occurred during plaintext attachment processing`);
+      }
       return {
         id: attachment.id,
         url: attachment.url,
@@ -1982,7 +2034,9 @@ var AttachmentManager = class {
         text: description || "Image content not available"
       };
     } catch (error) {
-      console.error(`Error processing image attachment: ${error.message}`);
+      if (error instanceof Error) {
+        console.error(`Error processing image attachment: ${error.message}`);
+      }
       return this.createFallbackImageMedia(attachment);
     }
   }
@@ -2011,9 +2065,16 @@ var AttachmentManager = class {
   async processVideoAttachment(attachment) {
     const videoService = this.runtime.getService(ServiceType3.VIDEO);
     if (!videoService) {
-      throw new Error("Video service not found");
+      return {
+        id: attachment.id,
+        url: attachment.url,
+        title: "Video Attachment (Service Unavailable)",
+        source: "Video",
+        description: "Could not process video attachment because the required service is not available.",
+        text: "Video content not available"
+      };
     }
-    if (videoService.isVideoUrl(attachment.url)) {
+    if (typeof videoService.isVideoUrl === "function" && videoService.isVideoUrl(attachment.url)) {
       const videoInfo = await videoService.processVideo(attachment.url, this.runtime);
       return {
         id: attachment.id,
@@ -2063,25 +2124,102 @@ import {
   ThreadChannel
 } from "discord.js";
 var MAX_MESSAGE_LENGTH = 1900;
-async function sendMessageInChunks(channel, content, _inReplyTo, files) {
+async function sendMessageInChunks(channel, content, _inReplyTo, files, components) {
   const sentMessages = [];
   const messages = splitMessage(content);
   try {
     for (let i = 0; i < messages.length; i++) {
       const message = messages[i];
-      if (message.trim().length > 0 || i === messages.length - 1 && files && files.length > 0) {
+      if (message.trim().length > 0 || i === messages.length - 1 && files && files.length > 0 || components) {
         const options = {
           content: message.trim()
         };
         if (i === messages.length - 1 && files && files.length > 0) {
           options.files = files;
         }
+        if (i === messages.length - 1 && components && components.length > 0) {
+          try {
+            const safeStringify = (obj) => {
+              return JSON.stringify(
+                obj,
+                (_, value) => typeof value === "bigint" ? value.toString() : value
+              );
+            };
+            logger3.info(`Components received: ${safeStringify(components)}`);
+            if (!Array.isArray(components)) {
+              logger3.warn("Components is not an array, skipping component processing");
+            } else if (components.length > 0 && components[0] && typeof components[0].toJSON === "function") {
+              options.components = components;
+            } else {
+              const {
+                ActionRowBuilder,
+                ButtonBuilder,
+                StringSelectMenuBuilder
+              } = __require("discord.js");
+              const discordComponents = components.map((row) => {
+                if (!row || typeof row !== "object" || row.type !== 1) {
+                  logger3.warn("Invalid component row structure, skipping");
+                  return null;
+                }
+                if (row.type === 1) {
+                  const actionRow = new ActionRowBuilder();
+                  if (!Array.isArray(row.components)) {
+                    logger3.warn("Row components is not an array, skipping");
+                    return null;
+                  }
+                  const validComponents = row.components.map((comp) => {
+                    if (!comp || typeof comp !== "object") {
+                      logger3.warn("Invalid component, skipping");
+                      return null;
+                    }
+                    try {
+                      if (comp.type === 2) {
+                        return new ButtonBuilder().setCustomId(comp.custom_id).setLabel(comp.label || "").setStyle(comp.style || 1);
+                      }
+                      if (comp.type === 3) {
+                        const selectMenu = new StringSelectMenuBuilder().setCustomId(comp.custom_id).setPlaceholder(comp.placeholder || "Select an option");
+                        if (typeof comp.min_values === "number")
+                          selectMenu.setMinValues(comp.min_values);
+                        if (typeof comp.max_values === "number")
+                          selectMenu.setMaxValues(comp.max_values);
+                        if (Array.isArray(comp.options)) {
+                          selectMenu.addOptions(
+                            comp.options.map((option) => ({
+                              label: option.label,
+                              value: option.value,
+                              description: option.description
+                            }))
+                          );
+                        }
+                        return selectMenu;
+                      }
+                    } catch (err) {
+                      logger3.error(`Error creating component: ${err}`);
+                      return null;
+                    }
+                    return null;
+                  }).filter(Boolean);
+                  if (validComponents.length > 0) {
+                    actionRow.addComponents(validComponents);
+                    return actionRow;
+                  }
+                }
+                return null;
+              }).filter(Boolean);
+              if (discordComponents.length > 0) {
+                options.components = discordComponents;
+              }
+            }
+          } catch (error) {
+            logger3.error(`Error processing components: ${error}`);
+          }
+        }
         const m = await channel.send(options);
         sentMessages.push(m);
       }
     }
   } catch (error) {
-    logger3.error("Error sending message:", error);
+    logger3.error(`Error sending message: ${error}`);
   }
   return sentMessages;
 }
@@ -2190,7 +2328,7 @@ var MessageManager = class {
     if (this.runtime.character.settings?.discord?.shouldIgnoreDirectMessages && message.channel.type === DiscordChannelType2.DM) {
       return;
     }
-    if (this.runtime.character.settings?.discord?.shouldRespondOnlyToMentions && !message.mentions.users?.has(this.client.user?.id)) {
+    if (this.runtime.character.settings?.discord?.shouldRespondOnlyToMentions && (!this.client.user?.id || !message.mentions.users?.has(this.client.user.id))) {
       return;
     }
     const entityId = createUniqueUuid4(this.runtime, message.author.id);
@@ -2203,6 +2341,9 @@ var MessageManager = class {
     if (message.guild) {
       const guild = await message.guild.fetch();
       type = await this.getChannelType(message.channel);
+      if (type === null) {
+        logger4.warn("null channel type, discord message", message);
+      }
       serverId = guild.id;
     } else {
       type = ChannelType7.DM;
@@ -2216,7 +2357,9 @@ var MessageManager = class {
       source: "discord",
       channelId: message.channel.id,
       serverId,
-      type
+      type,
+      worldId: createUniqueUuid4(this.runtime, serverId ?? roomId),
+      worldName: message.guild?.name
     });
     try {
       const canSendResult = canSendMessage(message.channel);
@@ -2236,6 +2379,22 @@ var MessageManager = class {
       }
       const entityId2 = createUniqueUuid4(this.runtime, message.author.id);
       const messageId = createUniqueUuid4(this.runtime, message.id);
+      const channel = message.channel;
+      const startTyping = () => {
+        try {
+          if (channel.sendTyping) {
+            channel.sendTyping();
+          }
+        } catch (err) {
+          logger4.warn("Error sending typing indicator:", err);
+        }
+      };
+      startTyping();
+      const typingInterval = setInterval(startTyping, 8e3);
+      const typingData = {
+        interval: typingInterval,
+        cleared: false
+      };
       const newMessage = {
         id: messageId,
         entityId: entityId2,
@@ -2250,6 +2409,10 @@ var MessageManager = class {
           url: message.url,
           inReplyTo: message.reference?.messageId ? createUniqueUuid4(this.runtime, message.reference?.messageId) : void 0
         },
+        metadata: {
+          entityName: name,
+          type: "message"
+        },
         createdAt: message.createdTimestamp
       };
       const callback = async (content, files) => {
@@ -2257,37 +2420,54 @@ var MessageManager = class {
           if (message.id && !content.inReplyTo) {
             content.inReplyTo = createUniqueUuid4(this.runtime, message.id);
           }
-          const messages = await sendMessageInChunks(
-            message.channel,
-            content.text,
-            message.id,
-            files
-          );
-          const memories = [];
-          for (const m of messages) {
-            const actions = content.actions;
-            const memory = {
-              id: createUniqueUuid4(this.runtime, m.id),
-              entityId: this.runtime.agentId,
-              agentId: this.runtime.agentId,
-              content: {
-                ...content,
-                actions,
-                inReplyTo: messageId,
-                url: m.url,
-                channelType: type
-              },
-              roomId,
-              createdAt: m.createdTimestamp
-            };
-            memories.push(memory);
-          }
-          for (const m of memories) {
-            await this.runtime.createMemory(m, "messages");
+          try {
+            const messages = await sendMessageInChunks(
+              channel,
+              content.text ?? "",
+              message.id,
+              files
+            );
+            const memories = [];
+            for (const m of messages) {
+              const actions = content.actions;
+              const memory = {
+                id: createUniqueUuid4(this.runtime, m.id),
+                entityId: this.runtime.agentId,
+                agentId: this.runtime.agentId,
+                content: {
+                  ...content,
+                  actions,
+                  inReplyTo: messageId,
+                  url: m.url,
+                  channelType: type
+                },
+                roomId,
+                createdAt: m.createdTimestamp
+              };
+              memories.push(memory);
+            }
+            for (const m of memories) {
+              await this.runtime.createMemory(m, "messages");
+            }
+            if (typingData.interval && !typingData.cleared) {
+              clearInterval(typingData.interval);
+              typingData.cleared = true;
+            }
+            return memories;
+          } catch (error) {
+            console.error("Error sending message:", error);
+            if (typingData.interval && !typingData.cleared) {
+              clearInterval(typingData.interval);
+              typingData.cleared = true;
+            }
+            return [];
           }
-          return memories;
         } catch (error) {
-          console.error("Error sending message:", error);
+          console.error("Error handling message:", error);
+          if (typingData.interval && !typingData.cleared) {
+            clearInterval(typingData.interval);
+            typingData.cleared = true;
+          }
           return [];
         }
       };
@@ -2296,6 +2476,12 @@ var MessageManager = class {
         message: newMessage,
         callback
       });
+      setTimeout(() => {
+        if (typingData.interval && !typingData.cleared) {
+          clearInterval(typingData.interval);
+          typingData.cleared = true;
+        }
+      }, 500);
     } catch (error) {
       console.error("Error handling message:", error);
     }
@@ -2342,11 +2528,8 @@ var MessageManager = class {
     const urlRegex = /(https?:\/\/[^\s]+)/g;
     const urls = processedContent.match(urlRegex) || [];
     for (const url of urls) {
-      if (this.runtime.getService(ServiceType4.VIDEO)?.isVideoUrl(url)) {
-        const videoService = this.runtime.getService(ServiceType4.VIDEO);
-        if (!videoService) {
-          throw new Error("Video service not found");
-        }
+      const videoService = this.runtime.getService(ServiceType4.VIDEO);
+      if (videoService?.isVideoUrl(url)) {
         const videoInfo = await videoService.processVideo(url, this.runtime);
         attachments.push({
           id: `youtube-${Date.now()}`,
@@ -2359,7 +2542,8 @@ var MessageManager = class {
       } else {
         const browserService = this.runtime.getService(ServiceType4.BROWSER);
         if (!browserService) {
-          throw new Error("Browser service not found");
+          logger4.warn("Browser service not found");
+          continue;
         }
         const { title, description: summary } = await browserService.getPageContent(
           url,
@@ -2548,9 +2732,17 @@ var VoiceManager = class extends EventEmitter {
     super();
     this.client = service.client;
     this.runtime = runtime;
-    this.client.on("voiceManagerReady", () => {
-      this.setReady(true);
-    });
+    this.ready = false;
+    if (this.client) {
+      this.client.on("voiceManagerReady", () => {
+        this.setReady(true);
+      });
+    } else {
+      logger5.error(
+        "Discord client is not available in VoiceManager constructor for voiceManagerReady event"
+      );
+      this.ready = false;
+    }
   }
   /**
    * Asynchronously retrieves the type of the channel.
@@ -2562,6 +2754,11 @@ var VoiceManager = class extends EventEmitter {
       case DiscordChannelType3.GuildVoice:
       case DiscordChannelType3.GuildStageVoice:
         return ChannelType8.VOICE_GROUP;
+      default:
+        logger5.error(
+          `getChannelType received unexpected channel type: ${channel.type} for channel ${channel.id}`
+        );
+        throw new Error(`Unexpected channel type encountered: ${channel.type}`);
     }
   }
   /**
@@ -2592,7 +2789,7 @@ var VoiceManager = class extends EventEmitter {
     const newChannelId = newState.channelId;
     const member = newState.member;
     if (!member) return;
-    if (member.id === this.client.user?.id) {
+    if (member.id === this.client?.user?.id) {
       return;
     }
     if (oldChannelId === newChannelId) {
@@ -2626,7 +2823,7 @@ var VoiceManager = class extends EventEmitter {
       adapterCreator: channel.guild.voiceAdapterCreator,
       selfDeaf: false,
       selfMute: false,
-      group: this.client.user.id
+      group: this.client?.user?.id ?? "default-group"
     });
     try {
       await Promise.race([
@@ -2702,7 +2899,12 @@ var VoiceManager = class extends EventEmitter {
    * @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);
+    const userId = this.client?.user?.id;
+    if (!userId) {
+      logger5.error("Client user ID is not available.");
+      return void 0;
+    }
+    const connections = getVoiceConnections(userId);
     if (!connections) {
       return;
     }
@@ -2727,6 +2929,7 @@ var VoiceManager = class extends EventEmitter {
       emitClose: true
     });
     if (!receiveStream || receiveStream.readableLength === 0) {
+      logger5.warn(`[monitorMember] No receiveStream or empty stream for user ${entityId}`);
       return;
     }
     const opusDecoder = new prism.opus.Decoder({
@@ -2755,7 +2958,11 @@ var VoiceManager = class extends EventEmitter {
     });
     pipeline(receiveStream, opusDecoder, (err) => {
       if (err) {
-        logger5.debug(`Opus decoding pipeline error: ${err}`);
+        logger5.debug(`[monitorMember] Opus decoding pipeline error for user ${entityId}: ${err}`);
+      } else {
+        logger5.debug(
+          `[monitorMember] Opus decoding pipeline finished successfully for user ${entityId}`
+        );
       }
     });
     this.streams.set(entityId, opusDecoder);
@@ -2780,7 +2987,7 @@ var VoiceManager = class extends EventEmitter {
     opusDecoder.on("error", errorHandler);
     opusDecoder.on("close", closeHandler);
     receiveStream?.on("close", streamCloseHandler);
-    this.client.emit("userStream", entityId, name, userName, channel, opusDecoder);
+    this.client?.emit("userStream", entityId, name, userName, channel, opusDecoder);
   }
   /**
    * Leaves the specified voice channel and stops monitoring all members in that channel.
@@ -2795,7 +3002,7 @@ var VoiceManager = class extends EventEmitter {
       this.connections.delete(channel.id);
     }
     for (const [memberId, monitorInfo] of this.activeMonitors) {
-      if (monitorInfo.channel.id === channel.id && memberId !== this.client.user?.id) {
+      if (monitorInfo.channel.id === channel.id && memberId !== this.client?.user?.id) {
         this.stopMonitoringMember(memberId);
       }
     }
@@ -2830,8 +3037,10 @@ var VoiceManager = class extends EventEmitter {
     }
     if (this.activeAudioPlayer || this.processingVoice) {
       const state = this.userStates.get(entityId);
-      state.buffers.length = 0;
-      state.totalLength = 0;
+      if (state) {
+        state.buffers.length = 0;
+        state.totalLength = 0;
+      }
       return;
     }
     if (this.transcriptionTimeout) {
@@ -2911,17 +3120,18 @@ var VoiceManager = class extends EventEmitter {
     const state = this.userStates.get(entityId);
     if (!state || state.buffers.length === 0) return;
     try {
-      let isValidTranscription = function(text) {
+      let isValidTranscription2 = function(text) {
         if (!text || text.includes("[BLANK_AUDIO]")) return false;
         return true;
       };
+      var isValidTranscription = isValidTranscription2;
       const inputBuffer = Buffer.concat(state.buffers, state.totalLength);
       state.buffers.length = 0;
       state.totalLength = 0;
       const wavBuffer = await this.convertOpusToWav(inputBuffer);
       logger5.debug("Starting transcription...");
       const transcriptionText = await this.runtime.useModel(ModelType8.TRANSCRIPTION, wavBuffer);
-      if (transcriptionText && isValidTranscription(transcriptionText)) {
+      if (transcriptionText && isValidTranscription2(transcriptionText)) {
         state.transcriptionText += transcriptionText;
       }
       if (state.transcriptionText.length) {
@@ -2961,7 +3171,9 @@ var VoiceManager = class extends EventEmitter {
         source: "discord",
         channelId,
         serverId: channel.guild.id,
-        type
+        type,
+        worldId: createUniqueUuid5(this.runtime, channel.guild.id),
+        worldName: channel.guild.name
       });
       const memory = {
         id: createUniqueUuid5(this.runtime, `${channelId}-voice-message-${Date.now()}`),
@@ -3185,6 +3397,13 @@ var DiscordService = class _DiscordService extends Service {
   character;
   messageManager;
   voiceManager;
+  userSelections = /* @__PURE__ */ new Map();
+  timeouts = [];
+  /**
+   * List of allowed channel IDs (parsed from CHANNEL_IDS env var).
+   * If undefined, all channels are allowed.
+   */
+  allowedChannelIds;
   /**
    * Constructor for Discord client.
    * Initializes the Discord client with specified intents and partials,
@@ -3194,6 +3413,11 @@ var DiscordService = class _DiscordService extends Service {
    */
   constructor(runtime) {
     super(runtime);
+    this.character = runtime.character;
+    const channelIdsRaw = runtime.getSetting("CHANNEL_IDS");
+    if (channelIdsRaw && channelIdsRaw.trim()) {
+      this.allowedChannelIds = channelIdsRaw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    }
     const token = runtime.getSetting("DISCORD_API_TOKEN");
     if (!token || token.trim() === "") {
       logger6.warn("Discord API Token not provided - Discord functionality will be unavailable");
@@ -3219,19 +3443,135 @@ var DiscordService = class _DiscordService extends Service {
       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.once(Events.ClientReady, this.onReady.bind(this));
       this.client.login(token).catch((error) => {
-        logger6.error(`Failed to login to Discord: ${error.message}`);
+        logger6.error(
+          `Failed to login to Discord: ${error instanceof Error ? error.message : String(error)}`
+        );
         this.client = null;
       });
       this.setupEventListeners();
+      this.registerSendHandler();
     } catch (error) {
-      logger6.error(`Error initializing Discord client: ${error.message}`);
+      logger6.error(
+        `Error initializing Discord client: ${error instanceof Error ? error.message : String(error)}`
+      );
       this.client = null;
     }
   }
+  static async start(runtime) {
+    const service = new _DiscordService(runtime);
+    return service;
+  }
+  /**
+   * Registers the send handler with the runtime.
+   * @private
+   */
+  registerSendHandler() {
+    if (this.runtime) {
+      this.runtime.registerSendHandler("discord", this.handleSendMessage.bind(this));
+    }
+  }
+  /**
+   * The SendHandlerFunction implementation for Discord.
+   * @param {IAgentRuntime} runtime - The runtime instance.
+   * @param {TargetInfo} target - The target information for the message.
+   * @param {Content} content - The content of the message to send.
+   * @returns {Promise<void>} A promise that resolves when the message is sent or rejects on error.
+   * @throws {Error} If the client is not ready, target is invalid, or sending fails.
+   */
+  async handleSendMessage(runtime, target, content) {
+    if (!this.client?.isReady()) {
+      logger6.error("[Discord SendHandler] Client not ready.");
+      throw new Error("Discord client is not ready.");
+    }
+    if (target.channelId && this.allowedChannelIds && !this.allowedChannelIds.includes(target.channelId)) {
+      logger6.warn(
+        `[Discord SendHandler] Channel ${target.channelId} is not in allowed channels, skipping send.`
+      );
+      return;
+    }
+    let targetChannel = null;
+    try {
+      if (target.channelId) {
+        targetChannel = await this.client.channels.fetch(target.channelId);
+      } else if (target.entityId) {
+        const discordUserId = target.entityId;
+        const user = await this.client.users.fetch(discordUserId);
+        if (user) {
+          targetChannel = await user.dmChannel ?? await user.createDM();
+        }
+      } else {
+        throw new Error("Discord SendHandler requires channelId or entityId.");
+      }
+      if (!targetChannel) {
+        throw new Error(
+          `Could not find target Discord channel/DM for target: ${JSON.stringify(target)}`
+        );
+      }
+      if (targetChannel.isTextBased() && !targetChannel.isVoiceBased()) {
+        if ("send" in targetChannel && typeof targetChannel.send === "function") {
+          if (content.text) {
+            const chunks = this.splitMessage(content.text, 2e3);
+            for (const chunk of chunks) {
+              await targetChannel.send(chunk);
+            }
+          } else {
+            logger6.warn("[Discord SendHandler] No text content provided to send.");
+          }
+        } else {
+          throw new Error(`Target channel ${targetChannel.id} does not have a send method.`);
+        }
+      } else {
+        throw new Error(
+          `Target channel ${targetChannel.id} is not a valid text-based channel for sending messages.`
+        );
+      }
+    } catch (error) {
+      logger6.error(
+        `[Discord SendHandler] Error sending message: ${error instanceof Error ? error.message : String(error)}`,
+        {
+          target,
+          content
+        }
+      );
+      throw error;
+    }
+  }
+  /**
+   * Helper function to split a string into chunks of a maximum length.
+   *
+   * @param {string} text - The text to split.
+   * @param {number} maxLength - The maximum length of each chunk.
+   * @returns {string[]} An array of text chunks.
+   * @private
+   */
+  // Helper to split messages
+  splitMessage(text, maxLength) {
+    const chunks = [];
+    let currentChunk = "";
+    const lines = text.split("\n");
+    for (const line of lines) {
+      if (currentChunk.length + line.length + 1 <= maxLength) {
+        currentChunk += (currentChunk ? "\n" : "") + line;
+      } else {
+        if (currentChunk) chunks.push(currentChunk);
+        if (line.length > maxLength) {
+          for (let i = 0; i < line.length; i += maxLength) {
+            chunks.push(line.substring(i, i + maxLength));
+          }
+          currentChunk = "";
+        } else {
+          currentChunk = line;
+        }
+      }
+    }
+    if (currentChunk) chunks.push(currentChunk);
+    return chunks;
+  }
   /**
-   * Set up event listeners for the client
+   * Set up event listeners for the client.
+   * @private
    */
   setupEventListeners() {
     if (!this.client) {
@@ -3241,8 +3581,11 @@ var DiscordService = class _DiscordService extends Service {
       if (message.author.id === this.client?.user?.id || message.author.bot) {
         return;
       }
+      if (this.allowedChannelIds && !this.allowedChannelIds.includes(message.channel.id)) {
+        return;
+      }
       try {
-        this.messageManager.handleMessage(message);
+        this.messageManager?.handleMessage(message);
       } catch (error) {
         logger6.error(`Error handling message: ${error}`);
       }
@@ -3251,6 +3594,9 @@ var DiscordService = class _DiscordService extends Service {
       if (user.id === this.client?.user?.id) {
         return;
       }
+      if (this.allowedChannelIds && reaction.message.channel && !this.allowedChannelIds.includes(reaction.message.channel.id)) {
+        return;
+      }
       try {
         await this.handleReactionAdd(reaction, user);
       } catch (error) {
@@ -3261,6 +3607,9 @@ var DiscordService = class _DiscordService extends Service {
       if (user.id === this.client?.user?.id) {
         return;
       }
+      if (this.allowedChannelIds && reaction.message.channel && !this.allowedChannelIds.includes(reaction.message.channel.id)) {
+        return;
+      }
       try {
         await this.handleReactionRemove(reaction, user);
       } catch (error) {
@@ -3282,6 +3631,9 @@ var DiscordService = class _DiscordService extends Service {
       }
     });
     this.client.on("interactionCreate", async (interaction) => {
+      if (this.allowedChannelIds && interaction.channelId && !this.allowedChannelIds.includes(interaction.channelId)) {
+        return;
+      }
       try {
         await this.handleInteractionCreate(interaction);
       } catch (error) {
@@ -3290,7 +3642,7 @@ var DiscordService = class _DiscordService extends Service {
     });
     this.client.on("userStream", (entityId, name, userName, channel, opusDecoder) => {
       if (entityId !== this.client?.user?.id) {
-        this.voiceManager.handleUserStream(entityId, name, userName, channel, opusDecoder);
+        this.voiceManager?.handleUserStream(entityId, name, userName, channel, opusDecoder);
       }
     });
   }
@@ -3299,6 +3651,7 @@ var DiscordService = class _DiscordService extends Service {
    *
    * @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.
+   * @private
    */
   async handleGuildMemberAdd(member) {
     logger6.log(`New member joined: ${member.user.username}`);
@@ -3328,164 +3681,442 @@ var DiscordService = class _DiscordService extends Service {
     });
   }
   /**
-   *
-   * Start the Discord service
-   * @param {IAgentRuntime} runtime - The runtime for the agent
-   * @returns {Promise<DiscordService>} A promise that resolves to a DiscordService instance
-   *
+   * 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>} A promise that resolves when the guild creation is handled.
+   * @private
    */
-  static async start(runtime) {
-    const token = runtime.getSetting("DISCORD_API_TOKEN");
-    if (!token || token.trim() === "") {
-      throw new Error("Discord API Token not provided");
+  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([EventType2.WORLD_JOINED], standardizedData);
+  }
+  /**
+   * Handles interactions created by the user, specifically commands and message components.
+   * @param {Interaction} interaction - The interaction object received.
+   * @returns {Promise<void>} A promise that resolves when the interaction is handled.
+   * @private
+   */
+  async handleInteractionCreate(interaction) {
+    if (interaction.isCommand()) {
+      switch (interaction.commandName) {
+        case "joinchannel":
+          await this.voiceManager?.handleJoinChannelCommand(interaction);
+          break;
+        case "leavechannel":
+          await this.voiceManager?.handleLeaveChannelCommand(interaction);
+          break;
+      }
     }
-    const maxRetries = 5;
-    let retryCount = 0;
-    let lastError = null;
-    while (retryCount < maxRetries) {
+    if (interaction.isMessageComponent()) {
+      logger6.info(`Received component interaction: ${interaction.customId}`);
+      const userId = interaction.user?.id;
+      const messageId = interaction.message?.id;
+      if (!this.userSelections.has(userId)) {
+        this.userSelections.set(userId, {});
+      }
+      const userSelections = this.userSelections.get(userId);
+      if (!userSelections) {
+        logger6.error(`User selections map unexpectedly missing for user ${userId}`);
+        return;
+      }
       try {
-        const service = new _DiscordService(runtime);
-        if (!service.client) {
-          throw new Error("Failed to initialize Discord client");
+        if (interaction.isStringSelectMenu()) {
+          logger6.info(`Values selected: ${JSON.stringify(interaction.values)}`);
+          logger6.info(
+            `User ${userId} selected values for ${interaction.customId}: ${JSON.stringify(interaction.values)}`
+          );
+          userSelections[messageId] = {
+            ...userSelections[messageId],
+            [interaction.customId]: interaction.values
+          };
+          logger6.info(
+            `Current selections for message ${messageId}: ${JSON.stringify(userSelections[messageId])}`
+          );
+          await interaction.deferUpdate();
         }
-        await new Promise((resolve, reject) => {
-          const timeout = setTimeout(() => {
-            reject(new Error("Discord client ready timeout"));
-          }, 3e4);
-          service.client?.once("ready", () => {
-            clearTimeout(timeout);
-            resolve();
+        if (interaction.isButton()) {
+          logger6.info("Button interaction detected");
+          logger6.info(`Button pressed by user ${userId}: ${interaction.customId}`);
+          const formSelections = userSelections[messageId] || {};
+          logger6.info(`Form data being submitted: ${JSON.stringify(formSelections)}`);
+          this.runtime.emitEvent(["DISCORD_INTERACTION"], {
+            interaction: {
+              customId: interaction.customId,
+              componentType: interaction.componentType,
+              type: interaction.type,
+              user: userId,
+              messageId,
+              selections: formSelections
+            },
+            source: "discord"
           });
-        });
-        return service;
+          delete userSelections[messageId];
+          logger6.info(`Cleared selections for message ${messageId}`);
+          await interaction.deferUpdate();
+          await interaction.followUp({
+            content: "Form submitted successfully!",
+            ephemeral: true
+          });
+        }
       } 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));
+        logger6.error(`Error handling component interaction: ${error}`);
+        try {
+          await interaction.followUp({
+            content: "There was an error processing your interaction.",
+            ephemeral: true
+          });
+        } catch (followUpError) {
+          logger6.error(`Error sending follow-up message: ${followUpError}`);
         }
       }
     }
-    throw new Error(
-      `Discord initialization failed after ${maxRetries} attempts. Last error: ${lastError?.message}`
-    );
   }
   /**
-   * Stops the Discord client associated with the given runtime.
+   * Builds a standardized list of rooms from Discord guild channels.
    *
-   * @param {IAgentRuntime} runtime - The runtime associated with the Discord client.
-   * @returns {void}
+   * @param {Guild} guild The guild to build rooms for.
+   * @param {UUID} _worldId The ID of the world to associate with the rooms (currently unused in favor of direct channel to room mapping).
+   * @returns {Promise<any[]>} An array of standardized room objects.
+   * @private
    */
-  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);
+  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;
   }
   /**
-   * Asynchronously stops the client by destroying it.
+   * Builds a standardized list of users (entities) from Discord guild members.
+   * Implements different strategies based on guild size for performance.
    *
-   * @returns {Promise<void>}
+   * @param {Guild} guild - The guild from which to build the user list.
+   * @returns {Promise<Entity[]>} A promise that resolves with an array of standardized entity objects.
+   * @private
    */
-  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();
-  }
+  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(
+                new Set(
+                  [member.user.username, member.displayName, member.user.globalName].filter(
+                    Boolean
+                  )
+                )
+              ),
+              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(
+                    new Set(
+                      [member.user.username, member.displayName, member.user.globalName].filter(
+                        Boolean
+                      )
+                    )
+                  ),
+                  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(
+                new Set(
+                  [member.user.username, member.displayName, member.user.globalName].filter(
+                    Boolean
+                  )
+                )
+              ),
+              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;
+  }
   /**
-   * 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.
+   * Handles tasks to be performed once the Discord client is fully ready and connected.
+   * This includes fetching guilds, scanning for voice data, and emitting connection events.
+   * @private
+   * @returns {Promise<void>} A promise that resolves when all on-ready tasks are completed.
    */
-  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;
+  async onReady() {
+    logger6.log("DISCORD ON READY");
+    const guilds = await this.client?.guilds.fetch();
+    if (!guilds) {
+      logger6.warn("Could not fetch guilds, client might not be ready.");
+      return;
+    }
+    for (const [, guild] of guilds) {
+      const fullGuild = await guild.fetch();
+      await this.voiceManager?.scanGuild(fullGuild);
+      const timeoutId = setTimeout(async () => {
+        try {
+          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([EventType2.WORLD_CONNECTED], standardizedData);
+        } catch (error) {
+          logger6.error("Error during Discord world connection:", error);
+        }
+      }, 1e3);
+      this.timeouts.push(timeoutId);
     }
+    this.client?.emit("voiceManagerReady");
   }
   /**
-   * Handles the addition of a reaction on a message.
+   * Registers send handlers for the Discord service instance.
+   * This allows the runtime to correctly dispatch messages to this service.
+   * @param {IAgentRuntime} runtime - The agent runtime instance.
+   * @param {DiscordService} serviceInstance - The instance of the DiscordService.
+   * @static
+   */
+  static registerSendHandlers(runtime, serviceInstance) {
+    if (serviceInstance) {
+      runtime.registerSendHandler(
+        "discord",
+        serviceInstance.handleSendMessage.bind(serviceInstance)
+      );
+      logger6.info("[Discord] Registered send handler.");
+    }
+  }
+  /**
+   * Fetches all members who have access to a specific text channel.
    *
-   * @param {MessageReaction | PartialMessageReaction} reaction The reaction that was added.
-   * @param {User | PartialUser} user The user who added the reaction.
-   * @returns {void}
+   * @param {string} channelId - The Discord ID of the text channel.
+   * @param {boolean} [useCache=true] - Whether to prioritize cached data. Defaults to true.
+   * @returns {Promise<Array<{id: string, username: string, displayName: string}>>} A promise that resolves with an array of channel member objects, each containing id, username, and displayName.
+   */
+  async getTextChannelMembers(channelId, useCache = true) {
+    logger6.info(`Fetching members for text channel ${channelId}, useCache=${useCache}`);
+    try {
+      const channel = await this.client?.channels.fetch(channelId);
+      if (!channel) {
+        logger6.error(`Channel not found: ${channelId}`);
+        return [];
+      }
+      if (channel.type !== DiscordChannelType4.GuildText) {
+        logger6.error(`Channel ${channelId} is not a text channel`);
+        return [];
+      }
+      const guild = channel.guild;
+      if (!guild) {
+        logger6.error(`Channel ${channelId} is not in a guild`);
+        return [];
+      }
+      const useCacheOnly = useCache && guild.memberCount > 1e3;
+      let members;
+      if (useCacheOnly) {
+        logger6.info(
+          `Using cached members for large guild ${guild.name} (${guild.memberCount} members)`
+        );
+        members = guild.members.cache;
+      } else {
+        try {
+          if (useCache && guild.members.cache.size > 0) {
+            logger6.info(`Using cached members (${guild.members.cache.size} members)`);
+            members = guild.members.cache;
+          } else {
+            logger6.info(`Fetching members for guild ${guild.name}`);
+            members = await guild.members.fetch();
+            logger6.info(`Fetched ${members.size} members`);
+          }
+        } catch (error) {
+          logger6.error(`Error fetching members: ${error}`);
+          members = guild.members.cache;
+          logger6.info(`Fallback to cache with ${members.size} members`);
+        }
+      }
+      logger6.info(`Filtering members for access to channel ${channel.name}`);
+      const memberArray = Array.from(members.values());
+      const channelMembers = memberArray.filter((member) => {
+        if (member.user.bot && member.id !== this.client?.user?.id) {
+          return false;
+        }
+        return channel.permissionsFor(member)?.has(PermissionsBitField2.Flags.ViewChannel) ?? false;
+      }).map((member) => ({
+        id: member.id,
+        username: member.user.username,
+        displayName: member.displayName || member.user.username
+      }));
+      logger6.info(`Found ${channelMembers.length} members with access to channel ${channel.name}`);
+      return channelMembers;
+    } catch (error) {
+      logger6.error(`Error fetching channel members: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Placeholder for handling reaction addition.
+   * @private
    */
   async handleReactionAdd(reaction, user) {
     try {
@@ -3522,13 +4153,15 @@ var DiscordService = class _DiscordService extends Service {
       }
       const messageContent = reaction.message.content || "";
       const truncatedContent = messageContent.length > 50 ? `${messageContent.substring(0, 50)}...` : messageContent;
-      const reactionMessage = `*Added <${emoji}> to: "${truncatedContent}"*`;
+      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,
+        worldId: createUniqueUuid6(this.runtime, reaction.message.guild?.id ?? roomId),
+        worldName: reaction.message.guild?.name,
         name,
         source: "discord",
         channelId: reaction.message.channel.id,
@@ -3554,9 +4187,9 @@ var DiscordService = class _DiscordService extends Service {
       const callback = async (content) => {
         if (!reaction.message.channel) {
           logger6.error("No channel found for reaction message");
-          return;
+          return [];
         }
-        await reaction.message.channel.send(content.text);
+        await reaction.message.channel.send(content.text ?? "");
         return [];
       };
       this.runtime.emitEvent(["DISCORD_REACTION_RECEIVED", "REACTION_RECEIVED"], {
@@ -3569,11 +4202,8 @@ var DiscordService = class _DiscordService extends Service {
     }
   }
   /**
-   * 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.
+   * Placeholder for handling reaction removal.
+   * @private
    */
   async handleReactionRemove(reaction, user) {
     try {
@@ -3592,7 +4222,7 @@ var DiscordService = class _DiscordService extends Service {
       }
       const messageContent = reaction.message.content || "";
       const truncatedContent = messageContent.length > 50 ? `${messageContent.substring(0, 50)}...` : messageContent;
-      const reactionMessage = `*Removed <${emoji}> from: "${truncatedContent}"*`;
+      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();
@@ -3606,6 +4236,8 @@ var DiscordService = class _DiscordService extends Service {
         entityId,
         roomId,
         userName,
+        worldId: createUniqueUuid6(this.runtime, reaction.message.guild?.id ?? roomId),
+        worldName: reaction.message.guild?.name,
         name,
         source: "discord",
         channelId: reaction.message.channel.id,
@@ -3630,9 +4262,9 @@ var DiscordService = class _DiscordService extends Service {
       const callback = async (content) => {
         if (!reaction.message.channel) {
           logger6.error("No channel found for reaction message");
-          return;
+          return [];
         }
-        await reaction.message.channel.send(content.text);
+        await reaction.message.channel.send(content.text ?? "");
         return [];
       };
       this.runtime.emitEvent(["DISCORD_REACTION_RECEIVED" /* REACTION_RECEIVED */], {
@@ -3645,260 +4277,40 @@ var DiscordService = class _DiscordService extends Service {
     }
   }
   /**
-   * 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>}
+   * Stops the Discord service and cleans up resources.
+   * Implements the abstract method from the Service class.
    */
-  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([EventType2.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;
+  async stop() {
+    logger6.info("Stopping Discord service...");
+    this.timeouts.forEach(clearTimeout);
+    this.timeouts = [];
+    if (this.client) {
+      await this.client.destroy();
+      this.client = null;
+      logger6.info("Discord client destroyed.");
     }
-  }
-  /**
-   * 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
-        });
-      }
+    if (this.voiceManager) {
     }
-    return rooms;
+    logger6.info("Discord service stopped.");
   }
   /**
-   * Builds a standardized list of users from Discord guild members
+   * 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 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;
-  }
-  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([EventType2.WORLD_CONNECTED], standardizedData);
-      }, 1e3);
+  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;
+      default:
+        logger6.warn(`Unhandled channel type: ${channel.type}`);
+        return ChannelType9.GROUP;
     }
-    this.client?.emit("voiceManagerReady");
   }
 };
 
@@ -3912,11 +4324,12 @@ import {
   entersState as entersState2
 } from "@discordjs/voice";
 import { ModelType as ModelType9, logger as logger7 } from "@elizaos/core";
-import { ChannelType as ChannelType10, Events as Events2 } from "discord.js";
+import { ChannelType as ChannelType10, Events as Events2, AttachmentBuilder } 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;
+  discordClient;
+  // Use definite assignment assertion
   tests;
   /**
    * Constructor for initializing the tests array with test cases to be executed.
@@ -3962,13 +4375,19 @@ var DiscordTestSuite = class {
   async testCreatingDiscordClient(runtime) {
     try {
       this.discordClient = runtime.getService(ServiceType2.DISCORD);
-      if (this.discordClient.client.isReady()) {
+      if (!this.discordClient) {
+        throw new Error("Failed to get DiscordService from runtime.");
+      }
+      if (this.discordClient.client?.isReady()) {
         logger7.success("DiscordService is already ready.");
       } else {
         logger7.info("Waiting for DiscordService to be ready...");
+        if (!this.discordClient.client) {
+          throw new Error("Discord client instance is missing within the service.");
+        }
         await new Promise((resolve, reject) => {
-          this.discordClient.client.once(Events2.ClientReady, resolve);
-          this.discordClient.client.once(Events2.Error, reject);
+          this.discordClient.client?.once(Events2.ClientReady, resolve);
+          this.discordClient.client?.once(Events2.Error, reject);
         });
       }
     } catch (error) {
@@ -3983,6 +4402,7 @@ var DiscordTestSuite = class {
    * @throws {Error} - If there is an error in executing the slash command test.
    */
   async testJoinVoiceSlashCommand(runtime) {
+    if (!this.discordClient) throw new Error("Discord client not initialized.");
     try {
       await this.waitForVoiceManagerReady(this.discordClient);
       const channel = await this.getTestChannel(runtime);
@@ -4002,10 +4422,13 @@ var DiscordTestSuite = class {
           logger7.info(`JoinChannel Slash Command Response: ${message}`);
         }
       };
+      if (!this.discordClient.voiceManager) {
+        throw new Error("VoiceManager is not available on the Discord client.");
+      }
       await this.discordClient.voiceManager.handleJoinChannelCommand(fakeJoinInteraction);
-      logger7.success("Slash command test completed successfully.");
+      logger7.success("Join voice slash command test completed successfully.");
     } catch (error) {
-      throw new Error(`Error in slash commands test: ${error}`);
+      throw new Error(`Error in join voice slash commands test: ${error}`);
     }
   }
   /**
@@ -4015,6 +4438,7 @@ var DiscordTestSuite = class {
    * @returns {Promise<void>} A promise that resolves when the test is complete.
    */
   async testLeaveVoiceSlashCommand(runtime) {
+    if (!this.discordClient) throw new Error("Discord client not initialized.");
     try {
       await this.waitForVoiceManagerReady(this.discordClient);
       const channel = await this.getTestChannel(runtime);
@@ -4029,10 +4453,13 @@ var DiscordTestSuite = class {
           logger7.info(`LeaveChannel Slash Command Response: ${message}`);
         }
       };
+      if (!this.discordClient.voiceManager) {
+        throw new Error("VoiceManager is not available on the Discord client.");
+      }
       await this.discordClient.voiceManager.handleLeaveChannelCommand(fakeLeaveInteraction);
-      logger7.success("Slash command test completed successfully.");
+      logger7.success("Leave voice slash command test completed successfully.");
     } catch (error) {
-      throw new Error(`Error in slash commands test: ${error}`);
+      throw new Error(`Error in leave voice slash commands test: ${error}`);
     }
   }
   /**
@@ -4041,16 +4468,26 @@ var DiscordTestSuite = class {
    * @throws {Error} - If voice channel is invalid, voice connection fails to become ready, or no text to speech service found.
    */
   async testTextToSpeechPlayback(runtime) {
+    if (!this.discordClient) throw new Error("Discord client not initialized.");
     try {
       await this.waitForVoiceManagerReady(this.discordClient);
       const channel = await this.getTestChannel(runtime);
       if (!channel || channel.type !== ChannelType10.GuildVoice) {
         throw new Error("Invalid voice channel.");
       }
+      if (!this.discordClient.voiceManager) {
+        throw new Error("VoiceManager is not available on the Discord client.");
+      }
       await this.discordClient.voiceManager.joinChannel(channel);
       const guild = await this.getActiveGuild(this.discordClient);
       const guildId = guild.id;
+      if (!this.discordClient.voiceManager) {
+        throw new Error("VoiceManager is not available on the Discord client.");
+      }
       const connection = this.discordClient.voiceManager.getVoiceConnection(guildId);
+      if (!connection) {
+        throw new Error(`No voice connection found for guild: ${guildId}`);
+      }
       try {
         await entersState2(connection, VoiceConnectionStatus2.Ready, 1e4);
         logger7.success(`Voice connection is ready in guild: ${guildId}`);
@@ -4082,9 +4519,14 @@ var DiscordTestSuite = class {
    * @throws {Error} If there is an error in sending the text message.
    */
   async testSendingTextMessage(runtime) {
+    if (!this.discordClient) throw new Error("Discord client not initialized.");
     try {
       const channel = await this.getTestChannel(runtime);
-      await this.sendMessageToChannel(channel, "Testing Message", [TEST_IMAGE_URL]);
+      if (!channel || !channel.isTextBased()) {
+        throw new Error("Cannot send message to a non-text channel.");
+      }
+      const attachment = new AttachmentBuilder(TEST_IMAGE_URL);
+      await this.sendMessageToChannel(channel, "Testing Message", [attachment]);
     } catch (error) {
       throw new Error(`Error in sending text message: ${error}`);
     }
@@ -4096,6 +4538,7 @@ var DiscordTestSuite = class {
    * @returns {Promise<void>} A Promise that resolves once the message is handled.
    */
   async testHandlingMessage(runtime) {
+    if (!this.discordClient) throw new Error("Discord client not initialized.");
     try {
       const channel = await this.getTestChannel(runtime);
       const fakeMessage = {
@@ -4114,9 +4557,12 @@ var DiscordTestSuite = class {
         reference: null,
         attachments: []
       };
+      if (!this.discordClient.messageManager) {
+        throw new Error("MessageManager is not available on the Discord client.");
+      }
       await this.discordClient.messageManager.handleMessage(fakeMessage);
     } catch (error) {
-      throw new Error(`Error in sending text message: ${error}`);
+      throw new Error(`Error in handling message test: ${error}`);
     }
   }
   // #############################
@@ -4130,8 +4576,9 @@ var DiscordTestSuite = class {
    * @throws {Error} If no test channel is found.
    */
   async getTestChannel(runtime) {
+    if (!this.discordClient) throw new Error("Discord client not initialized.");
     const channelId = this.validateChannelId(runtime);
-    const channel = await this.discordClient.client.channels.fetch(channelId);
+    const channel = await this.discordClient.client?.channels.fetch(channelId);
     if (!channel) throw new Error("no test channel found!");
     return channel;
   }
@@ -4149,7 +4596,7 @@ var DiscordTestSuite = class {
       if (!channel || !channel.isTextBased()) {
         throw new Error("Channel is not a text-based channel or does not exist.");
       }
-      await sendMessageInChunks(channel, messageContent, null, files);
+      await sendMessageInChunks(channel, messageContent, "", files);
     } catch (error) {
       throw new Error(`Error sending message: ${error}`);
     }
@@ -4190,6 +4637,9 @@ var DiscordTestSuite = class {
    * @throws {Error} If no active voice connection is found for the bot.
    */
   async getActiveGuild(discordClient) {
+    if (!discordClient.client) {
+      throw new Error("Discord client instance is missing within the service.");
+    }
     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);
@@ -4209,10 +4659,13 @@ var DiscordTestSuite = class {
     if (!discordClient) {
       throw new Error("Discord client is not initialized.");
     }
-    if (!discordClient.voiceManager.isReady()) {
+    if (!discordClient.voiceManager) {
+      throw new Error("VoiceManager is not available on the Discord client.");
+    }
+    if (!discordClient.voiceManager?.isReady()) {
       await new Promise((resolve, reject) => {
-        discordClient.voiceManager.once("ready", resolve);
-        discordClient.voiceManager.once("error", reject);
+        discordClient.voiceManager?.once("ready", resolve);
+        discordClient.voiceManager?.once("error", reject);
       });
     }
   }