@elizaos/plugin-discord 1.0.0-alpha.31 → 1.0.0-alpha.33

package/dist/index.js

@@ -1,20 +1,7 @@
 // src/index.ts
 import {
-  ChannelType as ChannelType10,
-  EventTypes as EventTypes2,
-  Role,
-  Service,
-  createUniqueUuid as createUniqueUuid6,
-  logger as logger7
+  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";
@@ -66,7 +53,7 @@ var getAttachmentIds = async (runtime, _message, state) => {
   }
   return null;
 };
-var summarizeAction = {
+var chatWithAttachments = {
   name: "CHAT_WITH_ATTACHMENTS",
   similes: [
     "CHAT_WITH_ATTACHMENT",
@@ -298,7 +285,7 @@ ${currentSummary.trim()}
     ]
   ]
 };
-var chatWithAttachments_default = summarizeAction;
+var chatWithAttachments_default = chatWithAttachments;
 
 // src/actions/downloadMedia.ts
 import {
@@ -336,7 +323,7 @@ var getMediaUrl = async (runtime, _message, state) => {
   }
   return null;
 };
-var downloadMedia_default = {
+var downloadMedia = {
   name: "DOWNLOAD_MEDIA",
   similes: [
     "DOWNLOAD_VIDEO",
@@ -534,7 +521,7 @@ var getDateRange = async (runtime, _message, state) => {
     }
   }
 };
-var summarizeAction2 = {
+var summarize = {
   name: "SUMMARIZE_CONVERSATION",
   similes: [
     "RECAP",
@@ -782,7 +769,6 @@ ${currentSummary.trim()}
     ]
   ]
 };
-var summarizeConversation_default = summarizeAction2;
 
 // src/actions/transcribeMedia.ts
 import {
@@ -820,7 +806,7 @@ var getMediaAttachmentId = async (runtime, _message, state) => {
   }
   return null;
 };
-var transcribeMediaAction = {
+var transcribeMedia = {
   name: "TRANSCRIBE_MEDIA",
   similes: [
     "TRANSCRIBE_AUDIO",
@@ -960,7 +946,6 @@ ${mediaTranscript.trim()}
     ]
   ]
 };
-var transcribeMedia_default = transcribeMediaAction;
 
 // src/actions/voiceJoin.ts
 import {
@@ -980,7 +965,7 @@ var ServiceTypes2 = {
 };
 
 // src/actions/voiceJoin.ts
-var voiceJoin_default = {
+var joinVoice = {
   name: "JOIN_VOICE",
   similes: [
     "JOIN_VOICE",
@@ -1273,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",
@@ -1520,1279 +1505,1283 @@ var voiceLeave_default = {
   ]
 };
 
-// src/constants.ts
-var MESSAGE_CONSTANTS = {
-  MAX_MESSAGES: 10,
-  RECENT_MESSAGE_COUNT: 3,
-  CHAT_HISTORY_COUNT: 5,
-  INTEREST_DECAY_TIME: 5 * 60 * 1e3,
-  // 5 minutes
-  PARTIAL_INTEREST_DECAY: 3 * 60 * 1e3,
-  // 3 minutes
-  DEFAULT_SIMILARITY_THRESHOLD: 0.3,
-  DEFAULT_SIMILARITY_THRESHOLD_FOLLOW_UPS: 0.2
+// 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
+    };
+  }
 };
-var DISCORD_SERVICE_NAME = "discord";
 
-// src/messages.ts
+// 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/tests.ts
 import {
-  ChannelType as ChannelType5,
-  EventTypes,
-  ServiceTypes as ServiceTypes4,
-  createUniqueUuid as createUniqueUuid4,
+  AudioPlayerStatus,
+  NoSubscriberBehavior,
+  VoiceConnectionStatus,
+  createAudioPlayer,
+  createAudioResource,
+  entersState
+} from "@discordjs/voice";
+import {
+  ModelTypes as ModelTypes7,
   logger as logger4
 } from "@elizaos/core";
-import {
-  ChannelType as DiscordChannelType2
-} from "discord.js";
+import { ChannelType as ChannelType7, Events } 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";
+// src/utils.ts
 import {
   ModelTypes as ModelTypes6,
-  ServiceTypes as ServiceTypes3
+  logger as logger3,
+  parseJSONObjectFromText as parseJSONObjectFromText5,
+  trimTokens as trimTokens3
 } from "@elizaos/core";
-import { Collection } from "discord.js";
-import ffmpeg from "fluent-ffmpeg";
-async function generateSummary(runtime, text) {
-  text = await trimTokens3(text, 1e5, runtime);
-  const prompt = `Please generate a concise summary for the following text:
-
-  Text: """
-  ${text}
-  """
-
-  Respond with a JSON object in the following format:
-  \`\`\`json
-  {
-    "title": "Generated Title",
-    "summary": "Generated summary and/or description of the text"
-  }
-  \`\`\``;
-  const response = await runtime.useModel(ModelTypes6.TEXT_SMALL, {
-    prompt
-  });
-  const parsedResponse = parseJSONObjectFromText5(response);
-  if (parsedResponse?.title && parsedResponse?.summary) {
-    return {
-      title: parsedResponse.title,
-      description: parsedResponse.summary
-    };
-  }
-  return {
-    title: "",
-    description: ""
-  };
+import {
+  ChannelType as ChannelType6,
+  PermissionsBitField,
+  ThreadChannel
+} from "discord.js";
+function getWavHeader(audioLength, sampleRate, channelCount = 1, bitsPerSample = 16) {
+  const wavHeader = Buffer.alloc(44);
+  wavHeader.write("RIFF", 0);
+  wavHeader.writeUInt32LE(36 + audioLength, 4);
+  wavHeader.write("WAVE", 8);
+  wavHeader.write("fmt ", 12);
+  wavHeader.writeUInt32LE(16, 16);
+  wavHeader.writeUInt16LE(1, 20);
+  wavHeader.writeUInt16LE(channelCount, 22);
+  wavHeader.writeUInt32LE(sampleRate, 24);
+  wavHeader.writeUInt32LE(sampleRate * bitsPerSample * channelCount / 8, 28);
+  wavHeader.writeUInt16LE(bitsPerSample * channelCount / 8, 32);
+  wavHeader.writeUInt16LE(bitsPerSample, 34);
+  wavHeader.write("data", 36);
+  wavHeader.writeUInt32LE(audioLength, 40);
+  return wavHeader;
 }
-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]));
-    for (const [, attachment] of attachmentCollection) {
-      const media = await this.processAttachment(attachment);
-      if (media) {
-        processedAttachments.push(media);
+var MAX_MESSAGE_LENGTH = 1900;
+async function sendMessageInChunks(channel, content, _inReplyTo, files) {
+  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) {
+        const options = {
+          content: message.trim()
+        };
+        if (i === messages.length - 1 && files && files.length > 0) {
+          options.files = files;
+        }
+        const m = await channel.send(options);
+        sentMessages.push(m);
       }
     }
-    return processedAttachments;
+  } catch (error) {
+    logger3.error("Error sending message:", error);
+  }
+  return sentMessages;
+}
+function splitMessage(content) {
+  const messages = [];
+  let currentMessage = "";
+  const rawLines = content?.split("\n") || [];
+  const lines = rawLines.flatMap((line) => {
+    const chunks = [];
+    while (line.length > MAX_MESSAGE_LENGTH) {
+      chunks.push(line.slice(0, MAX_MESSAGE_LENGTH));
+      line = line.slice(MAX_MESSAGE_LENGTH);
+    }
+    chunks.push(line);
+    return chunks;
+  });
+  for (const line of lines) {
+    if (currentMessage.length + line.length + 1 > MAX_MESSAGE_LENGTH) {
+      messages.push(currentMessage.trim());
+      currentMessage = "";
+    }
+    currentMessage += `${line}
+`;
   }
+  if (currentMessage.trim().length > 0) {
+    messages.push(currentMessage.trim());
+  }
+  return messages;
+}
+function canSendMessage(channel) {
+  if (!channel) {
+    return {
+      canSend: false,
+      reason: "No channel given"
+    };
+  }
+  if (channel.type === ChannelType6.DM) {
+    return {
+      canSend: true,
+      reason: null
+    };
+  }
+  const botMember = channel.guild?.members.cache.get(channel.client.user.id);
+  if (!botMember) {
+    return {
+      canSend: false,
+      reason: "Not a guild channel or bot member not found"
+    };
+  }
+  const requiredPermissions = [
+    PermissionsBitField.Flags.ViewChannel,
+    PermissionsBitField.Flags.SendMessages,
+    PermissionsBitField.Flags.ReadMessageHistory
+  ];
+  if (channel instanceof ThreadChannel) {
+    requiredPermissions.push(PermissionsBitField.Flags.SendMessagesInThreads);
+  }
+  const permissions = channel.permissionsFor(botMember);
+  if (!permissions) {
+    return {
+      canSend: false,
+      reason: "Could not retrieve permissions"
+    };
+  }
+  const missingPermissions = requiredPermissions.filter(
+    (perm) => !permissions.has(perm)
+  );
+  return {
+    canSend: missingPermissions.length === 0,
+    missingPermissions,
+    reason: missingPermissions.length > 0 ? `Missing permissions: ${missingPermissions.map((p) => String(p)).join(", ")}` : null
+  };
+}
+
+// src/tests.ts
+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;
   /**
-   * 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.
+   * Constructor for initializing the tests array with test cases to be executed.
    *
-   * @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
+   * @constructor
+   * @this {TestSuite}
    */
-  async processAttachment(attachment) {
-    if (this.attachmentCache.has(attachment.url)) {
-      return this.attachmentCache.get(attachment.url);
-    }
-    let media = null;
-    if (attachment.contentType?.startsWith("application/pdf")) {
-      media = await this.processPdfAttachment(attachment);
-    } else if (attachment.contentType?.startsWith("text/plain")) {
-      media = await this.processPlaintextAttachment(attachment);
-    } else if (attachment.contentType?.startsWith("audio/") || attachment.contentType?.startsWith("video/mp4")) {
-      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(ServiceTypes3.VIDEO).isVideoUrl(attachment.url)) {
-      media = await this.processVideoAttachment(attachment);
-    } else {
-      media = await this.processGenericAttachment(attachment);
-    }
-    if (media) {
-      this.attachmentCache.set(attachment.url, media);
-    }
-    return media;
+  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)
+      }
+    ];
   }
   /**
-   * 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.
+   * 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 processAudioVideoAttachment(attachment) {
+  async testCreatingDiscordClient(runtime) {
     try {
-      const response = await fetch(attachment.url);
-      const audioVideoArrayBuffer = await response.arrayBuffer();
-      let audioBuffer;
-      if (attachment.contentType?.startsWith("audio/")) {
-        audioBuffer = Buffer.from(audioVideoArrayBuffer);
-      } else if (attachment.contentType?.startsWith("video/mp4")) {
-        audioBuffer = await this.extractAudioFromMP4(audioVideoArrayBuffer);
+      this.discordClient = runtime.getService(
+        ServiceTypes2.DISCORD
+      );
+      if (this.discordClient.client.isReady()) {
+        logger4.success("DiscordService is already ready.");
       } else {
-        throw new Error("Unsupported audio/video format");
+        logger4.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);
+        });
       }
-      const transcription = await this.runtime.useModel(
-        ModelTypes6.TRANSCRIPTION,
-        audioBuffer
-      );
-      const { title, description } = await generateSummary(
-        this.runtime,
-        transcription
-      );
-      return {
-        id: attachment.id,
-        url: attachment.url,
-        title: title || "Audio/Video Attachment",
-        source: attachment.contentType?.startsWith("audio/") ? "Audio" : "Video",
-        description: description || "User-uploaded audio/video attachment which has been transcribed",
-        text: transcription || "Audio/video content not available"
-      };
     } catch (error) {
-      console.error(
-        `Error processing audio/video attachment: ${error.message}`
-      );
-      return {
-        id: attachment.id,
-        url: attachment.url,
-        title: "Audio/Video Attachment",
-        source: attachment.contentType?.startsWith("audio/") ? "Audio" : "Video",
-        description: "An audio/video attachment (transcription failed)",
-        text: `This is an audio/video attachment. File name: ${attachment.name}, Size: ${attachment.size} bytes, Content type: ${attachment.contentType}`
-      };
+      throw new Error(`Error in test creating Discord client: ${error}`);
     }
   }
   /**
-   * Extracts the audio stream from the provided MP4 data and converts it to MP3 format.
+   * Asynchronously tests the join voice slash command functionality.
    *
-   * @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
+   * @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 extractAudioFromMP4(mp4Data) {
-    const tempMP4File = `temp_${Date.now()}.mp4`;
-    const tempAudioFile = `temp_${Date.now()}.mp3`;
+  async testJoinVoiceSlashCommand(runtime) {
     try {
-      fs3.writeFileSync(tempMP4File, Buffer.from(mp4Data));
-      await new Promise((resolve, reject) => {
-        ffmpeg(tempMP4File).outputOptions("-vn").audioCodec("libmp3lame").save(tempAudioFile).on("end", () => {
-          resolve();
-        }).on("error", (err) => {
-          reject(err);
-        }).run();
-      });
-      const audioData = fs3.readFileSync(tempAudioFile);
-      return audioData;
-    } finally {
-      if (fs3.existsSync(tempMP4File)) {
-        fs3.unlinkSync(tempMP4File);
-      }
-      if (fs3.existsSync(tempAudioFile)) {
-        fs3.unlinkSync(tempAudioFile);
+      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) => {
+          logger4.info(`JoinChannel Slash Command Response: ${message}`);
+        }
+      };
+      await this.discordClient.voiceManager.handleJoinChannelCommand(
+        fakeJoinInteraction
+      );
+      logger4.success("Slash command test completed successfully.");
+    } catch (error) {
+      throw new Error(`Error in slash commands test: ${error}`);
     }
   }
   /**
-   * 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.
+   * Asynchronously tests the leave voice channel slash command.
    *
-   * @param {Attachment} attachment - The PDF attachment to process.
-   * @returns {Promise<Media>} A promise that resolves to a Media object representing
-   * the processed PDF attachment.
+   * @param {IAgentRuntime} runtime - The Agent Runtime instance.
+   * @returns {Promise<void>} A promise that resolves when the test is complete.
    */
-  async processPdfAttachment(attachment) {
+  async testLeaveVoiceSlashCommand(runtime) {
     try {
-      const response = await fetch(attachment.url);
-      const pdfBuffer = await response.arrayBuffer();
-      const text = await this.runtime.getService(ServiceTypes3.PDF).convertPdfToText(Buffer.from(pdfBuffer));
-      const { title, description } = await generateSummary(this.runtime, text);
-      return {
-        id: attachment.id,
-        url: attachment.url,
-        title: title || "PDF Attachment",
-        source: "PDF",
-        description: description || "A PDF document",
-        text
+      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) => {
+          logger4.info(`LeaveChannel Slash Command Response: ${message}`);
+        }
       };
+      await this.discordClient.voiceManager.handleLeaveChannelCommand(
+        fakeLeaveInteraction
+      );
+      logger4.success("Slash command test completed successfully.");
     } catch (error) {
-      console.error(`Error processing PDF attachment: ${error.message}`);
-      return {
-        id: attachment.id,
-        url: attachment.url,
-        title: "PDF Attachment (conversion failed)",
-        source: "PDF",
-        description: "A PDF document that could not be converted to text",
-        text: `This is a PDF attachment. File name: ${attachment.name}, Size: ${attachment.size} bytes`
-      };
+      throw new Error(`Error in slash commands test: ${error}`);
     }
   }
   /**
-   * 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.
+   * 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 processPlaintextAttachment(attachment) {
+  async testTextToSpeechPlayback(runtime) {
     try {
-      const response = await fetch(attachment.url);
-      const text = await response.text();
-      const { title, description } = await generateSummary(this.runtime, text);
-      return {
-        id: attachment.id,
-        url: attachment.url,
-        title: title || "Plaintext Attachment",
-        source: "Plaintext",
-        description: description || "A plaintext document",
-        text
-      };
+      await this.waitForVoiceManagerReady(this.discordClient);
+      const channel = await this.getTestChannel(runtime);
+      if (!channel || channel.type !== ChannelType7.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);
+        logger4.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(
+          ModelTypes7.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) {
-      console.error(`Error processing plaintext attachment: ${error.message}`);
-      return {
-        id: attachment.id,
-        url: attachment.url,
-        title: "Plaintext Attachment (retrieval failed)",
-        source: "Plaintext",
-        description: "A plaintext document that could not be retrieved",
-        text: `This is a plaintext attachment. File name: ${attachment.name}, Size: ${attachment.size} bytes`
-      };
+      throw new Error(`Error in TTS playback test: ${error}`);
     }
   }
   /**
-   * 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.
+   * Asynchronously tests sending a text message to a specified channel.
    *
-   * @param {Attachment} attachment - The attachment object containing the image details.
-   * @returns {Promise<Media>} A promise that resolves to a Media object.
+   * @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 processImageAttachment(attachment) {
+  async testSendingTextMessage(runtime) {
     try {
-      const { description, title } = await this.runtime.useModel(
-        ModelTypes6.IMAGE_DESCRIPTION,
-        attachment.url
+      const channel = await this.getTestChannel(runtime);
+      await this.sendMessageToChannel(
+        channel,
+        "Testing Message",
+        [TEST_IMAGE_URL]
       );
-      return {
-        id: attachment.id,
-        url: attachment.url,
-        title: title || "Image Attachment",
-        source: "Image",
-        description: description || "An image attachment",
-        text: description || "Image content not available"
-      };
     } catch (error) {
-      console.error(`Error processing image attachment: ${error.message}`);
-      return this.createFallbackImageMedia(attachment);
+      throw new Error(`Error in sending text message: ${error}`);
     }
   }
   /**
-   * Creates a fallback Media object for image attachments that could not be recognized.
+   * Asynchronously handles sending a test message using the given runtime and mock user data.
    *
-   * @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,
-      url: attachment.url,
-      title: "Image Attachment",
-      source: "Image",
-      description: "An image attachment (recognition failed)",
-      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.
+   * @param {IAgentRuntime} runtime - The agent runtime object.
+   * @returns {Promise<void>} A Promise that resolves once the message is handled.
    */
-  async processVideoAttachment(attachment) {
-    const videoService = this.runtime.getService(
-      ServiceTypes3.VIDEO
-    );
-    if (!videoService) {
-      throw new Error("Video service not found");
-    }
-    if (videoService.isVideoUrl(attachment.url)) {
-      const videoInfo = await videoService.processVideo(
-        attachment.url,
-        this.runtime
-      );
-      return {
-        id: attachment.id,
-        url: attachment.url,
-        title: videoInfo.title,
-        source: "YouTube",
-        description: videoInfo.description,
-        text: videoInfo.text
+  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}`);
     }
-    return {
-      id: attachment.id,
-      url: attachment.url,
-      title: "Video Attachment",
-      source: "Video",
-      description: "A video attachment",
-      text: "Video content not available"
-    };
   }
+  // #############################
+  //     Utility Functions
+  // #############################
   /**
-   * 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.
+   * 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 processGenericAttachment(attachment) {
-    return {
-      id: attachment.id,
-      url: attachment.url,
-      title: "Generic Attachment",
-      source: "Generic",
-      description: "A generic attachment",
-      text: "Attachment content not available"
-    };
-  }
-};
-
-// src/utils.ts
-import {
-  ModelTypes as ModelTypes7,
-  logger as logger3,
-  parseJSONObjectFromText as parseJSONObjectFromText6,
-  trimTokens as trimTokens4
-} from "@elizaos/core";
-import {
-  ChannelType as ChannelType4,
-  PermissionsBitField,
-  ThreadChannel
-} from "discord.js";
-function getWavHeader(audioLength, sampleRate, channelCount = 1, bitsPerSample = 16) {
-  const wavHeader = Buffer.alloc(44);
-  wavHeader.write("RIFF", 0);
-  wavHeader.writeUInt32LE(36 + audioLength, 4);
-  wavHeader.write("WAVE", 8);
-  wavHeader.write("fmt ", 12);
-  wavHeader.writeUInt32LE(16, 16);
-  wavHeader.writeUInt16LE(1, 20);
-  wavHeader.writeUInt16LE(channelCount, 22);
-  wavHeader.writeUInt32LE(sampleRate, 24);
-  wavHeader.writeUInt32LE(sampleRate * bitsPerSample * channelCount / 8, 28);
-  wavHeader.writeUInt16LE(bitsPerSample * channelCount / 8, 32);
-  wavHeader.writeUInt16LE(bitsPerSample, 34);
-  wavHeader.write("data", 36);
-  wavHeader.writeUInt32LE(audioLength, 40);
-  return wavHeader;
-}
-var MAX_MESSAGE_LENGTH = 1900;
-async function sendMessageInChunks(channel, content, _inReplyTo, files) {
-  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) {
-        const options = {
-          content: message.trim()
-        };
-        if (i === messages.length - 1 && files && files.length > 0) {
-          options.files = files;
-        }
-        const m = await channel.send(options);
-        sentMessages.push(m);
-      }
-    }
-  } catch (error) {
-    logger3.error("Error sending message:", error);
-  }
-  return sentMessages;
-}
-function splitMessage(content) {
-  const messages = [];
-  let currentMessage = "";
-  const rawLines = content?.split("\n") || [];
-  const lines = rawLines.flatMap((line) => {
-    const chunks = [];
-    while (line.length > MAX_MESSAGE_LENGTH) {
-      chunks.push(line.slice(0, MAX_MESSAGE_LENGTH));
-      line = line.slice(MAX_MESSAGE_LENGTH);
-    }
-    chunks.push(line);
-    return chunks;
-  });
-  for (const line of lines) {
-    if (currentMessage.length + line.length + 1 > MAX_MESSAGE_LENGTH) {
-      messages.push(currentMessage.trim());
-      currentMessage = "";
-    }
-    currentMessage += `${line}
-`;
-  }
-  if (currentMessage.trim().length > 0) {
-    messages.push(currentMessage.trim());
-  }
-  return messages;
-}
-function canSendMessage(channel) {
-  if (!channel) {
-    return {
-      canSend: false,
-      reason: "No channel given"
-    };
-  }
-  if (channel.type === ChannelType4.DM) {
-    return {
-      canSend: true,
-      reason: null
-    };
-  }
-  const botMember = channel.guild?.members.cache.get(channel.client.user.id);
-  if (!botMember) {
-    return {
-      canSend: false,
-      reason: "Not a guild channel or bot member not found"
-    };
-  }
-  const requiredPermissions = [
-    PermissionsBitField.Flags.ViewChannel,
-    PermissionsBitField.Flags.SendMessages,
-    PermissionsBitField.Flags.ReadMessageHistory
-  ];
-  if (channel instanceof ThreadChannel) {
-    requiredPermissions.push(PermissionsBitField.Flags.SendMessagesInThreads);
-  }
-  const permissions = channel.permissionsFor(botMember);
-  if (!permissions) {
-    return {
-      canSend: false,
-      reason: "Could not retrieve permissions"
-    };
-  }
-  const missingPermissions = requiredPermissions.filter(
-    (perm) => !permissions.has(perm)
-  );
-  return {
-    canSend: missingPermissions.length === 0,
-    missingPermissions,
-    reason: missingPermissions.length > 0 ? `Missing permissions: ${missingPermissions.map((p) => String(p)).join(", ")}` : null
-  };
-}
-
-// src/messages.ts
-var MessageManager = class {
-  client;
-  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;
+  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;
   }
   /**
-   * Handles incoming Discord messages and processes them accordingly.
+   * Async function to send a message to a text-based channel.
    *
-   * @param {DiscordMessage} message - The Discord message to be handled
+   * @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 handleMessage(message) {
-    if (this.runtime.character.settings?.discord?.allowedChannelIds && !this.runtime.character.settings.discord.allowedChannelIds.some(
-      (id) => id === message.channel.id
-    )) {
-      return;
-    }
-    if (message.interaction || message.author.id === this.client.user?.id) {
-      return;
-    }
-    if (this.runtime.character.settings?.discord?.shouldIgnoreBotMessages && message.author?.bot) {
-      return;
-    }
-    if (this.runtime.character.settings?.discord?.shouldIgnoreDirectMessages && message.channel.type === DiscordChannelType2.DM) {
-      return;
-    }
-    const entityId = createUniqueUuid4(this.runtime, message.author.id);
-    const userName = message.author.bot ? `${message.author.username}#${message.author.discriminator}` : message.author.username;
-    const name = message.author.displayName;
-    const channelId = message.channel.id;
-    const roomId = createUniqueUuid4(this.runtime, channelId);
-    let type;
-    let serverId;
-    if (message.guild) {
-      const guild = await message.guild.fetch();
-      type = await this.getChannelType(message.channel);
-      serverId = guild.id;
-    } else {
-      type = ChannelType5.DM;
-      serverId = void 0;
-    }
-    await this.runtime.ensureConnection({
-      entityId,
-      roomId,
-      userName,
-      name,
-      source: "discord",
-      channelId: message.channel.id,
-      serverId,
-      type
-    });
+  async sendMessageToChannel(channel, messageContent, files) {
     try {
-      const canSendResult = canSendMessage(message.channel);
-      if (!canSendResult.canSend) {
-        return logger4.warn(
-          `Cannot send message to channel ${message.channel}`,
-          canSendResult
+      if (!channel || !channel.isTextBased()) {
+        throw new Error(
+          "Channel is not a text-based channel or does not exist."
         );
       }
-      const { processedContent, attachments } = await this.processMessage(message);
-      const audioAttachments = message.attachments.filter(
-        (attachment) => attachment.contentType?.startsWith("audio/")
+      await sendMessageInChunks(
+        channel,
+        messageContent,
+        null,
+        files
       );
-      if (audioAttachments.size > 0) {
-        const processedAudioAttachments = await this.attachmentManager.processAttachments(audioAttachments);
-        attachments.push(...processedAudioAttachments);
-      }
-      if (!processedContent && !attachments?.length) {
-        return;
-      }
-      const entityId2 = createUniqueUuid4(this.runtime, message.author.id);
-      const messageId = createUniqueUuid4(this.runtime, message.id);
-      const newMessage = {
-        id: messageId,
-        entityId: entityId2,
-        agentId: this.runtime.agentId,
-        roomId,
-        content: {
-          // name: name,
-          // userName: userName,
-          text: processedContent || " ",
-          attachments,
-          source: "discord",
-          url: message.url,
-          inReplyTo: message.reference?.messageId ? createUniqueUuid4(this.runtime, message.reference?.messageId) : void 0
-        },
-        createdAt: message.createdTimestamp
-      };
-      const callback = async (content, files) => {
-        try {
-          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.getMemoryManager("messages").createMemory(m);
-          }
-          return memories;
-        } catch (error) {
-          console.error("Error sending message:", error);
-          return [];
-        }
-      };
-      this.runtime.emitEvent(["DISCORD_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, EventTypes.MESSAGE_RECEIVED], {
-        runtime: this.runtime,
-        message: newMessage,
-        callback
-      });
     } catch (error) {
-      console.error("Error handling message:", error);
+      throw new Error(`Error sending message: ${error}`);
     }
   }
   /**
-   * Processes the message content, mentions, code blocks, attachments, and URLs to generate
-   * processed content and media attachments.
+   * Play an audio stream from a given response stream using the provided VoiceConnection.
    *
-   * @param {DiscordMessage} message The message to process
-   * @returns {Promise<{ processedContent: string; attachments: Media[] }>} Processed content and media attachments
+   * @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 processMessage(message) {
-    let processedContent = message.content;
-    let attachments = [];
-    const mentionRegex = /<@!?(\d+)>/g;
-    processedContent = processedContent.replace(
-      mentionRegex,
-      (match2, entityId) => {
-        const user = message.mentions.users.get(entityId);
-        if (user) {
-          return `${user.username} (@${entityId})`;
-        }
-        return match2;
-      }
-    );
-    const codeBlockRegex = /```([\s\S]*?)```/g;
-    let match;
-    while (match = codeBlockRegex.exec(processedContent)) {
-      const codeBlock = match[1];
-      const lines = codeBlock.split("\n");
-      const title = lines[0];
-      const description = lines.slice(0, 3).join("\n");
-      const attachmentId = `code-${Date.now()}-${Math.floor(
-        Math.random() * 1e3
-      )}`.slice(-5);
-      attachments.push({
-        id: attachmentId,
-        url: "",
-        title: title || "Code Block",
-        source: "Code",
-        description,
-        text: codeBlock
-      });
-      processedContent = processedContent.replace(
-        match[0],
-        `Code Block (${attachmentId})`
-      );
-    }
-    if (message.attachments.size > 0) {
-      attachments = await this.attachmentManager.processAttachments(
-        message.attachments
-      );
-    }
-    const urlRegex = /(https?:\/\/[^\s]+)/g;
-    const urls = processedContent.match(urlRegex) || [];
-    for (const url of urls) {
-      if (this.runtime.getService(ServiceTypes4.VIDEO)?.isVideoUrl(url)) {
-        const videoService = this.runtime.getService(
-          ServiceTypes4.VIDEO
-        );
-        if (!videoService) {
-          throw new Error("Video service not found");
-        }
-        const videoInfo = await videoService.processVideo(url, this.runtime);
-        attachments.push({
-          id: `youtube-${Date.now()}`,
-          url,
-          title: videoInfo.title,
-          source: "YouTube",
-          description: videoInfo.description,
-          text: videoInfo.text
-        });
-      } else {
-        const browserService = this.runtime.getService(
-          ServiceTypes4.BROWSER
-        );
-        if (!browserService) {
-          throw new Error("Browser service not found");
-        }
-        const { title, description: summary } = await browserService.getPageContent(url, this.runtime);
-        attachments.push({
-          id: `webpage-${Date.now()}`,
-          url,
-          title: title || "Web Page",
-          source: "Web",
-          description: summary,
-          text: summary
-        });
+  async playAudioStream(responseStream, connection) {
+    const audioPlayer = createAudioPlayer({
+      behaviors: {
+        noSubscriber: NoSubscriberBehavior.Pause
       }
-    }
-    return { processedContent, attachments };
+    });
+    const audioResource = createAudioResource(responseStream);
+    audioPlayer.play(audioResource);
+    connection.subscribe(audioPlayer);
+    logger4.success("TTS playback started successfully.");
+    await new Promise((resolve, reject) => {
+      audioPlayer.once(AudioPlayerStatus.Idle, () => {
+        logger4.info("TTS playback finished.");
+        resolve();
+      });
+      audioPlayer.once("error", (error) => {
+        reject(error);
+        throw new Error(`TTS playback error: ${error}`);
+      });
+    });
   }
   /**
-   * Asynchronously fetches the bot's username and discriminator from Discord API.
+   * Retrieves the active guild where the bot is currently connected to a voice channel.
    *
-   * @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
+   * @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 fetchBotName(botToken) {
-    const url = "https://discord.com/api/v10/users/@me";
-    const response = await fetch(url, {
-      method: "GET",
-      headers: {
-        Authorization: `Bot ${botToken}`
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Error fetching bot details: ${response.statusText}`);
+  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.");
     }
-    const data = await response.json();
-    const discriminator = data.discriminator;
-    return data.username + (discriminator ? `#${discriminator}` : "");
+    return activeGuild;
   }
-};
-
-// 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.getRoom(message.roomId);
-    if (!room) {
-      throw new Error("No room found");
+  /**
+   * 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 waitForVoiceManagerReady(discordClient) {
+    if (!discordClient) {
+      throw new Error("Discord client is not initialized.");
     }
-    if (message.content.source !== "discord") {
-      return {
-        data: null,
-        values: {},
-        text: ""
-      };
+    if (!discordClient.voiceManager.isReady()) {
+      await new Promise((resolve, reject) => {
+        discordClient.voiceManager.once("ready", resolve);
+        discordClient.voiceManager.once("error", reject);
+      });
     }
-    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
+  }
+  /**
+   * 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.
+   */
+  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."
       );
-      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
-    };
+    return testChannelId;
   }
 };
-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.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.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 ChannelType10, EventTypes as EventTypes2, Role, Service, createUniqueUuid as createUniqueUuid6, logger as logger7 } from "@elizaos/core";
+import { ChannelType as DiscordChannelType4, Client as DiscordJsClient, Events as Events2, GatewayIntentBits, Partials, PermissionsBitField as PermissionsBitField2 } from "discord.js";
+
+// src/constants.ts
+var MESSAGE_CONSTANTS = {
+  MAX_MESSAGES: 10,
+  RECENT_MESSAGE_COUNT: 3,
+  CHAT_HISTORY_COUNT: 5,
+  INTEREST_DECAY_TIME: 5 * 60 * 1e3,
+  // 5 minutes
+  PARTIAL_INTEREST_DECAY: 3 * 60 * 1e3,
+  // 3 minutes
+  DEFAULT_SIMILARITY_THRESHOLD: 0.3,
+  DEFAULT_SIMILARITY_THRESHOLD_FOLLOW_UPS: 0.2
 };
-var voiceState_default = voiceStateProvider;
+var DISCORD_SERVICE_NAME = "discord";
 
-// src/tests.ts
+// src/messages.ts
 import {
-  AudioPlayerStatus,
-  NoSubscriberBehavior,
-  VoiceConnectionStatus,
-  createAudioPlayer,
-  createAudioResource,
-  entersState
-} from "@discordjs/voice";
+  ChannelType as ChannelType8,
+  EventTypes,
+  ServiceTypes as ServiceTypes4,
+  createUniqueUuid as createUniqueUuid4,
+  logger as logger5
+} from "@elizaos/core";
+import {
+  ChannelType as DiscordChannelType2
+} from "discord.js";
+
+// src/attachments.ts
+import fs3 from "node:fs";
+import { trimTokens as trimTokens4 } from "@elizaos/core";
+import { parseJSONObjectFromText as parseJSONObjectFromText6 } from "@elizaos/core";
 import {
   ModelTypes as ModelTypes8,
-  logger as logger5
+  ServiceTypes as ServiceTypes3
 } 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;
+import { Collection } from "discord.js";
+import ffmpeg from "fluent-ffmpeg";
+async function generateSummary(runtime, text) {
+  text = await trimTokens4(text, 1e5, runtime);
+  const prompt = `Please generate a concise summary for the following text:
+
+  Text: """
+  ${text}
+  """
+
+  Respond with a JSON object in the following format:
+  \`\`\`json
+  {
+    "title": "Generated Title",
+    "summary": "Generated summary and/or description of the text"
+  }
+  \`\`\``;
+  const response = await runtime.useModel(ModelTypes8.TEXT_SMALL, {
+    prompt
+  });
+  const parsedResponse = parseJSONObjectFromText6(response);
+  if (parsedResponse?.title && parsedResponse?.summary) {
+    return {
+      title: parsedResponse.title,
+      description: parsedResponse.summary
+    };
+  }
+  return {
+    title: "",
+    description: ""
+  };
+}
+var AttachmentManager = class {
+  attachmentCache = /* @__PURE__ */ new Map();
+  runtime;
   /**
-   * Constructor for initializing the tests array with test cases to be executed.
+   * Constructor for creating a new instance of the class.
    *
-   * @constructor
-   * @this {TestSuite}
+   * @param {IAgentRuntime} runtime The runtime object to be injected into the instance.
    */
-  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)
+  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]));
+    for (const [, attachment] of attachmentCollection) {
+      const media = await this.processAttachment(attachment);
+      if (media) {
+        processedAttachments.push(media);
       }
-    ];
+    }
+    return processedAttachments;
   }
   /**
-   * Asynchronously tests the creation of Discord client using the provided runtime.
+   * 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 {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.
+   * @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 testCreatingDiscordClient(runtime) {
+  async processAttachment(attachment) {
+    if (this.attachmentCache.has(attachment.url)) {
+      return this.attachmentCache.get(attachment.url);
+    }
+    let media = null;
+    if (attachment.contentType?.startsWith("application/pdf")) {
+      media = await this.processPdfAttachment(attachment);
+    } else if (attachment.contentType?.startsWith("text/plain")) {
+      media = await this.processPlaintextAttachment(attachment);
+    } else if (attachment.contentType?.startsWith("audio/") || attachment.contentType?.startsWith("video/mp4")) {
+      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(ServiceTypes3.VIDEO).isVideoUrl(attachment.url)) {
+      media = await this.processVideoAttachment(attachment);
+    } else {
+      media = await this.processGenericAttachment(attachment);
+    }
+    if (media) {
+      this.attachmentCache.set(attachment.url, media);
+    }
+    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 {
-      this.discordClient = runtime.getService(
-        ServiceTypes2.DISCORD
-      );
-      if (this.discordClient.client.isReady()) {
-        logger5.success("DiscordService is already ready.");
+      const response = await fetch(attachment.url);
+      const audioVideoArrayBuffer = await response.arrayBuffer();
+      let audioBuffer;
+      if (attachment.contentType?.startsWith("audio/")) {
+        audioBuffer = Buffer.from(audioVideoArrayBuffer);
+      } else if (attachment.contentType?.startsWith("video/mp4")) {
+        audioBuffer = await this.extractAudioFromMP4(audioVideoArrayBuffer);
       } 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);
-        });
+        throw new Error("Unsupported audio/video format");
       }
+      const transcription = await this.runtime.useModel(
+        ModelTypes8.TRANSCRIPTION,
+        audioBuffer
+      );
+      const { title, description } = await generateSummary(
+        this.runtime,
+        transcription
+      );
+      return {
+        id: attachment.id,
+        url: attachment.url,
+        title: title || "Audio/Video Attachment",
+        source: attachment.contentType?.startsWith("audio/") ? "Audio" : "Video",
+        description: description || "User-uploaded audio/video attachment which has been transcribed",
+        text: transcription || "Audio/video content not available"
+      };
     } catch (error) {
-      throw new Error(`Error in test creating Discord client: ${error}`);
+      console.error(
+        `Error processing audio/video attachment: ${error.message}`
+      );
+      return {
+        id: attachment.id,
+        url: attachment.url,
+        title: "Audio/Video Attachment",
+        source: attachment.contentType?.startsWith("audio/") ? "Audio" : "Video",
+        description: "An audio/video attachment (transcription failed)",
+        text: `This is an audio/video attachment. File name: ${attachment.name}, Size: ${attachment.size} bytes, Content type: ${attachment.contentType}`
+      };
     }
   }
   /**
-   * Asynchronously tests the join voice slash command functionality.
+   * Extracts the audio stream from the provided MP4 data and converts it to MP3 format.
    *
-   * @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.
+   * @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 testJoinVoiceSlashCommand(runtime) {
+  async extractAudioFromMP4(mp4Data) {
+    const tempMP4File = `temp_${Date.now()}.mp4`;
+    const tempAudioFile = `temp_${Date.now()}.mp3`;
     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.");
+      fs3.writeFileSync(tempMP4File, Buffer.from(mp4Data));
+      await new Promise((resolve, reject) => {
+        ffmpeg(tempMP4File).outputOptions("-vn").audioCodec("libmp3lame").save(tempAudioFile).on("end", () => {
+          resolve();
+        }).on("error", (err) => {
+          reject(err);
+        }).run();
+      });
+      const audioData = fs3.readFileSync(tempAudioFile);
+      return audioData;
+    } finally {
+      if (fs3.existsSync(tempMP4File)) {
+        fs3.unlinkSync(tempMP4File);
+      }
+      if (fs3.existsSync(tempAudioFile)) {
+        fs3.unlinkSync(tempAudioFile);
       }
-      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}`);
     }
   }
   /**
-   * Asynchronously tests the leave voice channel slash command.
+   * 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 {IAgentRuntime} runtime - The Agent Runtime instance.
-   * @returns {Promise<void>} A promise that resolves when the test is complete.
+   * @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 testLeaveVoiceSlashCommand(runtime) {
+  async processPdfAttachment(attachment) {
     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}`);
-        }
+      const response = await fetch(attachment.url);
+      const pdfBuffer = await response.arrayBuffer();
+      const text = await this.runtime.getService(ServiceTypes3.PDF).convertPdfToText(Buffer.from(pdfBuffer));
+      const { title, description } = await generateSummary(this.runtime, text);
+      return {
+        id: attachment.id,
+        url: attachment.url,
+        title: title || "PDF Attachment",
+        source: "PDF",
+        description: description || "A PDF document",
+        text
       };
-      await this.discordClient.voiceManager.handleLeaveChannelCommand(
-        fakeLeaveInteraction
-      );
-      logger5.success("Slash command test completed successfully.");
     } catch (error) {
-      throw new Error(`Error in slash commands test: ${error}`);
+      console.error(`Error processing PDF attachment: ${error.message}`);
+      return {
+        id: attachment.id,
+        url: attachment.url,
+        title: "PDF Attachment (conversion failed)",
+        source: "PDF",
+        description: "A PDF document that could not be converted to text",
+        text: `This is a PDF attachment. File name: ${attachment.name}, Size: ${attachment.size} bytes`
+      };
     }
   }
   /**
-   * 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.
+   * 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 testTextToSpeechPlayback(runtime) {
+  async processPlaintextAttachment(attachment) {
     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);
+      const response = await fetch(attachment.url);
+      const text = await response.text();
+      const { title, description } = await generateSummary(this.runtime, text);
+      return {
+        id: attachment.id,
+        url: attachment.url,
+        title: title || "Plaintext Attachment",
+        source: "Plaintext",
+        description: description || "A plaintext document",
+        text
+      };
     } catch (error) {
-      throw new Error(`Error in TTS playback test: ${error}`);
+      console.error(`Error processing plaintext attachment: ${error.message}`);
+      return {
+        id: attachment.id,
+        url: attachment.url,
+        title: "Plaintext Attachment (retrieval failed)",
+        source: "Plaintext",
+        description: "A plaintext document that could not be retrieved",
+        text: `This is a plaintext attachment. File name: ${attachment.name}, Size: ${attachment.size} bytes`
+      };
     }
   }
   /**
-   * Asynchronously tests sending a text message to a specified channel.
+   * 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 {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.
+   * @param {Attachment} attachment - The attachment object containing the image details.
+   * @returns {Promise<Media>} A promise that resolves to a Media object.
    */
-  async testSendingTextMessage(runtime) {
+  async processImageAttachment(attachment) {
     try {
-      const channel = await this.getTestChannel(runtime);
-      await this.sendMessageToChannel(
-        channel,
-        "Testing Message",
-        [TEST_IMAGE_URL]
+      const { description, title } = await this.runtime.useModel(
+        ModelTypes8.IMAGE_DESCRIPTION,
+        attachment.url
       );
+      return {
+        id: attachment.id,
+        url: attachment.url,
+        title: title || "Image Attachment",
+        source: "Image",
+        description: description || "An image attachment",
+        text: description || "Image content not available"
+      };
     } catch (error) {
-      throw new Error(`Error in sending text message: ${error}`);
+      console.error(`Error processing image attachment: ${error.message}`);
+      return this.createFallbackImageMedia(attachment);
     }
   }
   /**
-   * Asynchronously handles sending a test message using the given runtime and mock user data.
+   * Creates a fallback Media object for image attachments that could not be recognized.
    *
-   * @param {IAgentRuntime} runtime - The agent runtime object.
-   * @returns {Promise<void>} A Promise that resolves once the message is handled.
+   * @param {Attachment} attachment - The attachment object containing image details.
+   * @returns {Media} - The fallback Media object with basic information about the image attachment.
    */
-  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: []
+  createFallbackImageMedia(attachment) {
+    return {
+      id: attachment.id,
+      url: attachment.url,
+      title: "Image Attachment",
+      source: "Image",
+      description: "An image attachment (recognition failed)",
+      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
+    );
+    if (!videoService) {
+      throw new Error("Video service not found");
+    }
+    if (videoService.isVideoUrl(attachment.url)) {
+      const videoInfo = await videoService.processVideo(
+        attachment.url,
+        this.runtime
+      );
+      return {
+        id: attachment.id,
+        url: attachment.url,
+        title: videoInfo.title,
+        source: "YouTube",
+        description: videoInfo.description,
+        text: videoInfo.text
       };
-      await this.discordClient.messageManager.handleMessage(fakeMessage);
-    } catch (error) {
-      throw new Error(`Error in sending text message: ${error}`);
     }
+    return {
+      id: attachment.id,
+      url: attachment.url,
+      title: "Video Attachment",
+      source: "Video",
+      description: "A video attachment",
+      text: "Video content not available"
+    };
   }
-  // #############################
-  //     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.
+   * 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 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 processGenericAttachment(attachment) {
+    return {
+      id: attachment.id,
+      url: attachment.url,
+      title: "Generic Attachment",
+      source: "Generic",
+      description: "A generic attachment",
+      text: "Attachment content not available"
+    };
   }
+};
+
+// src/messages.ts
+var MessageManager = class {
+  client;
+  runtime;
+  attachmentManager;
+  getChannelType;
   /**
-   * Async function to send a message to a text-based channel.
+   * 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 {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.
+   * @param {DiscordMessage} message - The Discord message to be handled
    */
-  async sendMessageToChannel(channel, messageContent, files) {
+  async handleMessage(message) {
+    if (this.runtime.character.settings?.discord?.allowedChannelIds && !this.runtime.character.settings.discord.allowedChannelIds.some(
+      (id) => id === message.channel.id
+    )) {
+      return;
+    }
+    if (message.interaction || message.author.id === this.client.user?.id) {
+      return;
+    }
+    if (this.runtime.character.settings?.discord?.shouldIgnoreBotMessages && message.author?.bot) {
+      return;
+    }
+    if (this.runtime.character.settings?.discord?.shouldIgnoreDirectMessages && message.channel.type === DiscordChannelType2.DM) {
+      return;
+    }
+    const entityId = createUniqueUuid4(this.runtime, message.author.id);
+    const userName = message.author.bot ? `${message.author.username}#${message.author.discriminator}` : message.author.username;
+    const name = message.author.displayName;
+    const channelId = message.channel.id;
+    const roomId = createUniqueUuid4(this.runtime, channelId);
+    let type;
+    let serverId;
+    if (message.guild) {
+      const guild = await message.guild.fetch();
+      type = await this.getChannelType(message.channel);
+      serverId = guild.id;
+    } else {
+      type = ChannelType8.DM;
+      serverId = void 0;
+    }
+    await this.runtime.ensureConnection({
+      entityId,
+      roomId,
+      userName,
+      name,
+      source: "discord",
+      channelId: message.channel.id,
+      serverId,
+      type
+    });
     try {
-      if (!channel || !channel.isTextBased()) {
-        throw new Error(
-          "Channel is not a text-based channel or does not exist."
+      const canSendResult = canSendMessage(message.channel);
+      if (!canSendResult.canSend) {
+        return logger5.warn(
+          `Cannot send message to channel ${message.channel}`,
+          canSendResult
         );
       }
-      await sendMessageInChunks(
-        channel,
-        messageContent,
-        null,
-        files
+      const { processedContent, attachments } = await this.processMessage(message);
+      const audioAttachments = message.attachments.filter(
+        (attachment) => attachment.contentType?.startsWith("audio/")
       );
+      if (audioAttachments.size > 0) {
+        const processedAudioAttachments = await this.attachmentManager.processAttachments(audioAttachments);
+        attachments.push(...processedAudioAttachments);
+      }
+      if (!processedContent && !attachments?.length) {
+        return;
+      }
+      const entityId2 = createUniqueUuid4(this.runtime, message.author.id);
+      const messageId = createUniqueUuid4(this.runtime, message.id);
+      const newMessage = {
+        id: messageId,
+        entityId: entityId2,
+        agentId: this.runtime.agentId,
+        roomId,
+        content: {
+          // name: name,
+          // userName: userName,
+          text: processedContent || " ",
+          attachments,
+          source: "discord",
+          url: message.url,
+          inReplyTo: message.reference?.messageId ? createUniqueUuid4(this.runtime, message.reference?.messageId) : void 0
+        },
+        createdAt: message.createdTimestamp
+      };
+      const callback = async (content, files) => {
+        try {
+          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.getMemoryManager("messages").createMemory(m);
+          }
+          return memories;
+        } catch (error) {
+          console.error("Error sending message:", error);
+          return [];
+        }
+      };
+      this.runtime.emitEvent(["DISCORD_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, EventTypes.MESSAGE_RECEIVED], {
+        runtime: this.runtime,
+        message: newMessage,
+        callback
+      });
     } catch (error) {
-      throw new Error(`Error sending message: ${error}`);
+      console.error("Error handling message:", error);
     }
   }
   /**
-   * Play an audio stream from a given response stream using the provided VoiceConnection.
+   * Processes the message content, mentions, code blocks, attachments, and URLs to generate
+   * processed content and media attachments.
    *
-   * @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.
+   * @param {DiscordMessage} message The message to process
+   * @returns {Promise<{ processedContent: string; attachments: Media[] }>} Processed content and media attachments
    */
-  async playAudioStream(responseStream, connection) {
-    const audioPlayer = createAudioPlayer({
-      behaviors: {
-        noSubscriber: NoSubscriberBehavior.Pause
+  async processMessage(message) {
+    let processedContent = message.content;
+    let attachments = [];
+    const mentionRegex = /<@!?(\d+)>/g;
+    processedContent = processedContent.replace(
+      mentionRegex,
+      (match2, entityId) => {
+        const user = message.mentions.users.get(entityId);
+        if (user) {
+          return `${user.username} (@${entityId})`;
+        }
+        return match2;
       }
-    });
-    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}`);
+    );
+    const codeBlockRegex = /```([\s\S]*?)```/g;
+    let match;
+    while (match = codeBlockRegex.exec(processedContent)) {
+      const codeBlock = match[1];
+      const lines = codeBlock.split("\n");
+      const title = lines[0];
+      const description = lines.slice(0, 3).join("\n");
+      const attachmentId = `code-${Date.now()}-${Math.floor(
+        Math.random() * 1e3
+      )}`.slice(-5);
+      attachments.push({
+        id: attachmentId,
+        url: "",
+        title: title || "Code Block",
+        source: "Code",
+        description,
+        text: codeBlock
       });
-    });
-  }
-  /**
-   * 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.");
+      processedContent = processedContent.replace(
+        match[0],
+        `Code Block (${attachmentId})`
+      );
     }
-    return activeGuild;
-  }
-  /**
-   * 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 waitForVoiceManagerReady(discordClient) {
-    if (!discordClient) {
-      throw new Error("Discord client is not initialized.");
+    if (message.attachments.size > 0) {
+      attachments = await this.attachmentManager.processAttachments(
+        message.attachments
+      );
     }
-    if (!discordClient.voiceManager.isReady()) {
-      await new Promise((resolve, reject) => {
-        discordClient.voiceManager.once("ready", resolve);
-        discordClient.voiceManager.once("error", reject);
-      });
+    const urlRegex = /(https?:\/\/[^\s]+)/g;
+    const urls = processedContent.match(urlRegex) || [];
+    for (const url of urls) {
+      if (this.runtime.getService(ServiceTypes4.VIDEO)?.isVideoUrl(url)) {
+        const videoService = this.runtime.getService(
+          ServiceTypes4.VIDEO
+        );
+        if (!videoService) {
+          throw new Error("Video service not found");
+        }
+        const videoInfo = await videoService.processVideo(url, this.runtime);
+        attachments.push({
+          id: `youtube-${Date.now()}`,
+          url,
+          title: videoInfo.title,
+          source: "YouTube",
+          description: videoInfo.description,
+          text: videoInfo.text
+        });
+      } else {
+        const browserService = this.runtime.getService(
+          ServiceTypes4.BROWSER
+        );
+        if (!browserService) {
+          throw new Error("Browser service not found");
+        }
+        const { title, description: summary } = await browserService.getPageContent(url, this.runtime);
+        attachments.push({
+          id: `webpage-${Date.now()}`,
+          url,
+          title: title || "Web Page",
+          source: "Web",
+          description: summary,
+          text: summary
+        });
+      }
     }
+    return { processedContent, attachments };
   }
   /**
-   * 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.
+   * Asynchronously fetches the bot's username and discriminator from Discord API.
    *
-   * @param {IAgentRuntime} runtime The runtime object containing the settings and environment variables.
-   * @returns {string} The validated Discord test channel ID.
+   * @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
    */
-  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."
-      );
+  async fetchBotName(botToken) {
+    const url = "https://discord.com/api/v10/users/@me";
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bot ${botToken}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Error fetching bot details: ${response.statusText}`);
     }
-    return testChannelId;
+    const data = await response.json();
+    const discriminator = data.discriminator;
+    return data.username + (discriminator ? `#${discriminator}` : "");
   }
 };
 
@@ -3512,7 +3501,7 @@ 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.");
+        logger6.debug("Warning: No suitable voice channel found to join.");
       }
     } catch (error) {
       console.error("Error selecting or joining a voice channel:", error);
@@ -3626,7 +3615,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";
@@ -4437,27 +4426,29 @@ var DiscordService = class _DiscordService extends Service {
     this.client?.emit("voiceManagerReady");
   }
 };
+
+// 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],
+  providers: [channelStateProvider, voiceStateProvider],
   tests: [new DiscordTestSuite()],
   init: async (config, runtime) => {
     const token = runtime.getSetting("DISCORD_API_TOKEN");
     if (!token || token.trim() === "") {
-      logger7.warn(
+      logger8.warn(
         "Discord API Token not provided - Discord plugin is loaded but will not be functional"
       );
-      logger7.warn(
+      logger8.warn(
         "To enable Discord functionality, please provide DISCORD_API_TOKEN in your .eliza/.env file"
       );
     }
@@ -4465,7 +4456,6 @@ var discordPlugin = {
 };
 var index_default = discordPlugin;
 export {
-  DiscordService,
   index_default as default
 };
 //# sourceMappingURL=index.js.map