@elizaos/plugin-discord 2.0.0-alpha.11 → 2.0.0-alpha.12

package/dist/index.js

@@ -457,26 +457,26 @@ var require_channel = __commonJS((exports) => {
     ForumLayoutType2[ForumLayoutType2["ListView"] = 1] = "ListView";
     ForumLayoutType2[ForumLayoutType2["GalleryView"] = 2] = "GalleryView";
   })(ForumLayoutType || (exports.ForumLayoutType = ForumLayoutType = {}));
-  var ChannelType9;
-  (function(ChannelType10) {
-    ChannelType10[ChannelType10["GuildText"] = 0] = "GuildText";
-    ChannelType10[ChannelType10["DM"] = 1] = "DM";
-    ChannelType10[ChannelType10["GuildVoice"] = 2] = "GuildVoice";
-    ChannelType10[ChannelType10["GroupDM"] = 3] = "GroupDM";
-    ChannelType10[ChannelType10["GuildCategory"] = 4] = "GuildCategory";
-    ChannelType10[ChannelType10["GuildAnnouncement"] = 5] = "GuildAnnouncement";
-    ChannelType10[ChannelType10["AnnouncementThread"] = 10] = "AnnouncementThread";
-    ChannelType10[ChannelType10["PublicThread"] = 11] = "PublicThread";
-    ChannelType10[ChannelType10["PrivateThread"] = 12] = "PrivateThread";
-    ChannelType10[ChannelType10["GuildStageVoice"] = 13] = "GuildStageVoice";
-    ChannelType10[ChannelType10["GuildDirectory"] = 14] = "GuildDirectory";
-    ChannelType10[ChannelType10["GuildForum"] = 15] = "GuildForum";
-    ChannelType10[ChannelType10["GuildMedia"] = 16] = "GuildMedia";
-    ChannelType10[ChannelType10["GuildNews"] = 5] = "GuildNews";
-    ChannelType10[ChannelType10["GuildNewsThread"] = 10] = "GuildNewsThread";
-    ChannelType10[ChannelType10["GuildPublicThread"] = 11] = "GuildPublicThread";
-    ChannelType10[ChannelType10["GuildPrivateThread"] = 12] = "GuildPrivateThread";
-  })(ChannelType9 || (exports.ChannelType = ChannelType9 = {}));
+  var ChannelType10;
+  (function(ChannelType11) {
+    ChannelType11[ChannelType11["GuildText"] = 0] = "GuildText";
+    ChannelType11[ChannelType11["DM"] = 1] = "DM";
+    ChannelType11[ChannelType11["GuildVoice"] = 2] = "GuildVoice";
+    ChannelType11[ChannelType11["GroupDM"] = 3] = "GroupDM";
+    ChannelType11[ChannelType11["GuildCategory"] = 4] = "GuildCategory";
+    ChannelType11[ChannelType11["GuildAnnouncement"] = 5] = "GuildAnnouncement";
+    ChannelType11[ChannelType11["AnnouncementThread"] = 10] = "AnnouncementThread";
+    ChannelType11[ChannelType11["PublicThread"] = 11] = "PublicThread";
+    ChannelType11[ChannelType11["PrivateThread"] = 12] = "PrivateThread";
+    ChannelType11[ChannelType11["GuildStageVoice"] = 13] = "GuildStageVoice";
+    ChannelType11[ChannelType11["GuildDirectory"] = 14] = "GuildDirectory";
+    ChannelType11[ChannelType11["GuildForum"] = 15] = "GuildForum";
+    ChannelType11[ChannelType11["GuildMedia"] = 16] = "GuildMedia";
+    ChannelType11[ChannelType11["GuildNews"] = 5] = "GuildNews";
+    ChannelType11[ChannelType11["GuildNewsThread"] = 10] = "GuildNewsThread";
+    ChannelType11[ChannelType11["GuildPublicThread"] = 11] = "GuildPublicThread";
+    ChannelType11[ChannelType11["GuildPrivateThread"] = 12] = "GuildPrivateThread";
+  })(ChannelType10 || (exports.ChannelType = ChannelType10 = {}));
   var VideoQualityMode;
   (function(VideoQualityMode2) {
     VideoQualityMode2[VideoQualityMode2["Auto"] = 1] = "Auto";
@@ -924,20 +924,20 @@ var require_role = __commonJS((exports) => {
 var require_shared = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.ApplicationCommandOptionType = undefined;
-  var ApplicationCommandOptionType;
-  (function(ApplicationCommandOptionType2) {
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["Subcommand"] = 1] = "Subcommand";
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["SubcommandGroup"] = 2] = "SubcommandGroup";
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["String"] = 3] = "String";
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["Integer"] = 4] = "Integer";
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["Boolean"] = 5] = "Boolean";
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["User"] = 6] = "User";
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["Channel"] = 7] = "Channel";
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["Role"] = 8] = "Role";
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["Mentionable"] = 9] = "Mentionable";
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["Number"] = 10] = "Number";
-    ApplicationCommandOptionType2[ApplicationCommandOptionType2["Attachment"] = 11] = "Attachment";
-  })(ApplicationCommandOptionType || (exports.ApplicationCommandOptionType = ApplicationCommandOptionType = {}));
+  var ApplicationCommandOptionType2;
+  (function(ApplicationCommandOptionType3) {
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["Subcommand"] = 1] = "Subcommand";
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["SubcommandGroup"] = 2] = "SubcommandGroup";
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["String"] = 3] = "String";
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["Integer"] = 4] = "Integer";
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["Boolean"] = 5] = "Boolean";
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["User"] = 6] = "User";
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["Channel"] = 7] = "Channel";
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["Role"] = 8] = "Role";
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["Mentionable"] = 9] = "Mentionable";
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["Number"] = 10] = "Number";
+    ApplicationCommandOptionType3[ApplicationCommandOptionType3["Attachment"] = 11] = "Attachment";
+  })(ApplicationCommandOptionType2 || (exports.ApplicationCommandOptionType = ApplicationCommandOptionType2 = {}));
 });
 
 // ../../../node_modules/.bun/discord-api-types@0.37.120/node_modules/discord-api-types/payloads/v10/_interactions/_applicationCommands/_chatInput/string.js
@@ -2702,7 +2702,7 @@ var require_v106 = __commonJS((exports) => {
 });
 
 // index.ts
-import { logger as logger5 } from "@elizaos/core";
+import { logger as logger6 } from "@elizaos/core";
 
 // actions/chatWithAttachments.ts
 import fs from "node:fs";
@@ -6250,13 +6250,653 @@ var serverInfo = {
 };
 var serverInfo_default = serverInfo;
 
+// actions/setup-credentials.ts
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  logger
+} from "@elizaos/core";
+import { ChannelType as ChannelType2 } from "discord.js";
+var SAFE_PRESET_NAME_RE = /^[A-Za-z0-9_-]+$/;
+var SESSION_TIMEOUT_MS = 5 * 60 * 1000;
+var presets = new Map;
+var activeSessions = new Map;
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getCredentialsDir() {
+  const configured = process.env.CREDENTIALS_DIR?.trim();
+  if (configured) {
+    return configured;
+  }
+  const home = (typeof os.homedir === "function" ? os.homedir() : "") || process.env.HOME || process.env.USERPROFILE;
+  return home ? path.join(home, ".credentials") : path.join(process.cwd(), ".credentials");
+}
+function registerPreset(preset) {
+  const normalizedName = preset.name.trim().toLowerCase();
+  if (!SAFE_PRESET_NAME_RE.test(normalizedName)) {
+    throw new Error(`Invalid credential preset name "${preset.name}". Only letters, numbers, underscores, and hyphens are allowed.`);
+  }
+  presets.set(normalizedName, { ...preset, name: normalizedName });
+}
+function getPreset(name) {
+  return presets.get(name.toLowerCase());
+}
+function listPresets() {
+  return [...presets.keys()];
+}
+registerPreset({
+  name: "github",
+  displayName: "GitHub",
+  fields: [{ key: "token", label: "Personal Access Token", secret: true }],
+  helpUrl: "https://github.com/settings/tokens",
+  helpText: "Create a fine-grained PAT at the link above. Give it the repository permissions you need.",
+  async validate(credentials) {
+    try {
+      const response = await fetch("https://api.github.com/user", {
+        headers: {
+          Authorization: `Bearer ${credentials.token}`,
+          Accept: "application/vnd.github+json"
+        }
+      });
+      if (!response.ok) {
+        return {
+          valid: false,
+          error: `GitHub returned ${response.status}`
+        };
+      }
+      const data = await response.json();
+      return {
+        valid: true,
+        identity: data.login ? `@${data.login}` : "verified"
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+registerPreset({
+  name: "vercel",
+  displayName: "Vercel",
+  fields: [{ key: "token", label: "API Token", secret: true }],
+  helpUrl: "https://vercel.com/account/tokens",
+  helpText: "Create a token at the link above. Full Account scope works best.",
+  async validate(credentials) {
+    try {
+      const response = await fetch("https://api.vercel.com/v9/projects", {
+        headers: { Authorization: `Bearer ${credentials.token}` }
+      });
+      if (!response.ok) {
+        return {
+          valid: false,
+          error: `Vercel returned ${response.status}`
+        };
+      }
+      const data = await response.json();
+      return {
+        valid: true,
+        identity: `${data.projects?.length ?? 0} project(s) accessible`
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+registerPreset({
+  name: "cloudflare",
+  displayName: "Cloudflare",
+  fields: [
+    { key: "apiKey", label: "Global API Key", secret: true },
+    { key: "email", label: "Account Email", secret: false }
+  ],
+  helpUrl: "https://dash.cloudflare.com/profile/api-tokens",
+  helpText: 'Go to Cloudflare > Profile > API Tokens > "Global API Key". You will also need your account email.',
+  async validate(credentials) {
+    try {
+      const response = await fetch("https://api.cloudflare.com/client/v4/zones", {
+        headers: {
+          "X-Auth-Key": credentials.apiKey,
+          "X-Auth-Email": credentials.email
+        }
+      });
+      if (!response.ok) {
+        return {
+          valid: false,
+          error: `Cloudflare returned ${response.status}`
+        };
+      }
+      const data = await response.json();
+      return {
+        valid: true,
+        identity: data.result && data.result.length > 0 ? `zones: ${data.result.map((zone) => zone.name).join(", ")}` : "verified"
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+registerPreset({
+  name: "anthropic",
+  displayName: "Anthropic",
+  fields: [{ key: "apiKey", label: "API Key", secret: true }],
+  helpUrl: "https://console.anthropic.com/settings/keys",
+  helpText: "Create an API key in the Anthropic console.",
+  async validate(credentials) {
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "x-api-key": credentials.apiKey,
+          "anthropic-version": "2023-06-01",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: "claude-3-5-haiku-20241022",
+          max_tokens: 1,
+          messages: [{ role: "user", content: "hi" }]
+        })
+      });
+      if (response.ok || response.status === 429) {
+        return { valid: true, identity: "key verified" };
+      }
+      return {
+        valid: false,
+        error: `Anthropic returned ${response.status}`
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+registerPreset({
+  name: "openai",
+  displayName: "OpenAI",
+  fields: [{ key: "apiKey", label: "API Key", secret: true }],
+  helpUrl: "https://platform.openai.com/api-keys",
+  helpText: "Create an API key at the OpenAI platform link above.",
+  async validate(credentials) {
+    try {
+      const response = await fetch("https://api.openai.com/v1/models", {
+        headers: { Authorization: `Bearer ${credentials.apiKey}` }
+      });
+      if (response.ok || response.status === 429) {
+        return { valid: true, identity: "key verified" };
+      }
+      return {
+        valid: false,
+        error: `OpenAI returned ${response.status}`
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+registerPreset({
+  name: "fal",
+  displayName: "fal.ai",
+  fields: [{ key: "apiKey", label: "API Key", secret: true }],
+  helpUrl: "https://fal.ai/dashboard/keys",
+  helpText: "Generate an API key from your fal.ai dashboard.",
+  async validate(credentials) {
+    try {
+      const response = await fetch("https://rest.fal.run/fal-ai/fast-sdxl", {
+        method: "POST",
+        headers: {
+          Authorization: `Key ${credentials.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          prompt: "test",
+          image_size: { width: 64, height: 64 },
+          num_images: 1
+        })
+      });
+      if (response.ok || response.status === 422 || response.status === 429) {
+        return { valid: true, identity: "key verified" };
+      }
+      return {
+        valid: false,
+        error: `fal.ai returned ${response.status}`
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+registerPreset({
+  name: "generic",
+  displayName: "Custom Credential",
+  fields: [
+    {
+      key: "envName",
+      label: "environment variable name (for example MY_API_KEY)",
+      secret: false
+    },
+    { key: "value", label: "value", secret: true }
+  ],
+  helpUrl: "",
+  helpText: "I'll store this as a generic credential. Give me the env var name and value.",
+  async validate() {
+    return { valid: true, identity: "stored (unvalidated)" };
+  }
+});
+async function ensureCredentialsDir() {
+  await fs2.promises.mkdir(getCredentialsDir(), {
+    recursive: true,
+    mode: 448
+  });
+}
+async function storeCredentials(service, credentials) {
+  await ensureCredentialsDir();
+  const filePath = path.join(getCredentialsDir(), `${service}.json`);
+  await fs2.promises.writeFile(filePath, JSON.stringify(credentials, null, 2), {
+    mode: 384
+  });
+}
+function cleanExpiredSessions() {
+  const now = Date.now();
+  for (const [userId, session] of activeSessions) {
+    if (now - session.startedAt > SESSION_TIMEOUT_MS) {
+      activeSessions.delete(userId);
+    }
+  }
+}
+async function tryDeleteMessage(discordService, channelId, messageId, fieldName) {
+  try {
+    const client = discordService.client;
+    if (!client) {
+      return false;
+    }
+    const channel = await client.channels.fetch(channelId);
+    if (!channel || !("messages" in channel)) {
+      return false;
+    }
+    const message = await channel.messages.fetch(messageId);
+    await message.delete();
+    return true;
+  } catch (error) {
+    logger.warn({
+      src: "setup-credentials",
+      channelId,
+      messageId,
+      fieldName,
+      error: error instanceof Error ? error.message : String(error)
+    }, "Could not delete Discord message containing a credential");
+    return false;
+  }
+}
+var TRIGGER_PATTERNS = [
+  /\bsetup\s+(github|vercel|cloudflare|anthropic|openai|fal|credentials?)\b/i,
+  /\badd\s+(my\s+)?(api\s+)?key\b/i,
+  /\badd\s+credentials?\b/i,
+  /\bconfigure\s+(github|vercel|cloudflare|anthropic|openai|fal)\b/i,
+  /\bconnect\s+(github|vercel|cloudflare|anthropic|openai|fal)\b/i,
+  /^\/setup\b/i
+];
+function detectSetupIntent(text) {
+  const lower = text.toLowerCase().trim();
+  for (const presetName of presets.keys()) {
+    if (presetName === "generic") {
+      continue;
+    }
+    const pattern = new RegExp(`\\b(setup|configure|connect|add)\\s+(my\\s+)?${escapeRegex(presetName)}\\b`, "i");
+    if (pattern.test(lower)) {
+      return presetName;
+    }
+  }
+  const slashMatch = lower.match(/^\/setup\s+(\w+)/);
+  if (slashMatch) {
+    const service = slashMatch[1].toLowerCase();
+    if (presets.has(service)) {
+      return service;
+    }
+    if (service === "custom") {
+      return "generic";
+    }
+  }
+  for (const pattern of TRIGGER_PATTERNS) {
+    if (pattern.test(lower)) {
+      return null;
+    }
+  }
+  return;
+}
+function isSetupTrigger(text) {
+  return TRIGGER_PATTERNS.some((pattern) => pattern.test(text.toLowerCase().trim()));
+}
+function buildServiceListMessage() {
+  const services = listPresets().filter((presetName) => presetName !== "generic").map((presetName) => {
+    const preset = getPreset(presetName);
+    return `- **${preset?.displayName ?? presetName}** (\`${presetName}\`)`;
+  });
+  return [
+    "Which service do you want to set up? Here's what I support:",
+    "",
+    ...services,
+    "- **Custom** (`custom`) - any env var",
+    "",
+    "Just tell me the name, for example `github` or `custom`."
+  ].join(`
+`);
+}
+function resolveDeletionTarget(message, defaultChannelId) {
+  const contentRecord = message.content && typeof message.content === "object" ? message.content : null;
+  const metadataRecord = message.metadata && typeof message.metadata === "object" ? message.metadata : null;
+  const channelId = typeof contentRecord?.channelId === "string" && contentRecord.channelId || typeof metadataRecord?.discordChannelId === "string" && metadataRecord.discordChannelId || defaultChannelId;
+  const messageId = typeof contentRecord?.messageId === "string" && contentRecord.messageId || typeof metadataRecord?.discordMessageId === "string" && metadataRecord.discordMessageId;
+  return { channelId, messageId };
+}
+var setupCredentials = {
+  name: "SETUP_CREDENTIALS",
+  similes: [
+    "ADD_CREDENTIALS",
+    "CONFIGURE_SERVICE",
+    "CONNECT_SERVICE",
+    "ADD_API_KEY",
+    "SETUP_SERVICE"
+  ],
+  description: "Guide the user through setting up API credentials for supported third-party services, validate them when possible, and store them securely.",
+  validate: async (_runtime, message) => {
+    if (message.content.source !== "discord") {
+      return false;
+    }
+    const text = message.content.text?.trim() ?? "";
+    const userId = message.entityId;
+    return activeSessions.has(userId) || isSetupTrigger(text);
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const discordService = runtime.getService(DISCORD_SERVICE_NAME);
+    if (!discordService?.client) {
+      if (callback) {
+        await callback({
+          text: "Discord service isn't available right now.",
+          source: "discord"
+        });
+      }
+      return { success: false, error: "Discord service unavailable" };
+    }
+    const text = message.content.text?.trim() ?? "";
+    const userId = message.entityId;
+    const room = state?.data?.room || await runtime.getRoom(message.roomId);
+    const channelId = room?.channelId || message.roomId;
+    cleanExpiredSessions();
+    let isDm = false;
+    try {
+      const channel = await discordService.client.channels.fetch(channelId);
+      isDm = channel?.type === ChannelType2.DM || channel?.type === ChannelType2.GroupDM;
+    } catch {
+      isDm = false;
+    }
+    if (!isDm && !activeSessions.has(userId)) {
+      if (callback) {
+        await callback({
+          text: "Let's do this in DMs for security. I'll message you there.",
+          source: "discord"
+        });
+      }
+      try {
+        const discordUser = await discordService.client.users.fetch(userId);
+        const dmChannel = await discordUser.createDM();
+        const detectedService2 = detectSetupIntent(text);
+        if (detectedService2 && presets.has(detectedService2)) {
+          const preset = presets.get(detectedService2);
+          if (!preset) {
+            await dmChannel.send(buildServiceListMessage());
+            return {
+              success: false,
+              error: `Unsupported credential preset: ${detectedService2}`
+            };
+          }
+          activeSessions.set(userId, {
+            preset,
+            currentFieldIndex: 0,
+            collected: {},
+            channelId: dmChannel.id,
+            startedAt: Date.now()
+          });
+          const firstField = preset.fields[0];
+          const helpLine = preset.helpUrl ? `Here's where to get one: ${preset.helpUrl}` : "";
+          await dmChannel.send([
+            `Setting up **${preset.displayName}** credentials.`,
+            preset.helpText,
+            helpLine,
+            "",
+            `Please paste your **${firstField.label}** here. ${firstField.secret ? "I'll delete your message right after reading it." : ""}`
+          ].filter(Boolean).join(`
+`));
+        } else {
+          await dmChannel.send(buildServiceListMessage());
+        }
+      } catch (error) {
+        logger.warn({
+          src: "setup-credentials",
+          error: error instanceof Error ? error.message : String(error)
+        }, "Could not open DM with user");
+        if (callback) {
+          await callback({
+            text: "I couldn't send you a DM. Make sure your DMs are open, then try again.",
+            source: "discord"
+          });
+        }
+      }
+      return { success: true, text: "Redirected credential setup to DMs" };
+    }
+    if (activeSessions.has(userId)) {
+      const session = activeSessions.get(userId);
+      if (!session) {
+        return { success: false, error: "Credential session not found" };
+      }
+      const currentField = session.preset.fields[session.currentFieldIndex];
+      if (currentField.secret) {
+        const deletionTarget = resolveDeletionTarget(message, channelId);
+        if (deletionTarget.messageId) {
+          const deleted = await tryDeleteMessage(discordService, deletionTarget.channelId, deletionTarget.messageId, currentField.label);
+          if (!deleted) {
+            logger.warn({
+              src: "setup-credentials",
+              fieldName: currentField.label,
+              channelId: deletionTarget.channelId,
+              messageId: deletionTarget.messageId
+            }, "Credential message could not be deleted automatically");
+          }
+        }
+      }
+      session.collected[currentField.key] = text;
+      session.currentFieldIndex += 1;
+      if (session.currentFieldIndex < session.preset.fields.length) {
+        const nextField = session.preset.fields[session.currentFieldIndex];
+        if (callback) {
+          await callback({
+            text: `Got it. Now paste your **${nextField.label}**${nextField.secret ? " (I'll delete your message)" : ""}.`,
+            source: "discord"
+          });
+        }
+        return { success: true, text: "Collecting next credential field" };
+      }
+      if (callback) {
+        await callback({
+          text: "Validating your credentials...",
+          source: "discord"
+        });
+      }
+      const validation = await session.preset.validate(session.collected);
+      if (validation.valid) {
+        const storageKey = session.preset.name === "generic" ? (session.collected.envName ?? "custom").toLowerCase().replace(/[^a-z0-9_-]/g, "_") : session.preset.name;
+        await storeCredentials(storageKey, session.collected);
+        activeSessions.delete(userId);
+        if (callback) {
+          await callback({
+            text: `Connected${validation.identity ? ` as ${validation.identity}` : ""}. **${session.preset.displayName}** is ready.`,
+            source: "discord"
+          });
+        }
+        return { success: true, text: "Credentials stored" };
+      }
+      activeSessions.delete(userId);
+      if (callback) {
+        await callback({
+          text: `Validation failed: ${validation.error ?? "unknown error"}. Please check your credentials and try again with \`/setup ${session.preset.name}\`.`,
+          source: "discord"
+        });
+      }
+      return {
+        success: false,
+        error: validation.error ?? "Validation failed"
+      };
+    }
+    const detectedService = detectSetupIntent(text);
+    if (detectedService && presets.has(detectedService)) {
+      const preset = presets.get(detectedService);
+      if (!preset) {
+        return {
+          success: false,
+          error: `Unsupported credential preset: ${detectedService}`
+        };
+      }
+      activeSessions.set(userId, {
+        preset,
+        currentFieldIndex: 0,
+        collected: {},
+        channelId,
+        startedAt: Date.now()
+      });
+      const firstField = preset.fields[0];
+      const helpLine = preset.helpUrl ? `Here's where to get one: ${preset.helpUrl}` : "";
+      if (callback) {
+        await callback({
+          text: [
+            `Setting up **${preset.displayName}** credentials.`,
+            preset.helpText,
+            helpLine,
+            "",
+            `Please paste your **${firstField.label}** here. ${firstField.secret ? "I'll delete your message right after reading it." : ""}`
+          ].filter(Boolean).join(`
+`),
+          source: "discord"
+        });
+      }
+      return { success: true, text: `Started ${preset.displayName} setup` };
+    }
+    const serviceName = text.toLowerCase().trim();
+    if (presets.has(serviceName) || serviceName === "custom") {
+      const presetKey = serviceName === "custom" ? "generic" : serviceName;
+      const preset = presets.get(presetKey);
+      if (!preset) {
+        return {
+          success: false,
+          error: `Unsupported credential preset: ${presetKey}`
+        };
+      }
+      activeSessions.set(userId, {
+        preset,
+        currentFieldIndex: 0,
+        collected: {},
+        channelId,
+        startedAt: Date.now()
+      });
+      const firstField = preset.fields[0];
+      const helpLine = preset.helpUrl ? `Here's where to get one: ${preset.helpUrl}` : "";
+      if (callback) {
+        await callback({
+          text: [
+            `Setting up **${preset.displayName}** credentials.`,
+            preset.helpText,
+            helpLine,
+            "",
+            `Please paste your **${firstField.label}** here. ${firstField.secret ? "I'll delete your message right after reading it." : ""}`
+          ].filter(Boolean).join(`
+`),
+          source: "discord"
+        });
+      }
+      return { success: true, text: `Started ${preset.displayName} setup` };
+    }
+    if (callback) {
+      await callback({
+        text: buildServiceListMessage(),
+        source: "discord"
+      });
+    }
+    return { success: true, text: "Showed credential setup service list" };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "setup github" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: `Setting up **GitHub** credentials.
+Create a fine-grained PAT at the link above.
+Here's where to get one: https://github.com/settings/tokens
+
+Please paste your **Personal Access Token** here. I'll delete your message right after reading it.`,
+          action: "SETUP_CREDENTIALS"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "add my vercel key" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: `Setting up **Vercel** credentials.
+Create a token at the link above.
+Here's where to get one: https://vercel.com/account/tokens
+
+Please paste your **API Token** here. I'll delete your message right after reading it.`,
+          action: "SETUP_CREDENTIALS"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "/setup" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Which service do you want to set up? I support GitHub, Vercel, Cloudflare, Anthropic, OpenAI, fal.ai, or a custom credential.",
+          action: "SETUP_CREDENTIALS"
+        }
+      }
+    ]
+  ]
+};
+var setup_credentials_default = setupCredentials;
+
 // actions/summarizeConversation.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import {
   ContentType as ContentType3,
   composePromptFromState as composePromptFromState15,
   getEntityDetails,
-  logger,
+  logger as logger2,
   MemoryType as MemoryType5,
   ModelType as ModelType15,
   parseJSONObjectFromText as parseJSONObjectFromText15,
@@ -6302,7 +6942,7 @@ function parseTimeToTimestamp(input) {
     const milliseconds = value * (multipliers[unit] || 0);
     return Date.now() - milliseconds;
   }
-  logger.warn(`[parseTimeToTimestamp] Could not parse time value, using current time: ${input}`);
+  logger2.warn(`[parseTimeToTimestamp] Could not parse time value, using current time: ${input}`);
   return Date.now();
 }
 var getDateRange = async (runtime, _message, state) => {
@@ -6320,7 +6960,7 @@ var getDateRange = async (runtime, _message, state) => {
         const startRaw = parseTimeToTimestamp(parsedResponse.start);
         const endRaw = parseTimeToTimestamp(parsedResponse.end);
         if (!Number.isFinite(startRaw) || !Number.isFinite(endRaw)) {
-          logger.warn(`[getDateRange] Invalid timestamps parsed: start=${startRaw}, end=${endRaw}, retrying...`);
+          logger2.warn(`[getDateRange] Invalid timestamps parsed: start=${startRaw}, end=${endRaw}, retrying...`);
           continue;
         }
         let start = startRaw <= endRaw ? startRaw : endRaw;
@@ -6533,8 +7173,8 @@ ${currentSummary.trim()}
       const summaryDir = "cache";
       const summaryFilename = `${summaryDir}/conversation_summary_${Date.now()}`;
       await runtime.setCache(summaryFilename, currentSummary);
-      await fs2.promises.mkdir(summaryDir, { recursive: true });
-      await fs2.promises.writeFile(summaryFilename, currentSummary, "utf8");
+      await fs3.promises.mkdir(summaryDir, { recursive: true });
+      await fs3.promises.writeFile(summaryFilename, currentSummary, "utf8");
       if (callback) {
         await callback?.({
           ...callbackData,
@@ -7156,7 +7796,7 @@ function printBanner(options) {
 }
 
 // providers/channelState.ts
-import { ChannelType as ChannelType2 } from "@elizaos/core";
+import { ChannelType as ChannelType3 } from "@elizaos/core";
 
 // types.ts
 var DiscordEventTypes;
@@ -7186,6 +7826,39 @@ var ServiceType2 = {
 
 // providers/channelState.ts
 var spec18 = requireProviderSpec("channelState");
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readString(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeName(value) {
+  return value.trim().toLowerCase();
+}
+function formatDiscordIdentity(displayName, userName) {
+  if (displayName && userName && normalizeName(displayName) !== normalizeName(userName)) {
+    return `${displayName} (discord username: ${userName})`;
+  }
+  return displayName ?? userName ?? "someone";
+}
+function describeCurrentSpeaker(message, fallback) {
+  const metadata = asRecord(message.metadata);
+  const discordMetadata = asRecord(metadata?.discord);
+  const displayName = readString(metadata?.entityName) ?? readString(metadata?.displayName) ?? readString(discordMetadata?.name) ?? readString(discordMetadata?.globalName) ?? readString(fallback);
+  const userName = readString(metadata?.entityUserName) ?? readString(discordMetadata?.userName) ?? readString(discordMetadata?.username);
+  return formatDiscordIdentity(displayName, userName);
+}
+function describeAgentDiscordAccount(agentName, userName) {
+  const candidate = readString(userName);
+  if (!candidate || normalizeName(candidate) === normalizeName(agentName)) {
+    return agentName;
+  }
+  return `${agentName} (discord username: ${candidate})`;
+}
 var channelStateProvider = {
   name: spec18.name,
   dynamic: true,
@@ -7201,15 +7874,17 @@ var channelStateProvider = {
         text: ""
       };
     }
-    const agentName = state?.agentName || "The agent";
-    const senderName = state?.senderName || "someone";
+    const stateRecord = state;
+    const agentName = readString(stateRecord?.agentName) ?? "The agent";
+    const senderName = readString(stateRecord?.senderName) ?? "someone";
+    const senderIdentity = describeCurrentSpeaker(message, senderName);
     let responseText = "";
     let channelType = "";
     let serverName = "";
     const channelId = room.channelId ?? "";
-    if (room.type === ChannelType2.DM) {
+    if (room.type === ChannelType3.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.`;
+      responseText = `${agentName} is currently in a direct message conversation with ${senderIdentity}. ${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 (!channelId) {
@@ -7283,8 +7958,15 @@ var channelStateProvider = {
         };
       }
       serverName = guild.name;
+      const agentIdentity = describeAgentDiscordAccount(agentName, discordService.client?.user?.username);
       responseText = `${agentName} is currently having a conversation in the channel \`#${channel?.name || channelId}\` in the server \`${serverName}\``;
       responseText += `
+The current speaker is ${senderIdentity}.`;
+      if (agentIdentity !== agentName) {
+        responseText += `
+On Discord, ${agentName} is logged in as ${agentIdentity}.`;
+      }
+      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 {
@@ -7453,8 +8135,7 @@ function formatGuildInfoText(guild, info) {
 }
 
 // providers/voiceState.ts
-import { getVoiceConnection } from "@discordjs/voice";
-import { ChannelType as ChannelType3 } from "@elizaos/core";
+import { ChannelType as ChannelType4 } from "@elizaos/core";
 var spec20 = requireProviderSpec("voiceState");
 var voiceStateProvider = {
   name: spec20.name,
@@ -7464,7 +8145,7 @@ var voiceStateProvider = {
     if (!room) {
       throw new Error("No room found");
     }
-    if (room.type !== ChannelType3.GROUP) {
+    if (room.type !== ChannelType4.GROUP) {
       return {
         data: {
           isInVoiceChannel: false,
@@ -7533,7 +8214,7 @@ var voiceStateProvider = {
         text: `${agentName} is not currently in a voice channel`
       };
     }
-    const connection = getVoiceConnection(guildId);
+    const connection = discordService.voiceManager?.getVoiceConnection(guildId);
     if (!connection) {
       return {
         data: {
@@ -7576,17 +8257,21 @@ var voiceStateProvider = {
 
 // service.ts
 import {
-  ChannelType as ChannelType7,
-  createUniqueUuid as createUniqueUuid6,
+  ChannelType as ChannelType8,
+  createUniqueUuid as createUniqueUuid7,
   EventType as EventType3,
   MemoryType as MemoryType7,
   Service,
-  stringToUuid as stringToUuid3
+  stringToUuid as stringToUuid4
 } from "@elizaos/core";
+import {
+  getConnectorAdminWhitelist,
+  setConnectorAdminWhitelist
+} from "@elizaos/core/roles";
 import {
   AttachmentBuilder as AttachmentBuilder2,
   AuditLogEvent,
-  ChannelType as DiscordChannelType5,
+  ChannelType as DiscordChannelType6,
   Client as DiscordJsClient,
   Events,
   GatewayIntentBits,
@@ -7625,6 +8310,171 @@ function createCompatRuntime(runtime) {
   });
 }
 
+// debouncer.ts
+var DEFAULT_DEBOUNCE_MS = 400;
+var DEFAULT_CHANNEL_DEBOUNCE_MS = 3000;
+function escapeRegex2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function runSafely(callback) {
+  try {
+    callback();
+  } catch {}
+}
+function createChannelDebouncer(onFlush, options = {}) {
+  const debounceMs = options.debounceMs ?? DEFAULT_CHANNEL_DEBOUNCE_MS;
+  const responseCooldownMs = options.responseCooldownMs ?? 30000;
+  const botName = options.botName?.trim();
+  const botNameRegex = botName && botName.length >= 2 ? new RegExp(`(^|[^\\p{L}\\p{N}])${escapeRegex2(botName)}(?=$|[^\\p{L}\\p{N}])`, "iu") : null;
+  const pending = new Map;
+  const lastResponseTime = new Map;
+  const isBotTargeted = (message) => {
+    const botId = options.getBotUserId?.() ?? options.botUserId;
+    if (botId && message.mentions?.users?.has(botId)) {
+      return true;
+    }
+    if (botId && message.reference?.messageId && message.mentions?.repliedUser?.id === botId) {
+      return true;
+    }
+    return Boolean(botNameRegex?.test(message.content ?? ""));
+  };
+  const isInCooldown = (channelId) => {
+    const lastRespondedAt = lastResponseTime.get(channelId);
+    if (!lastRespondedAt) {
+      return false;
+    }
+    if (Date.now() - lastRespondedAt >= responseCooldownMs) {
+      lastResponseTime.delete(channelId);
+      return false;
+    }
+    return true;
+  };
+  const flush = (channelId) => {
+    const entry = pending.get(channelId);
+    if (!entry) {
+      return;
+    }
+    clearTimeout(entry.timer);
+    pending.delete(channelId);
+    if (entry.messages.length > 0) {
+      runSafely(() => onFlush(entry.messages));
+    }
+  };
+  const enqueue = (message) => {
+    const channelId = message.channel.id;
+    if (isBotTargeted(message)) {
+      const entry = pending.get(channelId);
+      if (entry) {
+        clearTimeout(entry.timer);
+        pending.delete(channelId);
+        entry.messages.push(message);
+        runSafely(() => onFlush(entry.messages));
+      } else {
+        runSafely(() => onFlush([message]));
+      }
+      return;
+    }
+    if (isInCooldown(channelId)) {
+      return;
+    }
+    if (debounceMs <= 0) {
+      runSafely(() => onFlush([message]));
+      return;
+    }
+    const existing = pending.get(channelId);
+    if (existing) {
+      clearTimeout(existing.timer);
+      existing.messages.push(message);
+      existing.timer = setTimeout(() => flush(channelId), debounceMs);
+      return;
+    }
+    pending.set(channelId, {
+      messages: [message],
+      timer: setTimeout(() => flush(channelId), debounceMs)
+    });
+  };
+  return {
+    enqueue,
+    markResponded: (channelId) => {
+      lastResponseTime.set(channelId, Date.now());
+    },
+    flushAll: () => {
+      for (const key of [...pending.keys()]) {
+        flush(key);
+      }
+    },
+    pendingCount: () => pending.size,
+    destroy: () => {
+      for (const [, entry] of pending) {
+        clearTimeout(entry.timer);
+      }
+      pending.clear();
+      lastResponseTime.clear();
+    }
+  };
+}
+function createMessageDebouncer(onFlush, debounceMs = DEFAULT_DEBOUNCE_MS) {
+  const pending = new Map;
+  const makeKey = (message) => `${message.channel.id}:${message.author.id}`;
+  const flush = (key) => {
+    const entry = pending.get(key);
+    if (!entry) {
+      return;
+    }
+    clearTimeout(entry.timer);
+    pending.delete(key);
+    if (entry.messages.length > 0) {
+      runSafely(() => onFlush(entry.messages));
+    }
+  };
+  const hasMedia = (message) => (message.attachments?.size ?? 0) > 0 || (message.stickers?.size ?? 0) > 0;
+  const enqueue = (message) => {
+    if (debounceMs <= 0) {
+      runSafely(() => onFlush([message]));
+      return;
+    }
+    const key = makeKey(message);
+    if (hasMedia(message)) {
+      const entry = pending.get(key);
+      if (entry) {
+        clearTimeout(entry.timer);
+        pending.delete(key);
+        if (entry.messages.length > 0) {
+          runSafely(() => onFlush(entry.messages));
+        }
+      }
+      runSafely(() => onFlush([message]));
+      return;
+    }
+    const existing = pending.get(key);
+    if (existing) {
+      clearTimeout(existing.timer);
+      existing.messages.push(message);
+      existing.timer = setTimeout(() => flush(key), debounceMs);
+      return;
+    }
+    pending.set(key, {
+      messages: [message],
+      timer: setTimeout(() => flush(key), debounceMs)
+    });
+  };
+  return {
+    enqueue,
+    flushAll: () => {
+      for (const key of [...pending.keys()]) {
+        flush(key);
+      }
+    },
+    pendingCount: () => pending.size,
+    destroy: () => {
+      for (const [, entry] of pending) {
+        clearTimeout(entry.timer);
+      }
+      pending.clear();
+    }
+  };
+}
+
 // environment.ts
 import { parseBooleanFromText } from "@elizaos/core";
 import { z } from "zod";
@@ -7647,8 +8497,9 @@ var DISCORD_DEFAULTS = {
   SHOULD_IGNORE_DIRECT_MESSAGES: getEnvBoolean("DISCORD_SHOULD_IGNORE_DIRECT_MESSAGES", false),
   SHOULD_RESPOND_ONLY_TO_MENTIONS: getEnvBoolean("DISCORD_SHOULD_RESPOND_ONLY_TO_MENTIONS", false),
   ALLOWED_CHANNEL_IDS: getEnvArray("CHANNEL_IDS", []),
-  DM_POLICY: process.env?.DISCORD_DM_POLICY || "open",
-  ALLOW_FROM: getEnvArray("DISCORD_ALLOW_FROM", [])
+  DM_POLICY: process.env?.DISCORD_DM_POLICY || "pairing",
+  ALLOW_FROM: getEnvArray("DISCORD_ALLOW_FROM", []),
+  SYNC_PROFILE: getEnvBoolean("DISCORD_SYNC_PROFILE", true)
 };
 var discordEnvSchema = z.object({
   DISCORD_API_TOKEN: z.string().min(1, "Discord API token is required"),
@@ -7681,50 +8532,128 @@ function getDiscordSettings(runtime) {
       }
       return DISCORD_DEFAULTS.DM_POLICY;
     }),
-    allowFrom: resolveSetting("DISCORD_ALLOW_FROM", characterSettings.allowFrom, DISCORD_DEFAULTS.ALLOW_FROM, (value) => value.split(",").map((s) => s.trim()).filter((s) => s.length > 0))
+    allowFrom: resolveSetting("DISCORD_ALLOW_FROM", characterSettings.allowFrom, DISCORD_DEFAULTS.ALLOW_FROM, (value) => value.split(",").map((s) => s.trim()).filter((s) => s.length > 0)),
+    syncProfile: resolveSetting("DISCORD_SYNC_PROFILE", characterSettings.syncProfile, DISCORD_DEFAULTS.SYNC_PROFILE, parseBooleanFromText),
+    profileName: resolveSetting("DISCORD_PROFILE_NAME", characterSettings.profileName, undefined, (value) => value.trim()),
+    profileAvatar: resolveSetting("DISCORD_PROFILE_AVATAR", characterSettings.profileAvatar, undefined, (value) => value.trim())
   };
 }
 
 // identity.ts
 import {
   createUniqueUuid as createUniqueUuid3,
-  Role
+  Role,
+  stringToUuid
 } from "@elizaos/core";
-var CANONICAL_OWNER_SETTING_KEY = "MILADY_ADMIN_ENTITY_ID";
+var CANONICAL_OWNER_SETTING_KEYS = [
+  "ELIZA_ADMIN_ENTITY_ID",
+  "MILADY_ADMIN_ENTITY_ID"
+];
+var DISCORD_SNOWFLAKE_PATTERN = /^\d{15,20}$/;
 function getCanonicalOwnerId(runtime) {
-  const value = runtime.getSetting?.(CANONICAL_OWNER_SETTING_KEY);
+  for (const key of CANONICAL_OWNER_SETTING_KEYS) {
+    const value = runtime.getSetting?.(key);
+    if (typeof value !== "string") {
+      continue;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  return;
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readDiscordSnowflake(value) {
   if (typeof value !== "string") {
-    return;
+    return null;
   }
   const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
+  return DISCORD_SNOWFLAKE_PATTERN.test(trimmed) ? trimmed : null;
 }
-function buildDiscordWorldMetadata(runtime, guildOwnerId) {
-  const ownerId = getCanonicalOwnerId(runtime);
-  if (ownerId) {
-    return {
-      ownership: { ownerId },
-      roles: {
-        [ownerId]: Role.OWNER
-      }
-    };
+function readUserIdFromOwnerLike(value) {
+  const owner = asRecord2(value);
+  if (!owner) {
+    return null;
   }
-  if (!guildOwnerId) {
-    return;
+  return readDiscordSnowflake(owner.id) ?? readDiscordSnowflake(asRecord2(owner.user)?.id) ?? readDiscordSnowflake(owner.ownerId) ?? readDiscordSnowflake(owner.ownerUserId);
+}
+function resolveMiladyOwnerEntityId(runtime) {
+  const configuredOwnerId = getCanonicalOwnerId(runtime);
+  if (configuredOwnerId) {
+    return configuredOwnerId;
+  }
+  const agentName = runtime.character?.name?.trim() || runtime.agentId;
+  return stringToUuid(`${agentName}-admin-entity`);
+}
+function resolveDiscordRuntimeEntityId(runtime, userId, ownerDiscordUserIds = []) {
+  for (const ownerUserId of ownerDiscordUserIds) {
+    if (ownerUserId === userId) {
+      return resolveMiladyOwnerEntityId(runtime);
+    }
+  }
+  return createUniqueUuid3(runtime, userId);
+}
+function extractDiscordOwnerUserIds(application) {
+  const applicationRecord = asRecord2(application);
+  if (!applicationRecord) {
+    return [];
+  }
+  const ownerCandidates = new Set;
+  const directOwnerId = readUserIdFromOwnerLike(applicationRecord.owner);
+  if (directOwnerId) {
+    ownerCandidates.add(directOwnerId);
+  }
+  const team = asRecord2(applicationRecord.team);
+  const teamOwnerId = readDiscordSnowflake(team?.ownerId) ?? readDiscordSnowflake(team?.ownerUserId);
+  if (teamOwnerId) {
+    ownerCandidates.add(teamOwnerId);
   }
-  const discordOwnerId = createUniqueUuid3(runtime, guildOwnerId);
+  const teamMembers = team?.members;
+  if (Array.isArray(teamMembers)) {
+    for (const member of teamMembers) {
+      const memberId = readUserIdFromOwnerLike(member);
+      if (memberId) {
+        ownerCandidates.add(memberId);
+      }
+    }
+  }
+  return [...ownerCandidates];
+}
+function parseDiscordOwnerUserIds(value) {
+  const rawValues = (() => {
+    if (Array.isArray(value)) {
+      return value;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(value);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  })();
+  return rawValues.map((entry) => readDiscordSnowflake(entry)).filter((entry) => Boolean(entry));
+}
+function buildDiscordWorldMetadata(runtime, _guildOwnerId) {
+  const ownerId = resolveMiladyOwnerEntityId(runtime);
   return {
-    ownership: { ownerId: discordOwnerId },
+    ownership: { ownerId },
     roles: {
-      [discordOwnerId]: Role.OWNER
+      [ownerId]: Role.OWNER
     }
   };
 }
-function buildDiscordEntityMetadata(userId, userName, name, globalName) {
+function buildDiscordEntityMetadata(userId, userName, name, globalName, avatarUrl) {
   return {
     default: {
       username: userName,
-      name
+      name,
+      ...typeof avatarUrl === "string" && avatarUrl.length > 0 ? { avatarUrl } : {}
     },
     discord: {
       id: userId,
@@ -7732,33 +8661,35 @@ function buildDiscordEntityMetadata(userId, userName, name, globalName) {
       userName,
       username: userName,
       name,
-      ...typeof globalName === "string" && globalName.length > 0 ? { globalName } : {}
+      ...typeof globalName === "string" && globalName.length > 0 ? { globalName } : {},
+      ...typeof avatarUrl === "string" && avatarUrl.length > 0 ? { avatarUrl } : {}
     },
     originalId: userId,
     username: userName,
-    displayName: name
+    displayName: name,
+    ...typeof avatarUrl === "string" && avatarUrl.length > 0 ? { avatarUrl } : {}
   };
 }
 
 // messages.ts
 import {
-  ChannelType as ChannelType5,
+  ChannelType as ChannelType6,
   checkPairingAllowed,
   createUniqueUuid as createUniqueUuid4,
   EventType,
   isInAllowlist,
   ServiceType as ServiceType4,
-  stringToUuid
+  stringToUuid as stringToUuid2
 } from "@elizaos/core";
 import {
   AttachmentBuilder,
-  ChannelType as DiscordChannelType3
+  ChannelType as DiscordChannelType4
 } from "discord.js";
 
 // attachments.ts
-import fs3 from "node:fs";
-import os from "node:os";
-import path from "node:path";
+import fs4 from "node:fs";
+import os2 from "node:os";
+import path2 from "node:path";
 import {
   ModelType as ModelType19,
   ServiceType as ServiceType3
@@ -7768,7 +8699,7 @@ import ffmpeg from "fluent-ffmpeg";
 
 // utils.ts
 import {
-  logger as logger2,
+  logger as logger3,
   ModelType as ModelType18,
   parseJSONObjectFromText as parseJSONObjectFromText18,
   trimTokens as trimTokens3
@@ -7776,13 +8707,13 @@ import {
 import {
   ActionRowBuilder,
   ButtonBuilder,
-  ChannelType as ChannelType4,
+  ChannelType as ChannelType5,
   PermissionsBitField as PermissionsBitField4,
   StringSelectMenuBuilder,
   ThreadChannel
 } from "discord.js";
 function hasMessagingAPI(runtime) {
-  return "elizaOS" in runtime && typeof runtime.elizaOS === "object" && runtime.elizaOS !== null && typeof runtime.elizaOS.sendMessage === "function";
+  return "elizaOS" in runtime && typeof runtime.elizaOS === "object" && runtime.elizaOS !== null && (typeof runtime.elizaOS.handleMessage === "function" || typeof runtime.elizaOS.sendMessage === "function");
 }
 function hasMessageService(runtime) {
   return runtime.messageService !== null && typeof runtime.messageService?.handleMessage === "function";
@@ -7800,6 +8731,59 @@ function getMessageService(runtime) {
   return null;
 }
 var MAX_MESSAGE_LENGTH = 1900;
+function collectStructuredText(value, seen) {
+  if (typeof value === "string") {
+    return value.trim() ? [value] : [];
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return [String(value)];
+  }
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+  if (seen.has(value)) {
+    return [];
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => collectStructuredText(entry, seen));
+  }
+  const record = value;
+  for (const key of ["text", "responseText", "message", "body"]) {
+    const normalized = collectStructuredText(record[key], seen);
+    if (normalized.length > 0) {
+      return normalized;
+    }
+  }
+  for (const key of [
+    "content",
+    "parts",
+    "blocks",
+    "items",
+    "segments"
+  ]) {
+    const normalized = collectStructuredText(record[key], seen);
+    if (normalized.length > 0) {
+      return normalized;
+    }
+  }
+  for (const key of ["title", "summary"]) {
+    const normalized = collectStructuredText(record[key], seen);
+    if (normalized.length > 0) {
+      return normalized;
+    }
+  }
+  return [];
+}
+function normalizeDiscordMessageText(value) {
+  const fragments = collectStructuredText(value, new Set).map((fragment) => fragment.trim()).filter((fragment) => fragment.length > 0);
+  if (fragments.length === 0) {
+    return "";
+  }
+  return fragments.join(`
+
+`);
+}
 function cleanUrl(url) {
   let clean = url;
   clean = clean.replace(/\\([._\-~])/g, "$1");
@@ -7923,6 +8907,13 @@ async function generateSummary(runtime, text) {
 function isDiscordAPIError(error) {
   return error instanceof Error && "code" in error;
 }
+function isReplyReferenceFailure(error) {
+  if (!isDiscordAPIError(error)) {
+    return false;
+  }
+  const errorMessage = error.message.toLowerCase();
+  return error.code === 10008 || errorMessage.includes("unknown message") || errorMessage.includes("message reference") || errorMessage.includes("message_reference");
+}
 function isDiscordJsComponent(component) {
   return component !== null && typeof component === "object" && "toJSON" in component && typeof component.toJSON === "function";
 }
@@ -7934,16 +8925,20 @@ function safeStringify(obj) {
 }
 async function sendMessageInChunks(channel, content, inReplyTo, files, components, runtime) {
   const sentMessages = [];
+  let lastSendError = null;
   let messages;
   if (runtime && content.length > MAX_MESSAGE_LENGTH && needsSmartSplit(content)) {
     messages = await smartSplitMessage(runtime, content);
   } else {
     messages = splitMessage(content);
   }
+  if (messages.length === 0 && (files && files.length > 0 || components && components.length > 0)) {
+    messages = [""];
+  }
   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 || components) {
+      if (message.trim().length > 0 || i === messages.length - 1 && files && files.length > 0 || i === messages.length - 1 && components && components.length > 0) {
         const options = {
           content: message.trim()
         };
@@ -7957,26 +8952,26 @@ async function sendMessageInChunks(channel, content, inReplyTo, files, component
         }
         if (i === messages.length - 1 && components && components.length > 0) {
           try {
-            logger2.info(`Components received: ${safeStringify(components)}`);
+            logger3.info(`Components received: ${safeStringify(components)}`);
             if (!Array.isArray(components)) {
-              logger2.warn("Components is not an array, skipping component processing");
+              logger3.warn("Components is not an array, skipping component processing");
             } else if (isDiscordJsComponentArray(components)) {
               options.components = components;
             } else {
               const discordComponents = components.map((row) => {
                 if (!row || typeof row !== "object" || row.type !== 1) {
-                  logger2.warn("Invalid component row structure, skipping");
+                  logger3.warn("Invalid component row structure, skipping");
                   return null;
                 }
                 if (row.type === 1) {
                   const actionRow = new ActionRowBuilder;
                   if (!Array.isArray(row.components)) {
-                    logger2.warn("Row components is not an array, skipping");
+                    logger3.warn("Row components is not an array, skipping");
                     return null;
                   }
                   const validComponents = row.components.map((comp) => {
                     if (!comp || typeof comp !== "object") {
-                      logger2.warn("Invalid component, skipping");
+                      logger3.warn("Invalid component, skipping");
                       return null;
                     }
                     try {
@@ -8001,7 +8996,7 @@ async function sendMessageInChunks(channel, content, inReplyTo, files, component
                         return selectMenu;
                       }
                     } catch (err) {
-                      logger2.error(`Error creating component: ${err}`);
+                      logger3.error(`Error creating component: ${err}`);
                       return null;
                     }
                     return null;
@@ -8018,15 +9013,15 @@ async function sendMessageInChunks(channel, content, inReplyTo, files, component
               }
             }
           } catch (error) {
-            logger2.error(`Error processing components: ${error}`);
+            logger3.error(`Error processing components: ${error}`);
           }
         }
         try {
           const m = await channel.send(options);
           sentMessages.push(m);
         } catch (error) {
-          if (isDiscordAPIError(error) && error.code === 50035 && error.message && error.message.includes("Unknown message")) {
-            logger2.warn("Message reference no longer valid (message may have been deleted). Sending without reply threading.");
+          if (isReplyReferenceFailure(error) && options.reply) {
+            logger3.warn("Message reference no longer valid (message may have been deleted). Sending without reply threading.");
             const optionsWithoutReply = { ...options };
             delete optionsWithoutReply.reply;
             try {
@@ -8034,17 +9029,27 @@ async function sendMessageInChunks(channel, content, inReplyTo, files, component
               sentMessages.push(m);
             } catch (retryError) {
               const errorMessage = retryError instanceof Error ? retryError.message : String(retryError);
-              logger2.error(`Error sending message after removing reply reference: ${errorMessage}`);
+              lastSendError = retryError;
+              logger3.error(`Error sending message after removing reply reference: ${errorMessage}`);
               throw retryError;
             }
           } else {
+            lastSendError = error;
             throw error;
           }
         }
       }
     }
   } catch (error) {
-    logger2.error(`Error sending message: ${error}`);
+    lastSendError = error;
+    logger3.error(`Error sending message: ${error}`);
+  }
+  const attemptedSend = content.trim().length > 0 || files && files.length > 0 || components && components.length > 0;
+  if (attemptedSend && sentMessages.length === 0) {
+    if (lastSendError instanceof Error) {
+      throw lastSendError;
+    }
+    throw new Error("Discord message send completed without delivering any chunks");
   }
   return sentMessages;
 }
@@ -8165,7 +9170,7 @@ function canSendMessage(channel) {
       reason: "No channel given"
     };
   }
-  if (channel.type === ChannelType4.DM) {
+  if (channel.type === ChannelType5.DM) {
     return {
       canSend: true,
       reason: null
@@ -8346,12 +9351,12 @@ class AttachmentManager {
     }
   }
   async extractAudioFromMP4(mp4Data) {
-    const tmpDir = os.tmpdir();
+    const tmpDir = os2.tmpdir();
     const timestamp = Date.now();
-    const tempMP4File = path.join(tmpDir, `discord_video_${timestamp}.mp4`);
-    const tempAudioFile = path.join(tmpDir, `discord_audio_${timestamp}.mp3`);
+    const tempMP4File = path2.join(tmpDir, `discord_video_${timestamp}.mp4`);
+    const tempAudioFile = path2.join(tmpDir, `discord_audio_${timestamp}.mp3`);
     try {
-      fs3.writeFileSync(tempMP4File, Buffer.from(mp4Data));
+      fs4.writeFileSync(tempMP4File, Buffer.from(mp4Data));
       await new Promise((resolve, reject) => {
         ffmpeg.ffprobe(tempMP4File, (err, metadata) => {
           if (err) {
@@ -8383,7 +9388,7 @@ class AttachmentManager {
           reject(err);
         }).output(tempAudioFile).run();
       });
-      const audioData = fs3.readFileSync(tempAudioFile);
+      const audioData = fs4.readFileSync(tempAudioFile);
       this.runtime.logger.debug({
         src: "plugin:discord",
         agentId: this.runtime.agentId,
@@ -8392,11 +9397,11 @@ class AttachmentManager {
       return audioData;
     } finally {
       try {
-        if (fs3.existsSync(tempMP4File)) {
-          fs3.unlinkSync(tempMP4File);
+        if (fs4.existsSync(tempMP4File)) {
+          fs4.unlinkSync(tempMP4File);
         }
-        if (fs3.existsSync(tempAudioFile)) {
-          fs3.unlinkSync(tempAudioFile);
+        if (fs4.existsSync(tempAudioFile)) {
+          fs4.unlinkSync(tempAudioFile);
         }
       } catch (cleanupError) {
         this.runtime.logger.warn({
@@ -8562,99 +9567,614 @@ class AttachmentManager {
   }
 }
 
-// messages.ts
-class MessageManager {
-  client;
-  runtime;
-  attachmentManager;
-  getChannelType;
-  discordSettings;
-  discordService;
-  constructor(discordService, runtime) {
-    if (!discordService.client) {
-      const errorMsg = "Discord client not initialized - cannot create MessageManager";
-      runtime.logger.error({ src: "plugin:discord", agentId: runtime.agentId }, errorMsg);
-      throw new Error(errorMsg);
-    }
-    this.client = discordService.client;
-    this.runtime = runtime;
-    this.attachmentManager = new AttachmentManager(this.runtime);
-    this.getChannelType = discordService.getChannelType;
-    this.discordService = discordService;
-    this.discordSettings = getDiscordSettings(this.runtime);
+// draft-chunking.ts
+var DEFAULT_DRAFT_CHUNK_CONFIG = {
+  minChars: 80,
+  maxChars: 1900,
+  breakPreference: "sentence"
+};
+function findBreakPoint(text, maxLen, breakPreference = "sentence") {
+  if (text.length <= maxLen) {
+    return text.length;
   }
-  async checkDmAccess(message) {
-    const policy = this.discordSettings.dmPolicy ?? "open";
-    const userId = message.author.id;
-    if (policy === "disabled") {
-      this.runtime.logger.debug({
-        src: "plugin:discord",
-        agentId: this.runtime.agentId,
-        userId
-      }, "DM blocked: policy is disabled");
-      return { allowed: false };
-    }
-    if (policy === "open") {
-      return { allowed: true };
+  const region = text.slice(0, maxLen);
+  if (breakPreference === "paragraph" || breakPreference === "newline") {
+    const paragraphBreak = region.lastIndexOf(`
+
+`);
+    if (paragraphBreak > maxLen * 0.3) {
+      return paragraphBreak + 2;
     }
-    if (policy === "allowlist") {
-      if (this.discordSettings.allowFrom?.includes(userId)) {
-        return { allowed: true };
-      }
-      const inDynamicAllowlist = await isInAllowlist(this.runtime, "discord", userId);
-      if (inDynamicAllowlist) {
-        return { allowed: true };
-      }
-      this.runtime.logger.debug({
-        src: "plugin:discord",
-        agentId: this.runtime.agentId,
-        userId
-      }, "DM blocked: user not in allowlist");
-      return { allowed: false };
+  }
+  if (breakPreference !== "sentence") {
+    const newlineBreak = region.lastIndexOf(`
+`);
+    if (newlineBreak > maxLen * 0.3) {
+      return newlineBreak + 1;
     }
-    if (policy === "pairing") {
-      if (this.discordSettings.allowFrom?.includes(userId)) {
-        return { allowed: true };
-      }
-      const result = await checkPairingAllowed(this.runtime, {
-        channel: "discord",
-        senderId: userId,
-        metadata: {
-          username: message.author.username,
-          displayName: message.author.displayName ?? message.author.username,
-          discriminator: message.author.discriminator ?? ""
-        }
-      });
-      if (result.allowed) {
-        return { allowed: true };
-      }
-      this.runtime.logger.debug({
-        src: "plugin:discord",
-        agentId: this.runtime.agentId,
-        userId,
-        pairingCode: result.pairingCode,
-        newRequest: result.newRequest
-      }, "DM blocked: pairing required");
-      return {
-        allowed: false,
-        replyMessage: result.newRequest ? result.replyMessage : undefined
-      };
+  }
+  const sentenceMatch = region.match(/[.!?]\s+(?=[A-Z])/g);
+  if (sentenceMatch) {
+    const lastSentenceEnd = region.lastIndexOf(sentenceMatch[sentenceMatch.length - 1]);
+    if (lastSentenceEnd > maxLen * 0.3) {
+      return lastSentenceEnd + sentenceMatch[sentenceMatch.length - 1].length;
     }
-    return { allowed: true };
   }
-  async handleMessage(message) {
-    const clientUser = this.client.user;
-    if (message.interaction || clientUser && message.author.id === clientUser.id) {
-      return;
+  const simpleSentenceBreak = region.lastIndexOf(". ");
+  if (simpleSentenceBreak > maxLen * 0.3) {
+    return simpleSentenceBreak + 2;
+  }
+  const wordBreak = region.lastIndexOf(" ");
+  if (wordBreak > maxLen * 0.5) {
+    return wordBreak + 1;
+  }
+  return maxLen;
+}
+
+// draft-stream.ts
+var DEFAULT_THROTTLE_MS = 1200;
+var DEFAULT_MIN_INITIAL_CHARS = 40;
+var DISCORD_MAX_CHARS = 2000;
+function createDraftStreamController(options = {}) {
+  const throttleMs = Math.max(250, options.throttleMs ?? DEFAULT_THROTTLE_MS);
+  const minInitialChars = options.minInitialChars ?? DEFAULT_MIN_INITIAL_CHARS;
+  const maxChars = Math.min(options.maxChars ?? 1900, DISCORD_MAX_CHARS);
+  const log = options.log ?? (() => {});
+  const warn = options.warn ?? (() => {});
+  let channel = null;
+  let draftMessage = null;
+  let lastSentText = "";
+  let pendingText = null;
+  let throttleTimer = null;
+  let started = false;
+  let done = false;
+  const clearThrottle = () => {
+    if (throttleTimer) {
+      clearTimeout(throttleTimer);
+      throttleTimer = null;
     }
-    if (this.discordSettings.shouldIgnoreBotMessages && message.author && message.author.bot) {
-      return;
+  };
+  const sendOrEdit = async (text) => {
+    if (done || !channel) {
+      return false;
     }
-    if (this.discordSettings.shouldIgnoreDirectMessages && message.channel.type === DiscordChannelType3.DM) {
-      return;
+    const trimmed = text.trimEnd();
+    if (!trimmed) {
+      return false;
     }
-    if (message.channel.type === DiscordChannelType3.DM) {
-      const accessCheck = await this.checkDmAccess(message);
+    const displayText = trimmed.length > maxChars ? `${trimmed.slice(0, maxChars - 3)}...` : trimmed;
+    if (displayText === lastSentText) {
+      return true;
+    }
+    try {
+      if (draftMessage) {
+        await draftMessage.edit({ content: displayText });
+      } else {
+        warn("draft-stream: sendOrEdit called before start, sending new message");
+        draftMessage = await channel.send({ content: displayText });
+      }
+      lastSentText = displayText;
+      return true;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("Unknown Message") || errorMessage.includes("10008")) {
+        warn("draft-stream: message was deleted externally, stopping");
+        done = true;
+        return false;
+      }
+      warn(`draft-stream: edit failed: ${errorMessage}`);
+      return false;
+    }
+  };
+  const flush = async () => {
+    clearThrottle();
+    if (pendingText !== null) {
+      const text = pendingText;
+      pendingText = null;
+      await sendOrEdit(text);
+    }
+  };
+  const scheduleUpdate = (text) => {
+    pendingText = text;
+    if (!throttleTimer) {
+      throttleTimer = setTimeout(async () => {
+        throttleTimer = null;
+        await flush();
+      }, throttleMs);
+    }
+  };
+  const start = async (nextChannel, replyToMessageId) => {
+    if (started) {
+      warn("draft-stream: start() called twice, ignoring");
+      return draftMessage;
+    }
+    started = true;
+    channel = nextChannel;
+    try {
+      const sendOptions = { content: "..." };
+      if (replyToMessageId) {
+        sendOptions.reply = { messageReference: replyToMessageId };
+      }
+      draftMessage = await nextChannel.send(sendOptions);
+      lastSentText = "...";
+      log(`draft-stream: started (messageId=${draftMessage.id}, throttle=${throttleMs}ms)`);
+      return draftMessage;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      warn(`draft-stream: failed to send initial message: ${errorMessage}`);
+      done = true;
+      return null;
+    }
+  };
+  const update = (text) => {
+    if (done || !started) {
+      return;
+    }
+    if (draftMessage && lastSentText === "..." && text.length < minInitialChars) {
+      return;
+    }
+    scheduleUpdate(text);
+  };
+  const finalize = async (text) => {
+    if (done) {
+      return draftMessage ? [draftMessage] : [];
+    }
+    clearThrottle();
+    pendingText = null;
+    if (!started || !draftMessage) {
+      warn("draft-stream: finalize called before start");
+      done = true;
+      return [];
+    }
+    const trimmed = text.trimEnd();
+    if (!trimmed) {
+      try {
+        await draftMessage.delete();
+      } catch {}
+      done = true;
+      return [];
+    }
+    if (trimmed.length <= maxChars) {
+      await sendOrEdit(trimmed);
+      done = true;
+      log("draft-stream: finalized (single message)");
+      return [draftMessage];
+    }
+    const chunkConfig = {
+      ...DEFAULT_DRAFT_CHUNK_CONFIG,
+      ...options.chunkConfig
+    };
+    const breakPoint = findBreakPoint(trimmed, maxChars, chunkConfig.breakPreference);
+    const firstChunk = trimmed.slice(0, breakPoint).trimEnd();
+    let remaining = trimmed.slice(breakPoint).trimStart();
+    await sendOrEdit(firstChunk);
+    const allMessages = [draftMessage];
+    while (remaining.length > 0 && channel) {
+      const nextBreak = findBreakPoint(remaining, maxChars, chunkConfig.breakPreference);
+      const chunk = remaining.slice(0, nextBreak).trimEnd();
+      remaining = remaining.slice(nextBreak).trimStart();
+      if (!chunk) {
+        continue;
+      }
+      try {
+        const overflowMessage = await channel.send({ content: chunk });
+        allMessages.push(overflowMessage);
+      } catch (error) {
+        warn(`draft-stream: overflow send failed: ${error instanceof Error ? error.message : String(error)}`);
+        break;
+      }
+    }
+    done = true;
+    log("draft-stream: finalized (multi-message)");
+    return allMessages;
+  };
+  const abort = async (reason) => {
+    if (done) {
+      return;
+    }
+    done = true;
+    clearThrottle();
+    pendingText = null;
+    if (!draftMessage) {
+      return;
+    }
+    const errorText = reason ? `⚠️ ${reason}` : "⚠️ Response generation was interrupted.";
+    try {
+      await draftMessage.edit({ content: errorText });
+    } catch {
+      try {
+        await draftMessage.delete();
+      } catch {}
+    }
+    log("draft-stream: aborted");
+  };
+  return {
+    start,
+    update,
+    finalize,
+    abort,
+    messageId: () => draftMessage?.id,
+    isStarted: () => started,
+    isDone: () => done
+  };
+}
+
+// inbound-envelope.ts
+import {
+  ChannelType as DiscordChannelType3
+} from "discord.js";
+var WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function formatTimestamp(timestamp) {
+  const date = timestamp instanceof Date ? timestamp : new Date(timestamp);
+  const weekday = WEEKDAYS[date.getDay()];
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const year = date.getFullYear();
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  let timezone = "UTC";
+  try {
+    timezone = date.toLocaleTimeString("en-US", { timeZoneName: "short" }).split(" ").pop() ?? "UTC";
+  } catch {}
+  return `${weekday} ${month}/${day}/${year} ${hours}:${minutes} ${timezone}`;
+}
+function detectChatType(message) {
+  const channelType = message.channel.type;
+  if (channelType === DiscordChannelType3.DM || channelType === DiscordChannelType3.GroupDM) {
+    return "dm";
+  }
+  if (channelType === DiscordChannelType3.PublicThread || channelType === DiscordChannelType3.PrivateThread || channelType === DiscordChannelType3.AnnouncementThread) {
+    const thread = message.channel;
+    if (thread.parent?.type === DiscordChannelType3.GuildForum) {
+      return "forum";
+    }
+    return "thread";
+  }
+  return "channel";
+}
+function getSenderName(message) {
+  if (message.member?.nickname) {
+    return message.member.nickname;
+  }
+  if (message.author.globalName) {
+    return message.author.globalName;
+  }
+  return message.author.displayName ?? message.author.username;
+}
+function buildChannelLabel(message, chatType) {
+  if (chatType === "dm") {
+    return "DM";
+  }
+  const guildName = message.guild?.name;
+  let channelPart;
+  if (chatType === "thread" || chatType === "forum") {
+    const thread = message.channel;
+    channelPart = `#${thread.parent?.name ?? "unknown"} › ${thread.name ?? "thread"}`;
+  } else {
+    const channel = message.channel;
+    channelPart = `#${channel.name ?? message.channel.id}`;
+  }
+  return guildName ? `${channelPart} | ${guildName}` : channelPart;
+}
+async function formatInboundEnvelope(message, rawContent) {
+  const chatType = detectChatType(message);
+  const channelLabel = buildChannelLabel(message, chatType);
+  const senderName = getSenderName(message);
+  const timestamp = formatTimestamp(message.createdTimestamp ?? Date.now());
+  let replyContext = "";
+  if (message.reference?.messageId) {
+    try {
+      const refMessage = await message.fetchReference();
+      const refAuthor = refMessage.author?.displayName ?? refMessage.author?.username ?? "unknown";
+      const refContent = refMessage.content ?? "";
+      const truncated = refContent.length > 200 ? `${refContent.slice(0, 200)}...` : refContent;
+      replyContext = truncated ? ` replying to @${refAuthor}:
+> ${truncated}
+` : ` replying to @${refAuthor}:
+`;
+    } catch {}
+  }
+  const header = `[Discord ${channelLabel}] @${senderName} (${timestamp})`;
+  return {
+    formattedContent: replyContext ? `${header}${replyContext}${rawContent}` : `${header}: ${rawContent}`,
+    chatType
+  };
+}
+
+// reasoning-tags.ts
+var REASONING_TAGS = [
+  "thinking",
+  "reasoning",
+  "reflection",
+  "scratchpad",
+  "thought",
+  "antthinking"
+];
+var SELF_CLOSING_ARTIFACTS_RE = /<(?:STOP|END|end_turn|eot_id)\s*\/?>|<\|(?:end|stop|im_end|eot_id)\|>/gi;
+var QUICK_TAG_RE = /<\/?(?:thinking|reasoning|reflection|scratchpad|thought|antthinking|final|STOP|END|end_turn)\b|<\|(?:end|stop|im_end)/i;
+var CODE_BLOCK_RE = /```[\s\S]*?```/g;
+var PLACEHOLDER_PREFIX = "\x00CB";
+function stripReasoningTags(text) {
+  if (!text || !QUICK_TAG_RE.test(text)) {
+    return text;
+  }
+  const codeBlocks = [];
+  let processed = text.replace(CODE_BLOCK_RE, (match) => {
+    const index = codeBlocks.length;
+    codeBlocks.push(match);
+    return `${PLACEHOLDER_PREFIX}${index}${PLACEHOLDER_PREFIX}`;
+  });
+  processed = processed.replace(SELF_CLOSING_ARTIFACTS_RE, "");
+  for (const tag of REASONING_TAGS) {
+    const paired = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, "gi");
+    processed = processed.replace(paired, "");
+    const unclosed = new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*$`, "gi");
+    processed = processed.replace(unclosed, "");
+  }
+  processed = processed.replace(/<final\b[^>]*>([\s\S]*?)<\/final>/gi, "$1");
+  for (let index = 0;index < codeBlocks.length; index++) {
+    processed = processed.replace(`${PLACEHOLDER_PREFIX}${index}${PLACEHOLDER_PREFIX}`, codeBlocks[index]);
+  }
+  return processed.replace(/\n{3,}/g, `
+
+`).trim();
+}
+
+// status-reactions.ts
+var EMOJI_QUEUED = "⏳";
+var EMOJI_THINKING = "\uD83E\uDD14";
+var EMOJI_DONE = "✅";
+var EMOJI_ERROR = "❌";
+function shouldShowStatusReaction(scope, message, botId) {
+  if (scope === "none") {
+    return false;
+  }
+  if (scope === "all") {
+    return true;
+  }
+  if (!message.guild) {
+    return true;
+  }
+  const isMentioned = Boolean(botId && message.mentions.users?.has(botId));
+  const isReplyToBot = message.mentions.repliedUser?.id === botId;
+  return isMentioned || isReplyToBot;
+}
+function createStatusReactionController(message) {
+  let currentEmoji = null;
+  let finished = false;
+  let chain = Promise.resolve();
+  const botId = message.client?.user?.id;
+  const transition = (emoji, terminal = false) => {
+    if (finished) {
+      return;
+    }
+    chain = chain.then(async () => {
+      if (finished && !terminal) {
+        return;
+      }
+      try {
+        if (currentEmoji && currentEmoji !== emoji && botId) {
+          try {
+            const reaction = message.reactions.resolve(currentEmoji);
+            if (reaction) {
+              await reaction.users.remove(botId);
+            }
+          } catch {}
+        }
+        await message.react(emoji);
+        currentEmoji = emoji;
+      } catch {} finally {
+        if (terminal) {
+          finished = true;
+        }
+      }
+    });
+  };
+  return {
+    setQueued: () => transition(EMOJI_QUEUED),
+    setThinking: () => transition(EMOJI_THINKING),
+    setDone: () => transition(EMOJI_DONE, true),
+    setError: () => transition(EMOJI_ERROR, true)
+  };
+}
+
+// typing.ts
+var HEARTBEAT_MS = 9000;
+var DEFAULT_MAX_DURATION_MS = 20 * 60 * 1000;
+function createTypingController(channel, maxDurationMs = DEFAULT_MAX_DURATION_MS) {
+  let interval = null;
+  let ttlTimeout = null;
+  let started = false;
+  let stopped = false;
+  const sendTyping = () => {
+    if (stopped || typeof channel.sendTyping !== "function") {
+      return;
+    }
+    try {
+      const result = channel.sendTyping();
+      if (result && typeof result.catch === "function") {
+        result.catch(() => {});
+      }
+    } catch {}
+  };
+  const stop = () => {
+    if (stopped) {
+      return;
+    }
+    stopped = true;
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    if (ttlTimeout) {
+      clearTimeout(ttlTimeout);
+      ttlTimeout = null;
+    }
+  };
+  const start = () => {
+    if (started || stopped) {
+      return;
+    }
+    started = true;
+    sendTyping();
+    interval = setInterval(sendTyping, HEARTBEAT_MS);
+    ttlTimeout = setTimeout(stop, maxDurationMs);
+  };
+  return { start, stop };
+}
+
+// messages.ts
+function escapeRegex3(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function textMentionsAnyName(text, names) {
+  if (!text) {
+    return false;
+  }
+  return names.some((name) => {
+    const candidate = name?.trim();
+    if (!candidate) {
+      return false;
+    }
+    const pattern = new RegExp(`(^|[^\\p{L}\\p{N}])${escapeRegex3(candidate)}(?=$|[^\\p{L}\\p{N}])`, "iu");
+    return pattern.test(text);
+  });
+}
+
+class MessageManager {
+  client;
+  runtime;
+  attachmentManager;
+  getChannelType;
+  discordSettings;
+  discordService;
+  statusReactionScope;
+  envelopeEnabled;
+  draftStreamingEnabled;
+  recentlyProcessedMessageIds = new Map;
+  static PROCESSED_MESSAGE_TTL_MS = 2 * 60 * 1000;
+  constructor(discordService, runtime) {
+    if (!discordService.client) {
+      const errorMsg = "Discord client not initialized - cannot create MessageManager";
+      runtime.logger.error({ src: "plugin:discord", agentId: runtime.agentId }, errorMsg);
+      throw new Error(errorMsg);
+    }
+    this.client = discordService.client;
+    this.runtime = runtime;
+    this.attachmentManager = new AttachmentManager(this.runtime);
+    this.getChannelType = discordService.getChannelType;
+    this.discordService = discordService;
+    this.discordSettings = getDiscordSettings(this.runtime);
+    const reactionScopeSetting = this.runtime.getSetting("DISCORD_STATUS_REACTIONS");
+    this.statusReactionScope = ["all", "group-mentions", "none"].includes(reactionScopeSetting ?? "") ? reactionScopeSetting : "group-mentions";
+    const envelopeSetting = this.runtime.getSetting("DISCORD_ENVELOPE_ENABLED");
+    this.envelopeEnabled = envelopeSetting !== "false" && envelopeSetting !== "0";
+    const draftStreamSetting = this.runtime.getSetting("DISCORD_DRAFT_STREAMING");
+    this.draftStreamingEnabled = draftStreamSetting === "true" || draftStreamSetting === "1";
+  }
+  async checkDmAccess(message) {
+    const policy = this.discordSettings.dmPolicy ?? "pairing";
+    const userId = message.author.id;
+    if (policy === "disabled") {
+      this.runtime.logger.debug({
+        src: "plugin:discord",
+        agentId: this.runtime.agentId,
+        userId
+      }, "DM blocked: policy is disabled");
+      return { allowed: false };
+    }
+    if (policy === "open") {
+      return { allowed: true };
+    }
+    if (policy === "allowlist") {
+      if (this.discordSettings.allowFrom?.includes(userId)) {
+        return { allowed: true };
+      }
+      const inDynamicAllowlist = await isInAllowlist(this.runtime, "discord", userId);
+      if (inDynamicAllowlist) {
+        return { allowed: true };
+      }
+      this.runtime.logger.debug({
+        src: "plugin:discord",
+        agentId: this.runtime.agentId,
+        userId
+      }, "DM blocked: user not in allowlist");
+      return { allowed: false };
+    }
+    if (policy === "pairing") {
+      if (this.discordSettings.allowFrom?.includes(userId)) {
+        return { allowed: true };
+      }
+      const result = await checkPairingAllowed(this.runtime, {
+        channel: "discord",
+        senderId: userId,
+        metadata: {
+          username: message.author.username,
+          displayName: message.author.displayName ?? message.author.username,
+          discriminator: message.author.discriminator ?? ""
+        }
+      });
+      if (result.allowed) {
+        return { allowed: true };
+      }
+      this.runtime.logger.debug({
+        src: "plugin:discord",
+        agentId: this.runtime.agentId,
+        userId,
+        pairingCode: result.pairingCode,
+        newRequest: result.newRequest
+      }, "DM blocked: pairing required");
+      return {
+        allowed: false,
+        replyMessage: result.newRequest ? result.replyMessage : undefined
+      };
+    }
+    return { allowed: true };
+  }
+  async persistInboundMemory(memory) {
+    if (!memory.id) {
+      return;
+    }
+    const existing = await this.runtime.getMemoryById(memory.id);
+    if (existing) {
+      return;
+    }
+    await this.runtime.createMemory(memory, "messages");
+  }
+  markMessageAsProcessing(messageId) {
+    const now = Date.now();
+    for (const [candidateId, processedAt] of this.recentlyProcessedMessageIds) {
+      if (now - processedAt > MessageManager.PROCESSED_MESSAGE_TTL_MS) {
+        this.recentlyProcessedMessageIds.delete(candidateId);
+      }
+    }
+    if (this.recentlyProcessedMessageIds.has(messageId)) {
+      return false;
+    }
+    this.recentlyProcessedMessageIds.set(messageId, now);
+    return true;
+  }
+  async handleMessage(message) {
+    const clientUser = this.client.user;
+    if (message.interaction || clientUser && message.author.id === clientUser.id) {
+      return;
+    }
+    if (this.discordSettings.shouldIgnoreBotMessages && message.author && message.author.bot) {
+      return;
+    }
+    if (message.id && !this.markMessageAsProcessing(message.id)) {
+      this.runtime.logger.debug({
+        src: "plugin:discord",
+        agentId: this.runtime.agentId,
+        messageId: message.id
+      }, "Skipping duplicate Discord message");
+      return;
+    }
+    if (this.discordSettings.shouldIgnoreDirectMessages && message.channel.type === DiscordChannelType4.DM) {
+      return;
+    }
+    if (message.channel.type === DiscordChannelType4.DM) {
+      const accessCheck = await this.checkDmAccess(message);
       if (!accessCheck.allowed) {
         if (accessCheck.replyMessage) {
           try {
@@ -8676,36 +10196,14 @@ class MessageManager {
     const mentionedOtherUsers = message.mentions.users ? Array.from(message.mentions.users.values()).some((user) => user.id !== clientUser?.id && user.id !== message.author.id) : false;
     const isReplyToOtherUser = !!message.reference?.messageId && !!message.mentions.repliedUser?.id && message.mentions.repliedUser.id !== clientUser?.id && message.mentions.repliedUser.id !== message.author.id;
     const isInThread = message.channel.isThread();
-    const isDM = message.channel.type === DiscordChannelType3.DM;
-    if (!isDM && (mentionedOtherUsers || isReplyToOtherUser)) {
-      this.runtime.logger.debug({
-        src: "plugin:discord",
-        agentId: this.runtime.agentId,
-        channelId: message.channel.id
-      }, "Ignoring message that targets another mentioned user");
-      return;
-    }
-    if (this.discordSettings.shouldRespondOnlyToMentions) {
-      const shouldProcess = isDM || isBotMentioned || isReplyToBot;
-      if (!shouldProcess) {
-        this.runtime.logger.debug({
-          src: "plugin:discord",
-          agentId: this.runtime.agentId,
-          channelId: message.channel.id
-        }, "Strict mode: ignoring message (no mention or reply)");
-        return;
-      }
-      this.runtime.logger.debug({
-        src: "plugin:discord",
-        agentId: this.runtime.agentId,
-        channelId: message.channel.id
-      }, "Strict mode: processing message");
-    }
-    const entityId = createUniqueUuid4(this.runtime, message.author.id);
+    const isDM = message.channel.type === DiscordChannelType4.DM;
+    const strictModeEnabled = this.discordSettings.shouldRespondOnlyToMentions === true;
+    const strictModeShouldProcess = isDM || isBotMentioned || isReplyToBot;
     const userName = message.author.bot ? `${message.author.username}#${message.author.discriminator}` : message.author.username;
-    const name = message.author.displayName;
+    const name = message.member?.displayName ?? message.author.globalName ?? message.author.displayName ?? message.author.username;
     const channelId = message.channel.id;
     const roomId = createUniqueUuid4(this.runtime, channelId);
+    const roomName = message.guild && "name" in message.channel && typeof message.channel.name === "string" ? message.channel.name : name || userName;
     let type;
     let messageServerId;
     if (message.guild) {
@@ -8720,43 +10218,27 @@ class MessageManager {
       }
       messageServerId = guild.id;
     } else {
-      type = ChannelType5.DM;
+      type = ChannelType6.DM;
       messageServerId = message.channel.id;
     }
-    await this.runtime.ensureConnection({
-      entityId,
-      roomId,
-      userName,
-      name,
-      source: "discord",
-      channelId: message.channel.id,
-      messageServerId: messageServerId ? stringToUuid(messageServerId) : undefined,
-      type,
-      worldId: createUniqueUuid4(this.runtime, messageServerId ?? roomId),
-      worldName: message.guild?.name,
-      userId: message.author.id,
-      metadata: buildDiscordWorldMetadata(this.runtime, message.guild?.ownerId ?? undefined)
-    });
     try {
-      const canSendResult = canSendMessage(message.channel);
-      if (!canSendResult.canSend) {
-        return this.runtime.logger.warn({
-          src: "plugin:discord",
-          agentId: this.runtime.agentId,
-          channelId: message.channel.id,
-          reason: canSendResult.reason
-        }, "Cannot send message to channel");
+      let { processedContent, attachments } = await this.processMessage(message);
+      if (this.envelopeEnabled && processedContent) {
+        try {
+          const envelope = await formatInboundEnvelope(message, processedContent);
+          processedContent = envelope.formattedContent;
+        } catch {}
       }
-      const { processedContent, attachments } = await this.processMessage(message);
       if (!processedContent && !attachments?.length) {
         return;
       }
-      const channel = message.channel;
-      const typingData = {
-        interval: null,
-        cleared: false,
-        started: false
-      };
+      const explicitlyAddressesBotByName = textMentionsAnyName(processedContent, [
+        this.runtime.character.name,
+        this.runtime.character.username,
+        clientUser?.globalName,
+        clientUser?.username
+      ]);
+      const ignoresOtherTarget = !isDM && !isBotMentioned && !isReplyToBot && !explicitlyAddressesBotByName && (mentionedOtherUsers || isReplyToOtherUser);
       const newMessage = await this.discordService.buildMemoryFromMessage(message, {
         processedContent,
         processedAttachments: attachments,
@@ -8771,9 +10253,15 @@ class MessageManager {
         extraMetadata: {
           replyToAuthor: message.mentions.repliedUser ? {
             id: message.mentions.repliedUser.id,
+            displayName: message.mentions.repliedUser.globalName ?? message.mentions.repliedUser.username,
             username: message.mentions.repliedUser.username,
             isBot: message.mentions.repliedUser.bot
-          } : undefined
+          } : undefined,
+          replyToMessageId: message.reference?.messageId ? createUniqueUuid4(this.runtime, message.reference.messageId) : undefined,
+          replyToExternalMessageId: message.reference?.messageId,
+          replyToSenderId: message.mentions.repliedUser?.id,
+          replyToSenderName: message.mentions.repliedUser?.globalName ?? message.mentions.repliedUser?.username,
+          replyToSenderUserName: message.mentions.repliedUser?.username
         }
       });
       if (!newMessage) {
@@ -8784,37 +10272,154 @@ class MessageManager {
         }, "Failed to build memory from message");
         return;
       }
+      await this.runtime.ensureConnection({
+        entityId: newMessage.entityId,
+        roomId,
+        roomName,
+        userName,
+        name,
+        source: "discord",
+        channelId: message.channel.id,
+        messageServerId: messageServerId ? stringToUuid2(messageServerId) : undefined,
+        type,
+        worldId: createUniqueUuid4(this.runtime, messageServerId ?? roomId),
+        worldName: message.guild?.name,
+        userId: message.author.id,
+        metadata: buildDiscordWorldMetadata(this.runtime, message.guild?.ownerId ?? undefined)
+      });
+      if (ignoresOtherTarget) {
+        await this.persistInboundMemory(newMessage);
+        this.runtime.logger.debug({
+          src: "plugin:discord",
+          agentId: this.runtime.agentId,
+          channelId: message.channel.id
+        }, "Ignoring message that targets another mentioned user");
+        return;
+      }
+      if (strictModeEnabled && !strictModeShouldProcess) {
+        await this.persistInboundMemory(newMessage);
+        this.runtime.logger.debug({
+          src: "plugin:discord",
+          agentId: this.runtime.agentId,
+          channelId: message.channel.id
+        }, "Strict mode: ignoring message (no mention or reply)");
+        return;
+      }
+      if (strictModeEnabled) {
+        this.runtime.logger.debug({
+          src: "plugin:discord",
+          agentId: this.runtime.agentId,
+          channelId: message.channel.id
+        }, "Strict mode: processing message");
+      }
+      const canSendResult = canSendMessage(message.channel);
+      if (!canSendResult.canSend) {
+        await this.persistInboundMemory(newMessage);
+        return this.runtime.logger.warn({
+          src: "plugin:discord",
+          agentId: this.runtime.agentId,
+          channelId: message.channel.id,
+          reason: canSendResult.reason
+        }, "Cannot send message to channel");
+      }
       const messageId = newMessage.id;
+      const channel = message.channel;
+      const typingController = createTypingController(channel);
+      const clientUserId = this.client.user?.id;
+      const useReactions = shouldShowStatusReaction(this.statusReactionScope, message, clientUserId);
+      const statusReactions = useReactions ? createStatusReactionController(message) : null;
+      const draftStream = this.draftStreamingEnabled ? createDraftStreamController({
+        log: (entry) => this.runtime.logger.debug({ src: "plugin:discord", agentId: this.runtime.agentId }, entry),
+        warn: (entry) => this.runtime.logger.warn({ src: "plugin:discord", agentId: this.runtime.agentId }, entry)
+      }) : null;
+      let typingStarted = false;
+      let responseEmitted = false;
+      const finalizePendingDraft = async () => {
+        if (draftStream?.isStarted() && !draftStream.isDone()) {
+          await draftStream.finalize("");
+        }
+      };
+      const abortPendingDraft = async () => {
+        if (draftStream?.isStarted() && !draftStream.isDone()) {
+          await draftStream.abort("An error occurred while generating the response.");
+        }
+      };
+      if (draftStream) {
+        await draftStream.start(channel, message.id);
+      }
+      statusReactions?.setQueued();
+      statusReactions?.setThinking();
       const callback = async (content) => {
         try {
           if (content.target && typeof content.target === "string" && content.target.toLowerCase() !== "discord") {
             return [];
           }
-          if (!typingData.started) {
-            typingData.started = true;
-            const startTyping = () => {
+          if (message.id && !content.inReplyTo) {
+            content.inReplyTo = createUniqueUuid4(this.runtime, message.id);
+          }
+          if (typeof content.text === "string" && content.text.length > 0) {
+            content.text = stripReasoningTags(content.text);
+          }
+          const textContent = normalizeDiscordMessageText(content.text);
+          const hasText = textContent.trim().length > 0;
+          const attachmentCount = Array.isArray(content.attachments) ? content.attachments.filter((media) => Boolean(media?.url)).length : 0;
+          if (!hasText && attachmentCount === 0) {
+            return [];
+          }
+          if (!typingStarted) {
+            typingStarted = true;
+            typingController.start();
+          }
+          if (hasText && content.inReplyTo) {
+            const dedupKey = `${content.inReplyTo}::${textContent.replace(/\s+/g, " ").trim()}`;
+            const callbackDedup = message;
+            callbackDedup._miladySentReplyKeys ??= new Set;
+            if (callbackDedup._miladySentReplyKeys.has(dedupKey)) {
+              const err = new Error("Duplicate callback reply for same inbound message — runtime emitted identical text twice");
+              this.runtime.logger.error({
+                src: "plugin:discord",
+                agentId: this.runtime.agentId,
+                messageId: message.id,
+                inReplyTo: content.inReplyTo,
+                textPreview: textContent.replace(/\s+/g, " ").trim().slice(0, 200)
+              }, err.message);
+              throw err;
+            }
+            callbackDedup._miladySentReplyKeys.add(dedupKey);
+          }
+          const files = [];
+          if (content.attachments && content.attachments.length > 0) {
+            for (const media of content.attachments) {
+              if (media.url) {
+                const fileName = getAttachmentFileName(media);
+                files.push(new AttachmentBuilder(media.url, { name: fileName }));
+              }
+            }
+          }
+          let messages = [];
+          if (draftStream?.isStarted() && !draftStream.isDone()) {
+            if (hasText || files.length === 0) {
+              messages = await draftStream.finalize(textContent);
+            } else {
+              await finalizePendingDraft();
+            }
+            if (files.length > 0) {
               try {
-                if (channel.sendTyping) {
-                  channel.sendTyping();
-                }
-              } catch (err) {
+                const attachmentMessage = await channel.send({
+                  files
+                });
+                messages.push(attachmentMessage);
+              } catch (error) {
                 this.runtime.logger.warn({
                   src: "plugin:discord",
                   agentId: this.runtime.agentId,
-                  error: err instanceof Error ? err.message : String(err)
-                }, "Error sending typing indicator");
+                  error: error instanceof Error ? error.message : String(error)
+                }, "Failed to send Discord attachments after draft finalize");
               }
-            };
-            startTyping();
-            typingData.interval = setInterval(startTyping, 8000);
-          }
-          if (message.id && !content.inReplyTo) {
-            content.inReplyTo = createUniqueUuid4(this.runtime, message.id);
-          }
-          let messages = [];
-          if (content && content.channelType === "DM") {
-            const u = await this.client.users.fetch(message.author.id);
-            if (!u) {
+            }
+          } else if (content && content.channelType === "DM") {
+            const user = await this.client.users.fetch(message.author.id);
+            if (!user) {
               this.runtime.logger.warn({
                 src: "plugin:discord",
                 agentId: this.runtime.agentId,
@@ -8822,41 +10427,21 @@ class MessageManager {
               }, "User not found for DM");
               return [];
             }
-            const files = [];
-            if (content.attachments && content.attachments.length > 0) {
-              for (const media of content.attachments) {
-                if (media.url) {
-                  const fileName = getAttachmentFileName(media);
-                  files.push(new AttachmentBuilder(media.url, { name: fileName }));
-                }
-              }
-            }
-            const textContent = content.text ?? "";
-            const hasText = textContent.trim().length > 0;
-            if (!hasText && files.length === 0) {
-              this.runtime.logger.warn({ src: "plugin:discord", agentId: this.runtime.agentId }, "Skipping DM response: no text or attachments");
-              return [];
-            }
-            const dmMessage = await u.send({
+            const dmMessage = await user.send({
               content: textContent,
               files: files.length > 0 ? files : undefined
             });
             messages = [dmMessage];
           } else {
-            const files = [];
-            if (content.attachments && content.attachments.length > 0) {
-              for (const media of content.attachments) {
-                if (media.url) {
-                  const fileName = getAttachmentFileName(media);
-                  files.push(new AttachmentBuilder(media.url, { name: fileName }));
-                }
-              }
-            }
             if (!message.id) {
               this.runtime.logger.warn({ src: "plugin:discord", agentId: this.runtime.agentId }, "Cannot send message: message.id is missing");
               return [];
             }
-            messages = await sendMessageInChunks(channel, content.text ?? "", message.id, files, undefined, this.runtime);
+            messages = await sendMessageInChunks(channel, textContent, message.id, files, undefined, this.runtime);
+          }
+          const attemptedSend = hasText || attachmentCount > 0;
+          if (attemptedSend && messages.length === 0) {
+            throw new Error("Discord response callback completed without sending any messages");
           }
           const memories = [];
           for (const m of messages) {
@@ -8868,7 +10453,8 @@ class MessageManager {
               agentId: this.runtime.agentId,
               content: {
                 ...content,
-                text: m.content || content.text || " ",
+                source: "discord",
+                text: m.content || textContent || " ",
                 actions,
                 inReplyTo: messageId,
                 url: m.url,
@@ -8883,9 +10469,28 @@ class MessageManager {
           for (const m of memories) {
             await this.runtime.createMemory(m, "messages");
           }
-          if (typingData.interval && !typingData.cleared) {
-            clearInterval(typingData.interval);
-            typingData.cleared = true;
+          responseEmitted = memories.length > 0;
+          typingController.stop();
+          statusReactions?.setDone();
+          if (hasText) {
+            const replyPreview = textContent.replace(/\s+/g, " ").slice(0, 200);
+            const callbackState = message;
+            callbackState._miladyReplyCount = (callbackState._miladyReplyCount ?? 0) + 1;
+            if (callbackState._miladyReplyCount === 1) {
+              callbackState._miladyFirstReplyPreview = replyPreview;
+            } else {
+              this.runtime.logger.warn({
+                src: "plugin:discord",
+                agentId: this.runtime.agentId,
+                messageId: message.id,
+                channelId: message.channel.id,
+                replyCount: callbackState._miladyReplyCount,
+                firstPreview: callbackState._miladyFirstReplyPreview,
+                currentPreview: replyPreview,
+                action: typeof content?.action === "string" ? String(content.action) : undefined,
+                source: typeof content.source === "string" ? content.source : undefined
+              }, "Multiple Discord replies emitted for one inbound message");
+            }
           }
           return memories;
         } catch (error) {
@@ -8894,23 +10499,27 @@ class MessageManager {
             agentId: this.runtime.agentId,
             error: error instanceof Error ? error.message : String(error)
           }, "Error handling message callback");
-          if (typingData.interval && !typingData.cleared) {
-            clearInterval(typingData.interval);
-            typingData.cleared = true;
-          }
-          return [];
+          typingController.stop();
+          statusReactions?.setError();
+          await abortPendingDraft();
+          throw error;
         }
       };
       const messagingAPI = getMessagingAPI(this.runtime);
       const messageService = getMessageService(this.runtime);
-      if (messagingAPI) {
-        this.runtime.logger.debug({ src: "plugin:discord", agentId: this.runtime.agentId }, "Using messaging API");
+      if (messageService) {
+        this.runtime.logger.debug({ src: "plugin:discord", agentId: this.runtime.agentId }, "Using messageService API");
+        await messageService.handleMessage(this.runtime, newMessage, callback);
+      } else if (messagingAPI?.handleMessage) {
+        this.runtime.logger.debug({ src: "plugin:discord", agentId: this.runtime.agentId }, "Using messaging API handleMessage");
+        await messagingAPI.handleMessage(this.runtime.agentId, newMessage, {
+          onResponse: callback
+        });
+      } else if (messagingAPI?.sendMessage) {
+        this.runtime.logger.debug({ src: "plugin:discord", agentId: this.runtime.agentId }, "Using messaging API sendMessage");
         await messagingAPI.sendMessage(this.runtime.agentId, newMessage, {
           onResponse: callback
         });
-      } else if (messageService) {
-        this.runtime.logger.debug({ src: "plugin:discord", agentId: this.runtime.agentId }, "Using messageService API");
-        await messageService.handleMessage(this.runtime, newMessage, callback);
       } else {
         this.runtime.logger.debug({ src: "plugin:discord", agentId: this.runtime.agentId }, "Using event-based message handling");
         await this.runtime.emitEvent([EventType.MESSAGE_RECEIVED], {
@@ -8920,13 +10529,11 @@ class MessageManager {
           source: "discord"
         });
       }
-      setTimeout(() => {
-        if (typingData.started && typingData.interval && !typingData.cleared) {
-          clearInterval(typingData.interval);
-          typingData.cleared = true;
-          this.runtime.logger.warn({ src: "plugin:discord", agentId: this.runtime.agentId }, "Typing indicator failsafe timeout triggered");
-        }
-      }, 30000);
+      if (!responseEmitted) {
+        typingController.stop();
+        statusReactions?.setDone();
+        await finalizePendingDraft();
+      }
     } catch (error) {
       this.runtime.logger.error({
         src: "plugin:discord",
@@ -8947,30 +10554,6 @@ Embed #${parseInt(i, 10) + 1}:
         processedContent += `  Title:${embed.title ?? "(none)"}
 `;
         processedContent += `  Description:${embed.description ?? "(none)"}
-`;
-      }
-    }
-    if (message.reference) {
-      let messageId;
-      if (message.reference.messageId) {
-        messageId = createUniqueUuid4(this.runtime, message.reference.messageId);
-      } else {
-        try {
-          const refMsg = await message.fetchReference();
-          messageId = createUniqueUuid4(this.runtime, refMsg.id);
-        } catch {}
-      }
-      if (messageId) {
-        processedContent += `
-Referencing MessageID ${messageId} (discord: ${message.reference.messageId})`;
-        if (message.reference.channelId !== message.channel.id) {
-          const roomId = createUniqueUuid4(this.runtime, message.reference.channelId);
-          processedContent += ` in channel ${roomId}`;
-        }
-        if (message.reference.guildId && message.guild && message.reference.guildId !== message.guild.id) {
-          processedContent += ` in guild ${message.reference.guildId}`;
-        }
-        processedContent += `
 `;
       }
     }
@@ -9028,7 +10611,7 @@ Referencing MessageID ${messageId} (discord: ${message.reference.messageId})`;
       } else {
         const browserService = this.runtime.getService(ServiceType4.BROWSER);
         if (!browserService) {
-          this.runtime.logger.warn({ src: "plugin:discord", agentId: this.runtime.agentId }, "Browser service not found");
+          this.runtime.logger.debug({ src: "plugin:discord", agentId: this.runtime.agentId }, "Skipping URL enrichment because browser service is unavailable");
           continue;
         }
         try {
@@ -9121,74 +10704,723 @@ function getState(perm, allow, deny) {
   if (deny.includes(perm)) {
     return "DENY";
   }
-  return "NEUTRAL";
-}
-function overwriteToChanges(ow, isDelete = false) {
-  const changes = [];
-  for (const p of ow.allow.toArray()) {
-    changes.push({
-      permission: p,
-      oldState: isDelete ? "ALLOW" : "NEUTRAL",
-      newState: isDelete ? "NEUTRAL" : "ALLOW"
+  return "NEUTRAL";
+}
+function overwriteToChanges(ow, isDelete = false) {
+  const changes = [];
+  for (const p of ow.allow.toArray()) {
+    changes.push({
+      permission: p,
+      oldState: isDelete ? "ALLOW" : "NEUTRAL",
+      newState: isDelete ? "NEUTRAL" : "ALLOW"
+    });
+  }
+  for (const p of ow.deny.toArray()) {
+    changes.push({
+      permission: p,
+      oldState: isDelete ? "DENY" : "NEUTRAL",
+      newState: isDelete ? "NEUTRAL" : "DENY"
+    });
+  }
+  return changes;
+}
+function diffOverwrites(oldOw, newOw) {
+  if (!oldOw && !newOw) {
+    return { changes: [], action: "UPDATE" };
+  }
+  if (!oldOw && newOw) {
+    return { changes: overwriteToChanges(newOw, false), action: "CREATE" };
+  }
+  if (oldOw && !newOw) {
+    return { changes: overwriteToChanges(oldOw, true), action: "DELETE" };
+  }
+  const changes = [];
+  const oldAllow = oldOw?.allow.toArray();
+  const oldDeny = oldOw?.deny.toArray();
+  const newAllow = newOw?.allow.toArray();
+  const newDeny = newOw?.deny.toArray();
+  const allPerms = new Set([...oldAllow, ...oldDeny, ...newAllow, ...newDeny]);
+  for (const perm of allPerms) {
+    const oldState = getState(perm, oldAllow, oldDeny);
+    const newState = getState(perm, newAllow, newDeny);
+    if (oldState !== newState) {
+      changes.push({ permission: perm, oldState, newState });
+    }
+  }
+  return { changes, action: "UPDATE" };
+}
+function diffRolePermissions(oldRole, newRole) {
+  const oldPerms = oldRole.permissions.toArray();
+  const newPerms = newRole.permissions.toArray();
+  const changes = [];
+  for (const p of newPerms) {
+    if (!oldPerms.includes(p)) {
+      changes.push({ permission: p, oldState: "NEUTRAL", newState: "ALLOW" });
+    }
+  }
+  for (const p of oldPerms) {
+    if (!newPerms.includes(p)) {
+      changes.push({ permission: p, oldState: "ALLOW", newState: "NEUTRAL" });
+    }
+  }
+  return changes;
+}
+function diffMemberRoles(oldMember, newMember) {
+  const oldRoles = oldMember.roles.cache;
+  const newRoles = newMember.roles.cache;
+  return {
+    added: [...newRoles.filter((r) => !oldRoles.has(r.id)).values()],
+    removed: [...oldRoles.filter((r) => !newRoles.has(r.id)).values()]
+  };
+}
+
+// profileSync.ts
+import { createHash } from "node:crypto";
+import fs5 from "node:fs/promises";
+import os3 from "node:os";
+import path3 from "node:path";
+var MAX_PROFILE_AVATAR_BYTES = 8 * 1024 * 1024;
+var PROFILE_SYNC_STATE_FILE = "discord-profile-sync.v1.json";
+var DEFAULT_DISCORD_PROFILE_AVATAR = "/avatars/eliza.png";
+function resolveUserPath(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  if (trimmed.startsWith("~")) {
+    return path3.resolve(trimmed.replace(/^~(?=$|[\\/])/, os3.homedir()));
+  }
+  return path3.resolve(trimmed);
+}
+function resolveStateDirFromEnv(env = process.env) {
+  const override = env.MILADY_STATE_DIR?.trim() || env.ELIZA_STATE_DIR?.trim();
+  if (override) {
+    return resolveUserPath(override);
+  }
+  const namespace = env.MILADY_NAMESPACE?.trim() || env.ELIZA_NAMESPACE?.trim() || "milady";
+  return path3.join(os3.homedir(), `.${namespace}`);
+}
+function resolveProfileSyncStatePath(env = process.env) {
+  return path3.join(resolveStateDirFromEnv(env), "cache", PROFILE_SYNC_STATE_FILE);
+}
+async function readPersistedProfileSyncState(env = process.env) {
+  try {
+    const raw = await fs5.readFile(resolveProfileSyncStatePath(env), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      ...typeof parsed.avatarHash === "string" ? { avatarHash: parsed.avatarHash } : {},
+      ...typeof parsed.username === "string" ? { username: parsed.username } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+async function writePersistedProfileSyncState(state, env = process.env) {
+  const statePath = resolveProfileSyncStatePath(env);
+  await fs5.mkdir(path3.dirname(statePath), { recursive: true });
+  await fs5.writeFile(statePath, JSON.stringify(state, null, 2), {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+function normalizeDesiredDiscordName(runtime, settings) {
+  const configured = settings.profileName?.trim();
+  if (configured) {
+    return configured;
+  }
+  const characterName = runtime.character.name?.trim();
+  if (characterName) {
+    return characterName;
+  }
+  const characterUserName = runtime.character.username?.trim();
+  return characterUserName || undefined;
+}
+function readNestedOptionalString(value, pathSegments) {
+  let cursor = value;
+  for (const segment of pathSegments) {
+    if (!cursor || typeof cursor !== "object") {
+      return;
+    }
+    cursor = cursor[segment];
+  }
+  return typeof cursor === "string" && cursor.trim().length > 0 ? cursor.trim() : undefined;
+}
+function normalizeDesiredDiscordAvatarSource(runtime, settings) {
+  const configured = settings.profileAvatar?.trim();
+  if (configured) {
+    return configured;
+  }
+  const character = runtime.character;
+  const fromIdentity = readNestedOptionalString(character, ["identity", "avatar"]) ?? readNestedOptionalString(character, ["settings", "identity", "avatar"]);
+  if (fromIdentity) {
+    return fromIdentity;
+  }
+  const fromCharacter = readNestedOptionalString(character, ["avatar"]) ?? readNestedOptionalString(character, ["settings", "avatar"]);
+  if (fromCharacter) {
+    return fromCharacter;
+  }
+  return DEFAULT_DISCORD_PROFILE_AVATAR;
+}
+function extractDataUriPayload(source) {
+  const match = source.match(/^data:image\/[^;]+;base64,([a-z0-9+/=]+)$/i);
+  if (!match) {
+    return null;
+  }
+  return Buffer.from(match[1], "base64");
+}
+function buildLocalAvatarPathCandidates(source) {
+  const candidates = new Set;
+  const trimmed = source.trim();
+  if (!trimmed) {
+    return [];
+  }
+  candidates.add(resolveUserPath(trimmed));
+  const normalized = trimmed.replace(/\\/g, "/");
+  const withoutLeadingSlash = normalized.replace(/^\/+/, "");
+  if (!withoutLeadingSlash) {
+    return [...candidates];
+  }
+  const repoRoot = process.cwd();
+  const publicRoots = [
+    path3.join(repoRoot, "cloud", "public"),
+    path3.join(repoRoot, "apps", "web", "public"),
+    path3.join(repoRoot, "public")
+  ];
+  for (const publicRoot of publicRoots) {
+    candidates.add(path3.join(publicRoot, withoutLeadingSlash));
+    if (!withoutLeadingSlash.startsWith("avatars/")) {
+      candidates.add(path3.join(publicRoot, "avatars", withoutLeadingSlash));
+    }
+  }
+  return [...candidates];
+}
+async function readAvatarBytesFromLocalCandidates(source) {
+  let lastError = null;
+  for (const candidate of buildLocalAvatarPathCandidates(source)) {
+    try {
+      return await fs5.readFile(candidate);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new Error(`Unable to resolve Discord profile avatar source: ${source}`);
+}
+async function loadDiscordProfileAvatarBytes(source, runtime) {
+  const trimmed = source.trim();
+  if (!trimmed) {
+    return null;
+  }
+  let bytes = extractDataUriPayload(trimmed);
+  if (!bytes) {
+    let remoteUrl = null;
+    try {
+      const parsedUrl = new URL(trimmed);
+      if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") {
+        remoteUrl = parsedUrl;
+      }
+    } catch {}
+    if (remoteUrl) {
+      const fetchImpl = runtime.fetch ?? globalThis.fetch;
+      if (typeof fetchImpl !== "function") {
+        return null;
+      }
+      const response = await fetchImpl(trimmed, {
+        headers: { Accept: "image/*" }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const contentType = response.headers.get("content-type");
+      if (!contentType?.toLowerCase().startsWith("image/")) {
+        throw new Error(`Expected image content-type, got ${contentType ?? "unknown"}`);
+      }
+      bytes = Buffer.from(await response.arrayBuffer());
+    } else {
+      bytes = await readAvatarBytesFromLocalCandidates(trimmed);
+    }
+  }
+  if (!bytes || bytes.length === 0) {
+    return null;
+  }
+  if (bytes.length > MAX_PROFILE_AVATAR_BYTES) {
+    throw new Error(`Discord profile avatar exceeds ${MAX_PROFILE_AVATAR_BYTES} bytes`);
+  }
+  return {
+    bytes,
+    hash: createHash("sha256").update(bytes).digest("hex")
+  };
+}
+async function syncDiscordClientProfile(runtime, clientUser, settings) {
+  if (settings.syncProfile === false) {
+    return;
+  }
+  const desiredName = normalizeDesiredDiscordName(runtime, settings);
+  const desiredAvatarSource = normalizeDesiredDiscordAvatarSource(runtime, settings);
+  if (!desiredName && !desiredAvatarSource) {
+    return;
+  }
+  const persisted = await readPersistedProfileSyncState();
+  const nextState = { ...persisted };
+  let stateChanged = false;
+  if (desiredName) {
+    if (persisted.username !== desiredName) {
+      if (clientUser.username !== desiredName) {
+        if (typeof clientUser.setUsername === "function") {
+          await clientUser.setUsername(desiredName);
+          runtime.logger.info({
+            src: "plugin:discord",
+            agentId: runtime.agentId,
+            discordProfileName: desiredName
+          }, "Synchronized Discord bot username from connector settings");
+        }
+      }
+      nextState.username = desiredName;
+      stateChanged = true;
+    }
+  }
+  if (desiredAvatarSource) {
+    const avatar = await loadDiscordProfileAvatarBytes(desiredAvatarSource, runtime);
+    if (avatar && persisted.avatarHash !== avatar.hash) {
+      if (typeof clientUser.setAvatar === "function") {
+        await clientUser.setAvatar(avatar.bytes);
+        runtime.logger.info({
+          src: "plugin:discord",
+          agentId: runtime.agentId
+        }, "Synchronized Discord bot avatar from connector settings");
+      }
+      nextState.avatarHash = avatar.hash;
+      stateChanged = true;
+    }
+  }
+  if (stateChanged) {
+    await writePersistedProfileSyncState(nextState);
+  }
+}
+
+// slash-commands.ts
+import { createUniqueUuid as createUniqueUuid5 } from "@elizaos/core";
+import { ApplicationCommandOptionType } from "discord.js";
+var OPTION_TYPE_MAP = {
+  string: ApplicationCommandOptionType.String,
+  number: ApplicationCommandOptionType.Number,
+  boolean: ApplicationCommandOptionType.Boolean,
+  user: ApplicationCommandOptionType.User,
+  channel: ApplicationCommandOptionType.Channel,
+  role: ApplicationCommandOptionType.Role
+};
+var commands = new Map;
+var cooldowns = new Map;
+var FALLBACK_KNOWN_MODELS = [
+  "gpt-4o",
+  "gpt-4o-mini",
+  "gpt-4",
+  "gpt-3.5-turbo",
+  "claude-sonnet-4-20250514",
+  "claude-opus-4-20250514",
+  "claude-3.5-haiku",
+  "llama-3.1-70b",
+  "llama-3.1-8b",
+  "gemini-2.5-pro",
+  "gemini-2.5-flash",
+  "mistral-large",
+  "mistral-medium"
+];
+function parseStringList(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
+  }
+  if (typeof value !== "string") {
+    return [];
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      return parseStringList(parsed);
+    }
+  } catch {}
+  return trimmed.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function getKnownModels(runtime) {
+  const configured = parseStringList(runtime.getSetting("DISCORD_KNOWN_MODELS")) ?? parseStringList(runtime.getSetting("KNOWN_MODELS"));
+  return configured.length > 0 ? configured : [...FALLBACK_KNOWN_MODELS];
+}
+var helpCommand = {
+  name: "help",
+  description: "Show available commands and usage information",
+  ephemeral: true,
+  async execute(interaction) {
+    const lines = [`**Available Commands**
+`];
+    for (const [name, command] of commands) {
+      const options = command.options ? command.options.map((option) => option.required ? `<${option.name}>` : `[${option.name}]`).join(" ") : "";
+      lines.push(`/${name}${options ? ` ${options}` : ""} - ${command.description}`);
+    }
+    await interaction.reply({ content: lines.join(`
+`), ephemeral: true });
+  }
+};
+var statusCommand = {
+  name: "status",
+  description: "Show the bot's current status and uptime",
+  ephemeral: true,
+  async execute(interaction, runtime) {
+    const uptimeMs = process.uptime() * 1000;
+    const hours = Math.floor(uptimeMs / 3600000);
+    const minutes = Math.floor(uptimeMs % 3600000 / 60000);
+    const seconds = Math.floor(uptimeMs % 60000 / 1000);
+    const memoryUsage = process.memoryUsage();
+    const heapMb = (memoryUsage.heapUsed / 1024 / 1024).toFixed(1);
+    const rssMb = (memoryUsage.rss / 1024 / 1024).toFixed(1);
+    await interaction.reply({
+      content: [
+        "**Bot Status**",
+        `- Agent: **${runtime.character?.name ?? "Unknown"}**`,
+        `- Uptime: **${hours}h ${minutes}m ${seconds}s**`,
+        `- Memory: **${heapMb} MB** heap / **${rssMb} MB** RSS`,
+        `- Guilds: **${interaction.client.guilds.cache.size}**`,
+        `- Node: **${process.version}**`,
+        `- Platform: **${process.platform}**`
+      ].join(`
+`),
+      ephemeral: true
+    });
+  }
+};
+var searchCommand = {
+  name: "search",
+  description: "Search conversation history in this channel",
+  options: [
+    {
+      name: "query",
+      description: "The search term or phrase",
+      type: "string",
+      required: true
+    },
+    {
+      name: "limit",
+      description: "Maximum results to return (default: 5)",
+      type: "number"
+    }
+  ],
+  ephemeral: true,
+  cooldown: 10,
+  async execute(interaction, runtime) {
+    const query = interaction.options.getString("query", true);
+    const limit = interaction.options.getNumber("limit") || 5;
+    await interaction.deferReply({ ephemeral: true });
+    try {
+      const roomId = createUniqueUuid5(runtime, interaction.channelId);
+      const memories = await runtime.getMemories({
+        tableName: "messages",
+        roomId,
+        count: 100
+      });
+      const normalizedQuery = query.trim().toLowerCase();
+      const filteredMemories = memories.filter((memory) => (memory.content?.text ?? "").toLowerCase().includes(normalizedQuery));
+      if (filteredMemories.length === 0) {
+        await interaction.editReply({
+          content: `No results found for **"${query}"**`
+        });
+        return;
+      }
+      const results = filteredMemories.slice(0, limit).map((memory, index) => {
+        const text = memory.content?.text || "(no text)";
+        const truncated = text.length > 120 ? `${text.slice(0, 120)}...` : text;
+        const date = memory.createdAt ? new Date(memory.createdAt).toLocaleDateString() : "unknown date";
+        return `**${index + 1}.** ${truncated}
+_${date}_`;
+      });
+      await interaction.editReply({
+        content: `**Search results for "${query}"**
+
+${results.join(`
+
+`)}`
+      });
+    } catch (error) {
+      await interaction.editReply({
+        content: `Search failed: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+};
+var clearCommand = {
+  name: "clear",
+  description: "Explain how context clearing works in this channel",
+  ephemeral: true,
+  async execute(interaction) {
+    await interaction.reply({
+      content: "Context clearing is not wired up for Discord yet. I can search recent messages with `/search`, but I won't pretend existing memory was deleted.",
+      ephemeral: true
     });
   }
-  for (const p of ow.deny.toArray()) {
-    changes.push({
-      permission: p,
-      oldState: isDelete ? "DENY" : "NEUTRAL",
-      newState: isDelete ? "NEUTRAL" : "DENY"
+};
+var settingsCommand = {
+  name: "settings",
+  description: "View the current Discord bot settings",
+  options: [
+    {
+      name: "action",
+      description: "What to do",
+      type: "string",
+      required: true,
+      choices: [
+        { name: "View current settings", value: "view" },
+        { name: "Toggle response-only-on-mention", value: "toggle-mention" },
+        { name: "Toggle ignore-bots", value: "toggle-ignore-bots" }
+      ]
+    }
+  ],
+  ephemeral: true,
+  async execute(interaction, runtime) {
+    const action = interaction.options.getString("action", true);
+    if (action === "view") {
+      await interaction.reply({
+        content: [
+          "**Current Settings**",
+          `- Respond only to mentions: **${runtime.getSetting("DISCORD_SHOULD_RESPOND_ONLY_TO_MENTIONS") ?? "false"}**`,
+          `- Ignore bot messages: **${runtime.getSetting("DISCORD_SHOULD_IGNORE_BOT_MESSAGES") ?? "true"}**`,
+          `- Allowed channels: **${runtime.getSetting("CHANNEL_IDS") ?? "(all channels)"}**`,
+          `- Agent name: **${runtime.character?.name ?? "Unknown"}**`
+        ].join(`
+`),
+        ephemeral: true
+      });
+      return;
+    }
+    const content = action === "toggle-mention" ? "Respond-only-on-mention is controlled by `DISCORD_SHOULD_RESPOND_ONLY_TO_MENTIONS`. Update the setting and restart to change it." : "Ignore-bots is controlled by `DISCORD_SHOULD_IGNORE_BOT_MESSAGES`. Update the setting and restart to change it.";
+    await interaction.reply({ content, ephemeral: true });
+  }
+};
+var setupCommand = {
+  name: "setup",
+  description: "Set up API credentials for third-party services",
+  options: [
+    {
+      name: "service",
+      description: "Service to configure (github, vercel, cloudflare, anthropic, openai, fal, custom)",
+      type: "string",
+      choices: [
+        { name: "GitHub", value: "github" },
+        { name: "Vercel", value: "vercel" },
+        { name: "Cloudflare", value: "cloudflare" },
+        { name: "Anthropic", value: "anthropic" },
+        { name: "OpenAI", value: "openai" },
+        { name: "fal.ai", value: "fal" },
+        { name: "Custom", value: "custom" }
+      ]
+    }
+  ],
+  ephemeral: true,
+  async execute(interaction) {
+    const service = interaction.options.getString("service");
+    if (!service) {
+      const services = listPresets().filter((presetName) => presetName !== "generic").map((presetName) => {
+        const preset = getPreset(presetName);
+        return `- **${preset?.displayName ?? presetName}** - \`/setup service:${presetName}\``;
+      });
+      await interaction.reply({
+        content: [
+          "**Credential Setup**",
+          "Choose a service to configure:",
+          "",
+          ...services,
+          "- **Custom** - `/setup service:custom`",
+          "",
+          "I'll walk you through it in DMs to keep your keys safe."
+        ].join(`
+`),
+        ephemeral: true
+      });
+      return;
+    }
+    await interaction.reply({
+      content: `Starting **${service}** setup. Check your DMs - I'll walk you through it there to keep your keys private.`,
+      ephemeral: true
     });
+    try {
+      const dmChannel = await interaction.user.createDM();
+      const presetKey = service === "custom" ? "generic" : service;
+      const preset = getPreset(presetKey);
+      if (!preset) {
+        await dmChannel.send(`I don't have a preset for "${service}". Try \`/setup\` to see available services.`);
+        return;
+      }
+      const field = preset.fields[0];
+      const helpLine = preset.helpUrl ? `Here's where to get one: ${preset.helpUrl}` : "";
+      await dmChannel.send([
+        `Setting up **${preset.displayName}** credentials.`,
+        preset.helpText,
+        helpLine,
+        "",
+        `Please paste your **${field.label}** here. ${field.secret ? "I'll delete your message right after reading it." : ""}`,
+        "",
+        "(Type `cancel` to abort setup)"
+      ].filter(Boolean).join(`
+`));
+    } catch {
+      try {
+        await interaction.followUp({
+          content: "I couldn't send you a DM. Make sure your DMs are open and try again.",
+          ephemeral: true
+        });
+      } catch {}
+    }
   }
-  return changes;
-}
-function diffOverwrites(oldOw, newOw) {
-  if (!oldOw && !newOw) {
-    return { changes: [], action: "UPDATE" };
+};
+var modelCommand = {
+  name: "model",
+  description: "View or change the active AI model",
+  options: [
+    {
+      name: "name",
+      description: "Model name to switch to (leave empty to view current)",
+      type: "string",
+      autocomplete: true
+    }
+  ],
+  ephemeral: true,
+  async execute(interaction, runtime) {
+    const modelName = interaction.options.getString("name");
+    if (!modelName) {
+      await interaction.reply({
+        content: `**Current model:** \`${runtime.getSetting("MODEL") ?? runtime.getSetting("DEFAULT_MODEL") ?? "(not configured)"}\``,
+        ephemeral: true
+      });
+      return;
+    }
+    await interaction.reply({
+      content: `Model switching to \`${modelName}\` is noted. The runtime model is still controlled by configuration, so update the setting and restart to switch permanently.`,
+      ephemeral: true
+    });
+  },
+  async autocomplete(interaction) {
+    const runtime = interaction.client.runtime;
+    const models = runtime ? getKnownModels(runtime) : [...FALLBACK_KNOWN_MODELS];
+    const focused = interaction.options.getFocused().toLowerCase();
+    const filtered = models.filter((model) => model.toLowerCase().includes(focused)).slice(0, 25);
+    await interaction.respond(filtered.map((model) => ({ name: model, value: model })));
   }
-  if (!oldOw && newOw) {
-    return { changes: overwriteToChanges(newOw, false), action: "CREATE" };
+};
+function registerBuiltins() {
+  for (const command of [
+    helpCommand,
+    statusCommand,
+    searchCommand,
+    clearCommand,
+    settingsCommand,
+    modelCommand,
+    setupCommand
+  ]) {
+    commands.set(command.name, command);
   }
-  if (oldOw && !newOw) {
-    return { changes: overwriteToChanges(oldOw, true), action: "DELETE" };
+}
+registerBuiltins();
+function toDiscordSlashCommand(command) {
+  const options = command.options?.map((option) => ({
+    name: option.name,
+    description: option.description,
+    type: OPTION_TYPE_MAP[option.type] ?? ApplicationCommandOptionType.String,
+    required: option.required ?? false,
+    ...option.choices ? { choices: option.choices } : {},
+    ...option.autocomplete ? { autocomplete: option.autocomplete } : {}
+  }));
+  return {
+    name: command.name,
+    description: command.description,
+    options
+  };
+}
+async function registerSlashCommands(runtime) {
+  const registered = [...commands.values()].map(toDiscordSlashCommand);
+  runtime.logger.info({
+    src: "slash-commands",
+    count: registered.length,
+    names: [...commands.keys()]
+  }, "Registering built-in slash commands");
+  await runtime.emitEvent(["DISCORD_REGISTER_COMMANDS"], {
+    runtime,
+    source: "discord",
+    commands: registered
+  });
+}
+async function handleSlashCommand(interaction, runtime) {
+  const command = commands.get(interaction.commandName);
+  if (!command) {
+    return;
   }
-  const changes = [];
-  const oldAllow = oldOw?.allow.toArray();
-  const oldDeny = oldOw?.deny.toArray();
-  const newAllow = newOw?.allow.toArray();
-  const newDeny = newOw?.deny.toArray();
-  const allPerms = new Set([...oldAllow, ...oldDeny, ...newAllow, ...newDeny]);
-  for (const perm of allPerms) {
-    const oldState = getState(perm, oldAllow, oldDeny);
-    const newState = getState(perm, newAllow, newDeny);
-    if (oldState !== newState) {
-      changes.push({ permission: perm, oldState, newState });
+  if (command.cooldown && command.cooldown > 0) {
+    const userId = interaction.user.id;
+    let commandCooldowns = cooldowns.get(command.name);
+    if (!commandCooldowns) {
+      commandCooldowns = new Map;
+      cooldowns.set(command.name, commandCooldowns);
     }
-  }
-  return { changes, action: "UPDATE" };
-}
-function diffRolePermissions(oldRole, newRole) {
-  const oldPerms = oldRole.permissions.toArray();
-  const newPerms = newRole.permissions.toArray();
-  const changes = [];
-  for (const p of newPerms) {
-    if (!oldPerms.includes(p)) {
-      changes.push({ permission: p, oldState: "NEUTRAL", newState: "ALLOW" });
+    const lastUsed = commandCooldowns.get(userId);
+    const now = Date.now();
+    if (lastUsed && now - lastUsed < command.cooldown * 1000) {
+      const remaining = Math.ceil((command.cooldown * 1000 - (now - lastUsed)) / 1000);
+      await interaction.reply({
+        content: `Please wait **${remaining}s** before using \`/${command.name}\` again.`,
+        ephemeral: true
+      });
+      return;
     }
+    commandCooldowns.set(userId, now);
+    setTimeout(() => {
+      if (commandCooldowns?.get(userId) === now) {
+        commandCooldowns.delete(userId);
+      }
+    }, command.cooldown * 1000);
   }
-  for (const p of oldPerms) {
-    if (!newPerms.includes(p)) {
-      changes.push({ permission: p, oldState: "ALLOW", newState: "NEUTRAL" });
+  if (command.ownerOnly) {
+    const guild = interaction.guild;
+    if (guild && interaction.user.id !== guild.ownerId) {
+      await interaction.reply({
+        content: "This command can only be used by the server owner.",
+        ephemeral: true
+      });
+      return;
     }
   }
-  return changes;
+  try {
+    await command.execute(interaction, runtime);
+  } catch (error) {
+    const content = `An error occurred while running \`/${command.name}\`: ${error instanceof Error ? error.message : String(error)}`;
+    runtime.logger.error({
+      src: "slash-commands",
+      commandName: command.name,
+      error: error instanceof Error ? error.message : String(error)
+    }, "Error executing slash command");
+    try {
+      if (interaction.deferred) {
+        await interaction.editReply({ content });
+      } else if (!interaction.replied) {
+        await interaction.reply({ content, ephemeral: true });
+      }
+    } catch {}
+  }
 }
-function diffMemberRoles(oldMember, newMember) {
-  const oldRoles = oldMember.roles.cache;
-  const newRoles = newMember.roles.cache;
-  return {
-    added: [...newRoles.filter((r) => !oldRoles.has(r.id)).values()],
-    removed: [...oldRoles.filter((r) => !newRoles.has(r.id)).values()]
-  };
+async function handleAutocomplete(interaction) {
+  const command = commands.get(interaction.commandName);
+  if (!command?.autocomplete) {
+    await interaction.respond([]);
+    return;
+  }
+  try {
+    await command.autocomplete(interaction);
+  } catch {
+    try {
+      await interaction.respond([]);
+    } catch {}
+  }
 }
 
 // voice.ts
@@ -9205,15 +11437,15 @@ import {
   VoiceConnectionStatus
 } from "@discordjs/voice";
 import {
-  ChannelType as ChannelType6,
-  createUniqueUuid as createUniqueUuid5,
+  ChannelType as ChannelType7,
+  createUniqueUuid as createUniqueUuid6,
   EventType as EventType2,
-  logger as logger3,
+  logger as logger4,
   ModelType as ModelType20,
-  stringToUuid as stringToUuid2
+  stringToUuid as stringToUuid3
 } from "@elizaos/core";
 import {
-  ChannelType as DiscordChannelType4
+  ChannelType as DiscordChannelType5
 } from "discord.js";
 import prism from "prism-media";
 var DECODE_FRAME_SIZE = 1024;
@@ -9222,16 +11454,16 @@ function createOpusDecoder(options) {
   try {
     return new prism.opus.Decoder(options);
   } catch (error) {
-    logger3.warn({
+    logger4.warn({
       src: "plugin:discord:service:voice",
       error: error instanceof Error ? error.message : String(error)
     }, "Failed to create opus decoder");
     try {
       const { generateDependencyReport } = __require("@discordjs/voice");
       const report = generateDependencyReport();
-      logger3.debug({ src: "plugin:discord:service:voice", report }, "Voice dependency report");
+      logger4.debug({ src: "plugin:discord:service:voice", report }, "Voice dependency report");
     } catch (reportError) {
-      logger3.warn({
+      logger4.warn({
         src: "plugin:discord:service:voice",
         error: reportError instanceof Error ? reportError.message : String(reportError)
       }, "Could not generate dependency report");
@@ -9278,7 +11510,7 @@ class AudioMonitor {
       }
     });
     this.readable.on("end", () => {
-      logger3.debug({ src: "plugin:discord:service:voice" }, "AudioMonitor ended");
+      logger4.debug({ src: "plugin:discord:service:voice" }, "AudioMonitor ended");
       this.ended = true;
       if (this.lastFlagged < 0) {
         return;
@@ -9290,7 +11522,7 @@ class AudioMonitor {
       if (this.ended) {
         return;
       }
-      logger3.debug({ src: "plugin:discord:service:voice" }, "Speaking stopped");
+      logger4.debug({ src: "plugin:discord:service:voice" }, "Speaking stopped");
       if (this.lastFlagged < 0) {
         return;
       }
@@ -9301,7 +11533,7 @@ class AudioMonitor {
         return;
       }
       onStart();
-      logger3.debug({ src: "plugin:discord:service:voice" }, "Speaking started");
+      logger4.debug({ src: "plugin:discord:service:voice" }, "Speaking started");
       this.reset();
     });
   }
@@ -9361,9 +11593,9 @@ class VoiceManager extends EventEmitter {
   }
   async getChannelType(channel) {
     switch (channel.type) {
-      case DiscordChannelType4.GuildVoice:
-      case DiscordChannelType4.GuildStageVoice:
-        return ChannelType6.VOICE_GROUP;
+      case DiscordChannelType5.GuildVoice:
+      case DiscordChannelType5.GuildStageVoice:
+        return ChannelType7.VOICE_GROUP;
       default:
         this.runtime.logger.error({
           src: "plugin:discord:service:voice",
@@ -9383,6 +11615,33 @@ class VoiceManager extends EventEmitter {
       ready: this.ready
     }, "VoiceManager ready status changed");
   }
+  stop() {
+    if (this.transcriptionTimeout) {
+      clearTimeout(this.transcriptionTimeout);
+      this.transcriptionTimeout = null;
+    }
+    for (const memberId of [...this.activeMonitors.keys()]) {
+      this.stopMonitoringMember(memberId);
+    }
+    for (const connection of new Set(this.connections.values())) {
+      try {
+        connection.destroy();
+      } catch (error) {
+        this.runtime.logger.warn({
+          src: "plugin:discord:service:voice",
+          agentId: this.runtime.agentId,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to destroy Discord voice connection during shutdown");
+      }
+    }
+    this.connections.clear();
+    this.streams.clear();
+    this.userStates.clear();
+    this.processingVoice = false;
+    this.cleanupAudioPlayer(this.activeAudioPlayer);
+    this.removeAllListeners();
+    this.ready = false;
+  }
   isReady() {
     return this.ready;
   }
@@ -9839,23 +12098,24 @@ class VoiceManager extends EventEmitter {
       if (!message || message.trim() === "" || message.length < 3) {
         return { text: "", actions: ["IGNORE"] };
       }
-      const roomId = createUniqueUuid5(this.runtime, channelId);
-      const uniqueEntityId = createUniqueUuid5(this.runtime, entityId);
+      const roomId = createUniqueUuid6(this.runtime, channelId);
+      const uniqueEntityId = createUniqueUuid6(this.runtime, entityId);
       const type = await this.getChannelType(channel);
       await this.runtime.ensureConnection({
         entityId: uniqueEntityId,
         roomId,
+        roomName: channel.name,
         userName,
         name,
         source: "discord",
         channelId,
-        messageServerId: stringToUuid2(channel.guild.id),
+        messageServerId: stringToUuid3(channel.guild.id),
         type,
-        worldId: createUniqueUuid5(this.runtime, channel.guild.id),
+        worldId: createUniqueUuid6(this.runtime, channel.guild.id),
         worldName: channel.guild.name
       });
       const memory = {
-        id: createUniqueUuid5(this.runtime, `${channelId}-voice-message-${Date.now()}`),
+        id: createUniqueUuid6(this.runtime, `${channelId}-voice-message-${Date.now()}`),
         agentId: this.runtime.agentId,
         entityId: uniqueEntityId,
         roomId,
@@ -9872,12 +12132,14 @@ class VoiceManager extends EventEmitter {
       };
       const callback = async (content, _actionName) => {
         try {
+          const responseText = normalizeDiscordMessageText(content.text);
           const responseMemory = {
-            id: createUniqueUuid5(this.runtime, `${memory.id}-voice-response-${Date.now()}`),
+            id: createUniqueUuid6(this.runtime, `${memory.id}-voice-response-${Date.now()}`),
             entityId: this.runtime.agentId,
             agentId: this.runtime.agentId,
             content: {
               ...content,
+              text: responseText || undefined,
               name: this.runtime.character.name,
               inReplyTo: memory.id,
               isVoiceMessage: true,
@@ -9889,8 +12151,8 @@ class VoiceManager extends EventEmitter {
           const responseMemoryContentText = responseMemory.content.text;
           if (responseMemoryContentText?.trim()) {
             await this.runtime.createMemory(responseMemory, "messages");
-            if (content.text) {
-              const responseStream = await this.runtime.useModel(ModelType20.TEXT_TO_SPEECH, content.text);
+            if (responseText) {
+              const responseStream = await this.runtime.useModel(ModelType20.TEXT_TO_SPEECH, responseText);
               if (responseStream) {
                 const buffer = Buffer.isBuffer(responseStream) ? responseStream : Buffer.from(responseStream);
                 const readable = Readable.from(buffer);
@@ -9954,7 +12216,7 @@ class VoiceManager extends EventEmitter {
         }
       }
       if (!chosenChannel) {
-        const channels = (await guild.channels.fetch()).filter((channel) => channel && channel.type === DiscordChannelType4.GuildVoice);
+        const channels = (await guild.channels.fetch()).filter((channel) => channel && channel.type === DiscordChannelType5.GuildVoice);
         for (const [, channel] of channels) {
           const voiceChannel = channel;
           if (voiceChannel.members.size > 0 && (chosenChannel === null || voiceChannel.members.size > chosenChannel.members.size)) {
@@ -10048,7 +12310,7 @@ class VoiceManager extends EventEmitter {
         await interaction.editReply("Could not find guild.");
         return;
       }
-      const voiceChannel = interaction.guild.channels.cache.find((channel) => channel.id === channelId && channel.type === DiscordChannelType4.GuildVoice);
+      const voiceChannel = interaction.guild.channels.cache.find((channel) => channel.id === channelId && channel.type === DiscordChannelType5.GuildVoice);
       if (!voiceChannel) {
         await interaction.editReply("Voice channel not found!");
         return;
@@ -10095,6 +12357,23 @@ class VoiceManager extends EventEmitter {
 }
 
 // service.ts
+var DISCORD_SNOWFLAKE_PATTERN2 = /^\d{15,20}$/;
+function normalizeDiscordTargetUserId(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return DISCORD_SNOWFLAKE_PATTERN2.test(trimmed) ? trimmed : null;
+}
+function extractDiscordUserIdFromMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object") {
+    return null;
+  }
+  const record = metadata;
+  const discord = record.discord && typeof record.discord === "object" ? record.discord : null;
+  return normalizeDiscordTargetUserId(discord?.userId) ?? normalizeDiscordTargetUserId(discord?.id) ?? normalizeDiscordTargetUserId(record.originalId);
+}
+
 class DiscordService extends Service {
   static serviceType = DISCORD_SERVICE_NAME;
   capabilityDescription = "The agent is able to send and receive messages on discord";
@@ -10102,6 +12381,9 @@ class DiscordService extends Service {
   character;
   messageManager;
   voiceManager;
+  messageDebouncer;
+  channelDebouncer;
+  _loginFailed = false;
   discordSettings;
   userSelections = new Map;
   timeouts = [];
@@ -10111,6 +12393,78 @@ class DiscordService extends Service {
   allowAllSlashCommands = new Set;
   allowedChannelIds;
   dynamicChannelIds = new Set;
+  ownerDiscordUserIds = new Set;
+  resolveDiscordEntityId(userId) {
+    return resolveDiscordRuntimeEntityId(this.runtime, userId, this.ownerDiscordUserIds);
+  }
+  async refreshOwnerDiscordUserIds(client) {
+    const explicitSetting = this.runtime.getSetting?.("MILADY_DISCORD_OWNER_USER_IDS_JSON");
+    const hasExplicitSetting = explicitSetting !== undefined && explicitSetting !== null && !(typeof explicitSetting === "string" && explicitSetting.trim() === "");
+    let ownerIds;
+    if (hasExplicitSetting) {
+      ownerIds = parseDiscordOwnerUserIds(Array.isArray(explicitSetting) ? explicitSetting : typeof explicitSetting === "string" ? explicitSetting : [String(explicitSetting)]);
+    } else {
+      const application = client.application && typeof client.application.fetch === "function" ? await client.application.fetch() : client.application;
+      ownerIds = [...new Set(extractDiscordOwnerUserIds(application))];
+    }
+    this.ownerDiscordUserIds = new Set(ownerIds);
+    if (ownerIds.length === 0) {
+      return;
+    }
+    const existingWhitelist = getConnectorAdminWhitelist(this.runtime);
+    const nextDiscordAdmins = [
+      ...new Set([...existingWhitelist.discord ?? [], ...ownerIds])
+    ];
+    setConnectorAdminWhitelist(this.runtime, {
+      ...existingWhitelist,
+      discord: nextDiscordAdmins
+    });
+    this.runtime.logger.info({
+      src: "plugin:discord",
+      agentId: this.runtime.agentId,
+      ownerDiscordUserIds: ownerIds
+    }, "Resolved Discord owner identities for canonical Milady owner mapping");
+  }
+  async resolveDiscordTargetUserId(targetEntityId) {
+    const directId = normalizeDiscordTargetUserId(targetEntityId);
+    if (directId) {
+      return directId;
+    }
+    if (targetEntityId === resolveMiladyOwnerEntityId(this.runtime)) {
+      const knownOwnerUserId = this.ownerDiscordUserIds.values().next().value;
+      if (typeof knownOwnerUserId === "string" && knownOwnerUserId.length > 0) {
+        return knownOwnerUserId;
+      }
+    }
+    const directEntity = this.runtime.getEntityById ? await this.runtime.getEntityById(targetEntityId) : null;
+    const directMetadataUserId = extractDiscordUserIdFromMetadata(directEntity?.metadata);
+    if (directMetadataUserId) {
+      return directMetadataUserId;
+    }
+    if (typeof this.runtime.getRelationships !== "function") {
+      return null;
+    }
+    const identityLinks = await this.runtime.getRelationships({
+      entityIds: [targetEntityId],
+      tags: ["identity_link"]
+    });
+    for (const relationship of identityLinks) {
+      const metadata = relationship.metadata && typeof relationship.metadata === "object" ? relationship.metadata : null;
+      if (metadata?.status !== "confirmed") {
+        continue;
+      }
+      const linkedEntityId = relationship.sourceEntityId === targetEntityId ? relationship.targetEntityId : relationship.targetEntityId === targetEntityId ? relationship.sourceEntityId : null;
+      if (!linkedEntityId || linkedEntityId === targetEntityId) {
+        continue;
+      }
+      const linkedEntity = this.runtime.getEntityById ? await this.runtime.getEntityById(linkedEntityId) : null;
+      const linkedMetadataUserId = extractDiscordUserIdFromMetadata(linkedEntity?.metadata);
+      if (linkedMetadataUserId) {
+        return linkedMetadataUserId;
+      }
+    }
+    return null;
+  }
   constructor(runtime) {
     super(runtime);
     this.discordSettings = getDiscordSettings(runtime);
@@ -10179,13 +12533,26 @@ class DiscordService extends Service {
           reject(error);
         });
       });
-      this.clientReadyPromise.catch((_error) => {});
+      this.clientReadyPromise.catch((error) => {
+        this.runtime.logger.error({
+          src: "plugin:discord",
+          agentId: this.runtime.agentId,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Discord client ready promise rejected");
+        this._loginFailed = true;
+      });
       this.setupEventListeners();
     } catch (error) {
       runtime.logger.error(`Error initializing Discord client: ${error instanceof Error ? error.message : String(error)}`);
       this.client = null;
     }
   }
+  isHealthy() {
+    if (this._loginFailed || !this.client) {
+      return false;
+    }
+    return this.client.isReady();
+  }
   static async start(runtime) {
     const service = new DiscordService(runtime);
     return service;
@@ -10196,22 +12563,31 @@ class DiscordService extends Service {
       throw new Error("Discord client is not ready.");
     }
     const client = this.client;
-    if (target.channelId && this.allowedChannelIds && !this.isChannelAllowed(target.channelId)) {
-      runtime.logger.warn(`Channel ${target.channelId} not in allowed list, skipping send`);
-      return;
-    }
     let targetChannel = null;
+    let resolvedChannelId = null;
     try {
       if (target.channelId) {
+        resolvedChannelId = target.channelId;
         targetChannel = await client.channels.fetch(target.channelId);
+      } else if (target.roomId) {
+        const room = typeof runtime.getRoom === "function" ? await runtime.getRoom(target.roomId) : null;
+        const roomChannelId = room?.channelId && typeof room.channelId === "string" ? room.channelId : null;
+        if (!roomChannelId) {
+          throw new Error(`Could not resolve Discord channel ID for room ${target.roomId}`);
+        }
+        resolvedChannelId = roomChannelId;
+        targetChannel = await client.channels.fetch(roomChannelId);
       } else if (target.entityId) {
-        const discordUserId = target.entityId;
+        const discordUserId = await this.resolveDiscordTargetUserId(target.entityId);
+        if (!discordUserId) {
+          throw new Error(`Could not resolve Discord user ID for runtime entity ${target.entityId}`);
+        }
         const user = await client.users.fetch(discordUserId);
         if (user) {
           targetChannel = user.dmChannel ?? await user.createDM();
         }
       } else {
-        throw new Error("Discord SendHandler requires channelId or entityId.");
+        throw new Error("Discord SendHandler requires channelId, roomId, or entityId.");
       }
       if (!targetChannel) {
         const targetStr = JSON.stringify(target, (_key, value) => {
@@ -10222,6 +12598,12 @@ class DiscordService extends Service {
         });
         throw new Error(`Could not find target Discord channel/DM for target: ${targetStr}`);
       }
+      const allowedByParentThread = typeof targetChannel.isThread === "function" && targetChannel.isThread() && "parentId" in targetChannel && typeof targetChannel.parentId === "string" && targetChannel.parentId.length > 0 && this.isChannelAllowed(targetChannel.parentId);
+      if (this.allowedChannelIds && !this.isChannelAllowed(targetChannel.id) && !allowedByParentThread) {
+        const resolvedFromText = resolvedChannelId && resolvedChannelId !== targetChannel.id ? ` (resolved from ${resolvedChannelId})` : "";
+        runtime.logger.warn(`Channel ${targetChannel.id}${resolvedFromText} not in allowed list, skipping send`);
+        return;
+      }
       if (targetChannel.isTextBased() && !targetChannel.isVoiceBased()) {
         if ("send" in targetChannel && typeof targetChannel.send === "function") {
           const files = [];
@@ -10234,11 +12616,12 @@ class DiscordService extends Service {
             }
           }
           const sentMessages = [];
-          const roomId = createUniqueUuid6(runtime, targetChannel.id);
+          const roomId = createUniqueUuid7(runtime, targetChannel.id);
           const channelType = await this.getChannelType(targetChannel);
-          if (content.text || files.length > 0) {
-            if (content.text) {
-              const chunks = splitMessage(content.text, MAX_MESSAGE_LENGTH);
+          const textContent = normalizeDiscordMessageText(content.text);
+          if (textContent || files.length > 0) {
+            if (textContent) {
+              const chunks = splitMessage(textContent, MAX_MESSAGE_LENGTH);
               if (chunks.length > 1) {
                 for (let i = 0;i < chunks.length - 1; i++) {
                   const sent2 = await targetChannel.send(chunks[i]);
@@ -10267,17 +12650,18 @@ class DiscordService extends Service {
           }
           const targetChannelGuild = "guild" in targetChannel ? targetChannel.guild : null;
           const serverId = targetChannelGuild?.id ? targetChannelGuild.id : targetChannel.id;
-          const worldId = createUniqueUuid6(runtime, serverId);
+          const worldId = createUniqueUuid7(runtime, serverId);
           const worldName = targetChannelGuild?.name ? targetChannelGuild.name : undefined;
           const clientUser = client.user;
           await this.runtime.ensureConnection({
             entityId: runtime.agentId,
             roomId,
+            roomName: "name" in targetChannel && typeof targetChannel.name === "string" ? targetChannel.name : clientUser?.displayName || clientUser?.username || undefined,
             userName: clientUser?.username ? clientUser.username : undefined,
             name: clientUser?.displayName || clientUser?.username || undefined,
             source: "discord",
             channelId: targetChannel.id,
-            messageServerId: stringToUuid3(serverId),
+            messageServerId: stringToUuid4(serverId),
             type: channelType,
             worldId,
             worldName
@@ -10286,12 +12670,12 @@ class DiscordService extends Service {
             try {
               const hasAttachments = sentMsg.attachments.size > 0;
               const memory = {
-                id: createUniqueUuid6(runtime, sentMsg.id),
+                id: createUniqueUuid7(runtime, sentMsg.id),
                 entityId: runtime.agentId,
                 agentId: runtime.agentId,
                 roomId,
                 content: {
-                  text: sentMsg.content || content.text || " ",
+                  text: sentMsg.content || textContent || " ",
                   url: sentMsg.url,
                   channelType,
                   ...hasAttachments && content.attachments ? { attachments: content.attachments } : {},
@@ -10329,6 +12713,64 @@ class DiscordService extends Service {
     }
     const listenCidsRaw = this.runtime.getSetting("DISCORD_LISTEN_CHANNEL_IDS");
     const listenCids = Array.isArray(listenCidsRaw) ? listenCidsRaw : listenCidsRaw && typeof listenCidsRaw === "string" && listenCidsRaw.trim() ? listenCidsRaw.trim().split(",").map((s) => s.trim()).filter((s) => s.length > 0) : [];
+    const debounceMsSetting = this.runtime.getSetting("DISCORD_DEBOUNCE_MS");
+    const debounceMs = typeof debounceMsSetting === "number" ? debounceMsSetting : typeof debounceMsSetting === "string" && debounceMsSetting.trim() ? Number.parseInt(debounceMsSetting, 10) || 400 : 400;
+    this.messageDebouncer = createMessageDebouncer((messages) => {
+      if (!this.messageManager || messages.length === 0) {
+        return;
+      }
+      if (messages.length === 1) {
+        this.messageManager.handleMessage(messages[0]);
+        return;
+      }
+      const anchor = messages[0];
+      const combinedText = messages.map((message) => message.content).join(`
+`);
+      const combined = Object.create(anchor, {
+        content: { value: combinedText, writable: true, enumerable: true }
+      });
+      this.messageManager.handleMessage(combined);
+    }, debounceMs);
+    const channelDebounceMsSetting = this.runtime.getSetting("DISCORD_CHANNEL_DEBOUNCE_MS");
+    const channelDebounceMs = typeof channelDebounceMsSetting === "number" ? channelDebounceMsSetting : typeof channelDebounceMsSetting === "string" && channelDebounceMsSetting.trim() ? Number.parseInt(channelDebounceMsSetting, 10) || 3000 : 3000;
+    const responseCooldownMsSetting = this.runtime.getSetting("DISCORD_RESPONSE_COOLDOWN_MS");
+    const responseCooldownMs = typeof responseCooldownMsSetting === "number" ? responseCooldownMsSetting : typeof responseCooldownMsSetting === "string" && responseCooldownMsSetting.trim() ? Number.parseInt(responseCooldownMsSetting, 10) || 30000 : 30000;
+    this.channelDebouncer = createChannelDebouncer((messages) => {
+      if (!this.messageManager || messages.length === 0) {
+        return;
+      }
+      const clientUser = this.client?.user;
+      const botId = clientUser?.id;
+      const agentName = this.character?.name?.toLowerCase();
+      let anchor;
+      if (botId) {
+        anchor = messages.find((message) => message.mentions?.users?.has(botId) || Boolean(agentName && agentName.length >= 2 && message.content?.toLowerCase().includes(agentName)));
+        if (!anchor) {
+          anchor = messages.find((message) => Boolean(message.reference?.messageId) && message.mentions?.repliedUser?.id === botId);
+        }
+      }
+      anchor ??= messages[messages.length - 1];
+      if (messages.length === 1) {
+        this.messageManager.handleMessage(anchor);
+      } else {
+        const contextLines = messages.filter((message) => message.id !== anchor?.id).map((message) => `${message.member?.displayName ?? message.author.globalName ?? message.author.displayName ?? message.author.username}: ${message.content}`);
+        const combinedText = contextLines.length > 0 ? `[Recent channel context]
+${contextLines.join(`
+`)}
+
+${anchor.content || ""}` : anchor.content || "";
+        const combined = Object.create(anchor, {
+          content: { value: combinedText, writable: true, enumerable: true }
+        });
+        this.messageManager.handleMessage(combined);
+      }
+      this.channelDebouncer?.markResponded(messages[0].channel.id);
+    }, {
+      debounceMs: channelDebounceMs,
+      responseCooldownMs,
+      getBotUserId: () => this.client?.user?.id,
+      botName: this.character?.name
+    });
     this.client.on("messageCreate", async (message) => {
       const clientUser = this.client?.user;
       if (clientUser && message.author.id === clientUser.id || message.author.bot && this.discordSettings.shouldIgnoreBotMessages) {
@@ -10394,8 +12836,23 @@ class DiscordService extends Service {
         }
       }
       try {
-        if (this.messageManager) {
-          this.messageManager.handleMessage(message);
+        if (!this.messageManager) {
+          return;
+        }
+        const channelType = message.channel.type;
+        const isDm = channelType === DiscordChannelType6.DM || channelType === DiscordChannelType6.GroupDM;
+        if (isDm) {
+          if (this.messageDebouncer) {
+            this.messageDebouncer.enqueue(message);
+          } else {
+            await this.messageManager.handleMessage(message);
+          }
+        } else if (this.channelDebouncer) {
+          this.channelDebouncer.enqueue(message);
+        } else if (this.messageDebouncer) {
+          this.messageDebouncer.enqueue(message);
+        } else {
+          await this.messageManager.handleMessage(message);
         }
       } catch (error) {
         this.runtime.logger.error({
@@ -10464,6 +12921,18 @@ class DiscordService extends Service {
       }
     });
     this.client.on("interactionCreate", async (interaction) => {
+      if (interaction.isAutocomplete()) {
+        try {
+          await handleAutocomplete(interaction);
+        } catch (error) {
+          this.runtime.logger.error({
+            src: "plugin:discord",
+            agentId: this.runtime.agentId,
+            error: error instanceof Error ? error.message : String(error)
+          }, "Error handling Discord autocomplete interaction");
+        }
+        return;
+      }
       const isSlashCommand = interaction.isCommand();
       const isModalSubmit = interaction.isModalSubmit();
       const isComponent = interaction.isMessageComponent();
@@ -10571,6 +13040,9 @@ class DiscordService extends Service {
       }
       try {
         await this.handleInteractionCreate(interaction);
+        if (interaction.isChatInputCommand()) {
+          await handleSlashCommand(interaction, this.runtime);
+        }
       } catch (error) {
         this.runtime.logger.error({
           src: "plugin:discord",
@@ -10588,7 +13060,7 @@ class DiscordService extends Service {
       }
     });
     const auditLogSetting = this.runtime.getSetting("DISCORD_AUDIT_LOG_ENABLED");
-    const isAuditLogEnabled = auditLogSetting !== "false" && auditLogSetting !== false;
+    const isAuditLogEnabled = auditLogSetting === "true" || auditLogSetting === true || auditLogSetting === "1" || auditLogSetting === 1;
     if (isAuditLogEnabled) {
       this.client.on("channelUpdate", async (oldChannel, newChannel) => {
         try {
@@ -10785,8 +13257,8 @@ class DiscordService extends Service {
     this.runtime.logger.info(`New member joined: ${member.user.username} (${member.id})`);
     const guild = member.guild;
     const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
-    const worldId = createUniqueUuid6(this.runtime, guild.id);
-    const entityId = createUniqueUuid6(this.runtime, member.id);
+    const worldId = createUniqueUuid7(this.runtime, guild.id);
+    const entityId = this.resolveDiscordEntityId(member.id);
     this.runtime.emitEvent(["DISCORD_USER_JOINED" /* ENTITY_JOINED */], {
       runtime: this.runtime,
       entityId,
@@ -10803,7 +13275,7 @@ class DiscordService extends Service {
       member
     });
   }
-  async registerSlashCommands(commands) {
+  async registerSlashCommands(commands2) {
     await this.clientReadyPromise;
     const sanitizeCommandForLogging = (cmd) => {
       const sanitized = {
@@ -10823,11 +13295,11 @@ class DiscordService extends Service {
       }
       return sanitized;
     };
-    const sanitizedCommands = commands.map(sanitizeCommandForLogging);
+    const sanitizedCommands = commands2.map(sanitizeCommandForLogging);
     this.runtime.logger.debug({
       src: "plugin:discord",
       agentId: this.runtime.agentId,
-      commandCount: commands.length,
+      commandCount: commands2.length,
       commands: sanitizedCommands
     }, "Registering Discord commands");
     const clientApplication = this.client?.application;
@@ -10835,11 +13307,11 @@ class DiscordService extends Service {
       this.runtime.logger.warn({ src: "plugin:discord", agentId: this.runtime.agentId }, "Cannot register commands - Discord client application not available");
       return;
     }
-    if (!Array.isArray(commands) || commands.length === 0) {
+    if (!Array.isArray(commands2) || commands2.length === 0) {
       this.runtime.logger.warn({ src: "plugin:discord", agentId: this.runtime.agentId }, "Cannot register commands - no commands provided");
       return;
     }
-    for (const cmd of commands) {
+    for (const cmd of commands2) {
       if (!cmd.name || !cmd.description) {
         this.runtime.logger.warn({
           src: "plugin:discord",
@@ -10858,7 +13330,7 @@ class DiscordService extends Service {
           commandMap.set(cmd.name, cmd);
         }
       }
-      for (const cmd of commands) {
+      for (const cmd of commands2) {
         if (cmd.name) {
           commandMap.set(cmd.name, cmd);
         }
@@ -10997,7 +13469,7 @@ class DiscordService extends Service {
       this.runtime.logger.info({
         src: "plugin:discord",
         agentId: this.runtime.agentId,
-        newCommands: commands.length,
+        newCommands: commands2.length,
         totalCommands: this.slashCommands.length,
         globalCommands: transformedGlobalCommands.length,
         globalCommandsRegisteredForDMs: globalCommandsRegistered,
@@ -11086,7 +13558,7 @@ class DiscordService extends Service {
         }, "Failed to register commands to newly joined guild");
       }
     }
-    const worldId = createUniqueUuid6(this.runtime, fullGuild.id);
+    const worldId = createUniqueUuid7(this.runtime, fullGuild.id);
     const standardizedData = {
       runtime: this.runtime,
       rooms: await this.buildStandardizedRooms(fullGuild, worldId),
@@ -11113,11 +13585,11 @@ class DiscordService extends Service {
     this.runtime.emitEvent([EventType3.WORLD_JOINED], standardizedData);
   }
   async handleInteractionCreate(interaction) {
-    const entityId = createUniqueUuid6(this.runtime, interaction.user.id);
+    const entityId = this.resolveDiscordEntityId(interaction.user.id);
     const userName = interaction.user.bot ? `${interaction.user.username}#${interaction.user.discriminator}` : interaction.user.username;
     const name = interaction.user.displayName;
     const interactionChannelId = interaction.channel?.id;
-    const roomId = createUniqueUuid6(this.runtime, interactionChannelId || userName);
+    const roomId = createUniqueUuid7(this.runtime, interactionChannelId || userName);
     let type;
     let serverId;
     if (interaction.guild) {
@@ -11132,19 +13604,20 @@ class DiscordService extends Service {
       }
       serverId = guild.id;
     } else {
-      type = ChannelType7.DM;
+      type = ChannelType8.DM;
       serverId = interactionChannelId;
     }
     await this.runtime.ensureConnection({
       entityId,
       roomId,
+      roomName: interaction.guild && interaction.channel && "name" in interaction.channel && typeof interaction.channel.name === "string" ? interaction.channel.name : name,
       userName,
       name,
       source: "discord",
       channelId: interactionChannelId,
-      messageServerId: serverId ? stringToUuid3(serverId) : undefined,
+      messageServerId: serverId ? stringToUuid4(serverId) : undefined,
       type,
-      worldId: createUniqueUuid6(this.runtime, serverId ?? roomId),
+      worldId: createUniqueUuid7(this.runtime, serverId ?? roomId),
       worldName: interaction.guild?.name || undefined,
       userId: interaction.user.id,
       metadata: buildDiscordWorldMetadata(this.runtime, interaction.guild?.ownerId)
@@ -11333,23 +13806,23 @@ class DiscordService extends Service {
   async buildStandardizedRooms(guild, _worldId) {
     const rooms = [];
     for (const [channelId, channel] of guild.channels.cache) {
-      if (channel.type === DiscordChannelType5.GuildText || channel.type === DiscordChannelType5.GuildVoice) {
-        const roomId = createUniqueUuid6(this.runtime, channelId);
+      if (channel.type === DiscordChannelType6.GuildText || channel.type === DiscordChannelType6.GuildVoice) {
+        const roomId = createUniqueUuid7(this.runtime, channelId);
         let channelType;
         switch (channel.type) {
-          case DiscordChannelType5.GuildText:
-            channelType = ChannelType7.GROUP;
+          case DiscordChannelType6.GuildText:
+            channelType = ChannelType8.GROUP;
             break;
-          case DiscordChannelType5.GuildVoice:
-            channelType = ChannelType7.VOICE_GROUP;
+          case DiscordChannelType6.GuildVoice:
+            channelType = ChannelType8.VOICE_GROUP;
             break;
           default:
-            channelType = ChannelType7.GROUP;
+            channelType = ChannelType8.GROUP;
         }
         let participants = [];
-        if (guild.memberCount < 1000 && channel.type === DiscordChannelType5.GuildText) {
+        if (guild.memberCount < 1000 && channel.type === DiscordChannelType6.GuildText) {
           try {
-            participants = Array.from(guild.members.cache.values()).filter((member) => channel.permissionsFor(member)?.has(PermissionsBitField5.Flags.ViewChannel)).map((member) => createUniqueUuid6(this.runtime, member.id));
+            participants = Array.from(guild.members.cache.values()).filter((member) => channel.permissionsFor(member)?.has(PermissionsBitField5.Flags.ViewChannel)).map((member) => this.resolveDiscordEntityId(member.id));
           } catch (error) {
             this.runtime.logger.warn({
               src: "plugin:discord",
@@ -11390,14 +13863,14 @@ class DiscordService extends Service {
           const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
           if (member.id !== botId) {
             entities.push({
-              id: createUniqueUuid6(this.runtime, member.id),
+              id: this.resolveDiscordEntityId(member.id),
               names: Array.from(new Set([
                 member.user.username,
                 member.displayName,
                 member.user.globalName
               ].filter(Boolean))),
               agentId: this.runtime.agentId,
-              metadata: buildDiscordEntityMetadata(member.id, tag, member.displayName || member.user.username, member.user.globalName ?? undefined)
+              metadata: buildDiscordEntityMetadata(member.id, tag, member.displayName || member.user.username, member.user.globalName ?? undefined, member.user.displayAvatarURL())
             });
           }
         }
@@ -11410,7 +13883,7 @@ class DiscordService extends Service {
           const onlineMembers = await guild.members.fetch({ limit: 100 });
           for (const [, member] of onlineMembers) {
             if (member.id !== botId) {
-              const entityId = createUniqueUuid6(this.runtime, member.id);
+              const entityId = this.resolveDiscordEntityId(member.id);
               if (!entities.some((u) => u.id === entityId)) {
                 const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
                 entities.push({
@@ -11421,7 +13894,7 @@ class DiscordService extends Service {
                     member.user.globalName
                   ].filter(Boolean))),
                   agentId: this.runtime.agentId,
-                  metadata: buildDiscordEntityMetadata(member.id, tag, member.displayName || member.user.username, member.user.globalName ?? undefined)
+                  metadata: buildDiscordEntityMetadata(member.id, tag, member.displayName || member.user.username, member.user.globalName ?? undefined, member.user.displayAvatarURL())
                 });
               }
             }
@@ -11445,14 +13918,14 @@ class DiscordService extends Service {
           if (member.id !== botId) {
             const tag = member.user.bot ? `${member.user.username}#${member.user.discriminator}` : member.user.username;
             entities.push({
-              id: createUniqueUuid6(this.runtime, member.id),
+              id: this.resolveDiscordEntityId(member.id),
               names: Array.from(new Set([
                 member.user.username,
                 member.displayName,
                 member.user.globalName
               ].filter(Boolean))),
               agentId: this.runtime.agentId,
-              metadata: buildDiscordEntityMetadata(member.id, tag, member.displayName || member.user.username, member.user.globalName ?? undefined)
+              metadata: buildDiscordEntityMetadata(member.id, tag, member.displayName || member.user.username, member.user.globalName ?? undefined, member.user.displayAvatarURL())
             });
           }
         }
@@ -11469,13 +13942,30 @@ class DiscordService extends Service {
   }
   async onReady(readyClient) {
     this.runtime.logger.success("Discord client ready");
+    const discordApiToken = this.runtime.getSetting("DISCORD_API_TOKEN");
+    if (typeof discordApiToken === "string" && discordApiToken.trim().length > 0 && typeof readyClient.rest?.setToken === "function") {
+      readyClient.rest.setToken(discordApiToken.trim());
+    }
+    await this.refreshOwnerDiscordUserIds(readyClient);
     this.slashCommands = [];
     this.runtime.registerEvent("DISCORD_REGISTER_COMMANDS", async (params) => {
       await this.registerSlashCommands(params.commands);
     });
+    await registerSlashCommands(this.runtime);
     const auditLogSettingForInvite = this.runtime.getSetting("DISCORD_AUDIT_LOG_ENABLED");
-    const isAuditLogEnabledForInvite = auditLogSettingForInvite !== "false" && auditLogSettingForInvite !== false;
+    const isAuditLogEnabledForInvite = auditLogSettingForInvite === "true" || auditLogSettingForInvite === true || auditLogSettingForInvite === "1" || auditLogSettingForInvite === 1;
     const readyClientUser = readyClient.user;
+    if (readyClientUser) {
+      try {
+        await syncDiscordClientProfile(this.runtime, readyClientUser, this.discordSettings);
+      } catch (error) {
+        this.runtime.logger.warn({
+          src: "plugin:discord",
+          agentId: this.runtime.agentId,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to synchronize Discord bot profile from connector settings");
+      }
+    }
     const inviteUrl = readyClientUser?.id ? generateInviteUrl(readyClientUser.id, "MODERATOR_VOICE") : undefined;
     if (isAuditLogEnabledForInvite) {
       this.runtime.logger.info({ src: "plugin:discord", agentId: this.runtime.agentId }, "Audit log tracking enabled - ensure bot has ViewAuditLog permission in server settings");
@@ -11498,7 +13988,7 @@ class DiscordService extends Service {
         try {
           const fullGuild = await guild.fetch();
           this.runtime.logger.info(`Discord server connected: ${fullGuild.name} (${fullGuild.id})`);
-          const worldId = createUniqueUuid6(this.runtime, fullGuild.id);
+          const worldId = createUniqueUuid7(this.runtime, fullGuild.id);
           const standardizedData = {
             name: fullGuild.name,
             runtime: this.runtime,
@@ -11535,7 +14025,7 @@ class DiscordService extends Service {
       this.timeouts.push(timeoutId);
     }
     const auditLogEnabled = this.runtime.getSetting("DISCORD_AUDIT_LOG_ENABLED");
-    if (auditLogEnabled !== "false" && auditLogEnabled !== false) {
+    if (auditLogEnabled === "true" || auditLogEnabled === true || auditLogEnabled === "1" || auditLogEnabled === 1) {
       try {
         const testGuild = guilds.first();
         if (testGuild) {
@@ -11544,11 +14034,15 @@ class DiscordService extends Service {
           this.runtime.logger.debug("Audit log access verified for permission tracking");
         }
       } catch (err) {
-        this.runtime.logger.warn({
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        const errorCode = typeof err === "object" && err !== null && "code" in err && typeof err.code !== "undefined" ? String(err.code) : "";
+        const missingAuditLogPermission = errorCode === "50013" || errorMessage.includes("Missing Permissions");
+        const logMethod = missingAuditLogPermission ? this.runtime.logger.info : this.runtime.logger.warn;
+        logMethod.call(this.runtime.logger, {
           src: "plugin:discord",
           agentId: this.runtime.agentId,
-          error: err instanceof Error ? err.message : String(err)
-        }, "Cannot access audit logs - permission change alerts will not include executor info");
+          error: errorMessage
+        }, missingAuditLogPermission ? "Audit log access unavailable - permission change alerts will not include executor info" : "Cannot access audit logs - permission change alerts will not include executor info");
       }
     }
     if (this.client) {
@@ -11574,7 +14068,7 @@ class DiscordService extends Service {
         this.runtime.logger.error({ src: "plugin:discord", agentId: this.runtime.agentId, channelId }, "Channel not found");
         return [];
       }
-      if (channel.type !== DiscordChannelType5.GuildText) {
+      if (channel.type !== DiscordChannelType6.GuildText) {
         this.runtime.logger.error({ src: "plugin:discord", agentId: this.runtime.agentId, channelId }, "Channel is not a text channel");
         return [];
       }
@@ -11706,9 +14200,9 @@ class DiscordService extends Service {
         }
       }
       const timestamp = Date.now();
-      const roomId = createUniqueUuid6(this.runtime, reaction.message.channel.id);
-      const entityId = createUniqueUuid6(this.runtime, user.id);
-      const reactionUUID = createUniqueUuid6(this.runtime, `${reaction.message.id}-${user.id}-${emoji}-${timestamp}`);
+      const roomId = createUniqueUuid7(this.runtime, reaction.message.channel.id);
+      const entityId = this.resolveDiscordEntityId(user.id);
+      const reactionUUID = createUniqueUuid7(this.runtime, `${reaction.message.id}-${user.id}-${emoji}-${timestamp}`);
       if (!entityId || !roomId) {
         this.runtime.logger.error({
           src: "plugin:discord",
@@ -11728,18 +14222,19 @@ class DiscordService extends Service {
       await this.runtime.ensureConnection({
         entityId,
         roomId,
+        roomName: "name" in reaction.message.channel && typeof reaction.message.channel.name === "string" ? reaction.message.channel.name : name,
         userName,
-        worldId: createUniqueUuid6(this.runtime, reaction.message.guild?.id ?? roomId),
+        worldId: createUniqueUuid7(this.runtime, reaction.message.guild?.id ?? roomId),
         worldName: reaction.message.guild?.name || undefined,
         name,
         source: "discord",
         channelId: reaction.message.channel.id,
-        messageServerId: reaction.message.guild?.id ? stringToUuid3(reaction.message.guild.id) : undefined,
+        messageServerId: reaction.message.guild?.id ? stringToUuid4(reaction.message.guild.id) : undefined,
         type: channelType,
         userId: user.id,
         metadata: buildDiscordWorldMetadata(this.runtime, reaction.message.guild?.ownerId)
       });
-      const inReplyTo = createUniqueUuid6(this.runtime, reaction.message.id);
+      const inReplyTo = createUniqueUuid7(this.runtime, reaction.message.id);
       const memory = {
         id: reactionUUID,
         entityId,
@@ -11750,6 +14245,16 @@ class DiscordService extends Service {
           inReplyTo,
           channelType
         },
+        metadata: {
+          entityName: name,
+          entityUserName: userName,
+          fromId: user.id,
+          discordReaction: {
+            action: type,
+            emoji,
+            targetMessageId: inReplyTo
+          }
+        },
         roomId,
         createdAt: timestamp
       };
@@ -11758,7 +14263,11 @@ class DiscordService extends Service {
           this.runtime.logger.error({ src: "plugin:discord", agentId: this.runtime.agentId }, "No channel found for reaction message");
           return [];
         }
-        await reaction.message.channel.send(content.text ?? "");
+        const responseText = normalizeDiscordMessageText(content.text);
+        if (!responseText.trim()) {
+          return [];
+        }
+        await reaction.message.channel.send(responseText);
         return [];
       };
       const events = type === "add" ? ["DISCORD_REACTION_RECEIVED" /* REACTION_RECEIVED */, EventType3.REACTION_RECEIVED] : ["DISCORD_REACTION_REMOVED" /* REACTION_REMOVED */];
@@ -11817,7 +14326,7 @@ class DiscordService extends Service {
   }
   async getSpiderState(channelId) {
     try {
-      const stateId = createUniqueUuid6(this.runtime, `discord-spider-state-${channelId}`);
+      const stateId = createUniqueUuid7(this.runtime, `discord-spider-state-${channelId}`);
       const stateMemory = await this.runtime.getMemoryById(stateId);
       const stateMemoryContent = stateMemory?.content;
       if (stateMemoryContent?.text) {
@@ -11842,8 +14351,8 @@ class DiscordService extends Service {
   }
   async saveSpiderState(state) {
     try {
-      const stateId = createUniqueUuid6(this.runtime, `discord-spider-state-${state.channelId}`);
-      const roomId = createUniqueUuid6(this.runtime, state.channelId);
+      const stateId = createUniqueUuid7(this.runtime, `discord-spider-state-${state.channelId}`);
+      const roomId = createUniqueUuid7(this.runtime, state.channelId);
       this.runtime.logger.debug(`[SpiderState] Saving channel=${state.channelId} stateId=${stateId}`);
       let existing = null;
       try {
@@ -11875,7 +14384,7 @@ class DiscordService extends Service {
           }
         }
       } catch {}
-      worldId = createUniqueUuid6(this.runtime, serverId ?? state.channelId);
+      worldId = createUniqueUuid7(this.runtime, serverId ?? state.channelId);
       const entityId = this.runtime.agentId;
       try {
         const entity = await this.runtime.getEntityById(entityId);
@@ -11899,7 +14408,7 @@ class DiscordService extends Service {
           id: worldId,
           name: serverId ? `Discord Server ${serverId}` : `Spider World ${state.channelId}`,
           agentId: this.runtime.agentId,
-          messageServerId: stringToUuid3(serverId ?? state.channelId)
+          messageServerId: stringToUuid4(serverId ?? state.channelId)
         });
         this.runtime.logger.debug(`[SpiderState] World ensured: ${worldId}`);
       } catch (worldError) {
@@ -11911,9 +14420,9 @@ class DiscordService extends Service {
           id: roomId,
           name: channelName,
           source: "discord",
-          type: ChannelType7.GROUP,
+          type: ChannelType8.GROUP,
           channelId: state.channelId,
-          messageServerId: stringToUuid3(serverId ?? state.channelId),
+          messageServerId: stringToUuid4(serverId ?? state.channelId),
           worldId
         });
         this.runtime.logger.debug(`[SpiderState] Room ensured: ${roomId}`);
@@ -11997,24 +14506,24 @@ class DiscordService extends Service {
     }
     const channel = fetchedChannel;
     const serverId = "guild" in channel && channel.guild ? channel.guild.id : ("guildId" in channel) && channel.guildId ? channel.guildId : channel.id;
-    const worldId = serverId ? createUniqueUuid6(this.runtime, serverId) : this.runtime.agentId;
+    const worldId = serverId ? createUniqueUuid7(this.runtime, serverId) : this.runtime.agentId;
     await this.runtime.ensureWorldExists({
       id: worldId,
       agentId: this.runtime.agentId,
-      messageServerId: stringToUuid3(serverId),
+      messageServerId: stringToUuid4(serverId),
       name: (() => {
         const channelGuild = "guild" in channel ? channel.guild : null;
         return channelGuild?.name || "Discord";
       })()
     });
     await this.runtime.ensureRoomExists({
-      id: createUniqueUuid6(this.runtime, channel.id),
+      id: createUniqueUuid7(this.runtime, channel.id),
       agentId: this.runtime.agentId,
       name: "name" in channel && channel.name || channel.id,
       source: "discord",
       type: await this.getChannelType(channel),
       channelId: channel.id,
-      messageServerId: stringToUuid3(serverId),
+      messageServerId: stringToUuid4(serverId),
       worldId
     });
     const spiderState = options.force ? null : await this.getSpiderState(channelId);
@@ -12371,13 +14880,13 @@ class DiscordService extends Service {
     if (!message.author || !message.channel) {
       return null;
     }
-    const entityId = createUniqueUuid6(this.runtime, message.author.id);
-    const roomId = createUniqueUuid6(this.runtime, message.channel.id);
+    const entityId = this.resolveDiscordEntityId(message.author.id);
+    const roomId = createUniqueUuid7(this.runtime, message.channel.id);
     const channel = message.channel;
     const channelType = await this.getChannelType(channel);
     const channelGuild = "guild" in channel ? channel.guild : null;
     const serverId = channelGuild?.id ? channelGuild.id : message.guild?.id ?? message.channel.id;
-    const worldId = serverId ? createUniqueUuid6(this.runtime, serverId) : this.runtime.agentId;
+    const worldId = serverId ? createUniqueUuid7(this.runtime, serverId) : this.runtime.agentId;
     let textContent;
     let attachments;
     const optionsProcessedContent = options?.processedContent;
@@ -12394,6 +14903,8 @@ class DiscordService extends Service {
     const metadata = {
       type: "custom",
       entityName: (message.member && "displayName" in message.member && typeof message.member.displayName === "string" ? message.member.displayName : undefined) ?? ("globalName" in message.author && typeof message.author.globalName === "string" ? message.author.globalName : undefined) ?? message.author.username,
+      entityUserName: message.author.username,
+      entityAvatarUrl: message.author.displayAvatarURL(),
       fromBot: message.author.bot,
       fromId: message.author.id,
       sourceId: entityId,
@@ -12407,7 +14918,7 @@ class DiscordService extends Service {
       ...options?.extraMetadata ? options.extraMetadata : {}
     };
     const memory = {
-      id: createUniqueUuid6(this.runtime, message.id),
+      id: createUniqueUuid7(this.runtime, message.id),
       entityId,
       agentId: this.runtime.agentId,
       roomId,
@@ -12417,7 +14928,7 @@ class DiscordService extends Service {
         source: "discord",
         channelType,
         url: message.url,
-        inReplyTo: message.reference?.messageId ? createUniqueUuid6(this.runtime, message.reference.messageId) : undefined,
+        inReplyTo: message.reference?.messageId ? createUniqueUuid7(this.runtime, message.reference.messageId) : undefined,
         ...options?.extraContent ? options.extraContent : {}
       },
       metadata,
@@ -12444,20 +14955,20 @@ class DiscordService extends Service {
       const channelType = await this.getChannelType(firstMessage.channel);
       const firstMessageChannelGuild = "guild" in firstMessage.channel ? firstMessage.channel.guild : null;
       const serverId = firstMessageChannelGuild?.id ? firstMessageChannelGuild.id : firstMessage.guild?.id ?? firstMessage.channel.id;
-      const worldId = serverId ? createUniqueUuid6(this.runtime, serverId) : this.runtime.agentId;
+      const worldId = serverId ? createUniqueUuid7(this.runtime, serverId) : this.runtime.agentId;
       const entities = Array.from(uniqueAuthors.entries()).map(([authorId, message]) => {
         const userName = message.author.username;
         const name = (message.member && "displayName" in message.member && typeof message.member.displayName === "string" ? message.member.displayName : undefined) ?? ("globalName" in message.author && typeof message.author.globalName === "string" ? message.author.globalName : undefined) ?? userName;
         return {
-          id: createUniqueUuid6(this.runtime, authorId),
+          id: this.resolveDiscordEntityId(authorId),
           names: [userName, name].filter((n) => typeof n === "string" && n.length > 0),
-          metadata: buildDiscordEntityMetadata(authorId, userName, name),
+          metadata: buildDiscordEntityMetadata(authorId, userName, name, undefined, message.author.displayAvatarURL()),
           agentId: this.runtime.agentId
         };
       });
       const rooms = [
         {
-          id: createUniqueUuid6(this.runtime, firstMessage.channel.id),
+          id: createUniqueUuid7(this.runtime, firstMessage.channel.id),
           channelId: firstMessage.channel.id,
           type: channelType,
           source: "discord"
@@ -12465,7 +14976,7 @@ class DiscordService extends Service {
       ];
       const world = {
         id: worldId,
-        messageServerId: stringToUuid3(serverId),
+        messageServerId: stringToUuid4(serverId),
         name: firstMessage.guild?.name ?? `DM-${firstMessage.channel.id}`,
         agentId: this.runtime.agentId,
         metadata: buildDiscordWorldMetadata(this.runtime, firstMessageChannelGuild?.ownerId ?? firstMessage.guild?.ownerId ?? undefined)
@@ -12487,37 +14998,56 @@ class DiscordService extends Service {
     this.runtime.logger.info("Stopping Discord service");
     this.timeouts.forEach(clearTimeout);
     this.timeouts = [];
+    this.messageDebouncer?.destroy();
+    this.channelDebouncer?.destroy();
+    this.messageDebouncer = undefined;
+    this.channelDebouncer = undefined;
+    this.userSelections.clear();
+    if (this.voiceManager) {
+      try {
+        this.voiceManager.stop();
+      } catch (error) {
+        this.runtime.logger.warn(`Discord voice cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
     if (this.client) {
-      await this.client.destroy();
-      this.client = null;
-      this.runtime.logger.info("Discord client destroyed");
+      try {
+        await this.client.destroy();
+        this.runtime.logger.info("Discord client destroyed");
+      } catch (error) {
+        this.runtime.logger.warn(`Discord client destroy failed: ${error instanceof Error ? error.message : String(error)}`);
+      } finally {
+        this.client = null;
+      }
     }
-    if (this.voiceManager) {}
+    this.clientReadyPromise = null;
+    this.messageManager = undefined;
+    this.voiceManager = undefined;
     this.runtime.logger.info("Discord service stopped");
   }
   async getChannelType(channel) {
     switch (channel.type) {
-      case DiscordChannelType5.DM:
-        return ChannelType7.DM;
-      case DiscordChannelType5.GroupDM:
-        return ChannelType7.DM;
-      case DiscordChannelType5.GuildText:
-      case DiscordChannelType5.GuildNews:
-      case DiscordChannelType5.PublicThread:
-      case DiscordChannelType5.PrivateThread:
-      case DiscordChannelType5.AnnouncementThread:
-      case DiscordChannelType5.GuildForum:
-        return ChannelType7.GROUP;
-      case DiscordChannelType5.GuildVoice:
-      case DiscordChannelType5.GuildStageVoice:
-        return ChannelType7.VOICE_GROUP;
+      case DiscordChannelType6.DM:
+        return ChannelType8.DM;
+      case DiscordChannelType6.GroupDM:
+        return ChannelType8.DM;
+      case DiscordChannelType6.GuildText:
+      case DiscordChannelType6.GuildNews:
+      case DiscordChannelType6.PublicThread:
+      case DiscordChannelType6.PrivateThread:
+      case DiscordChannelType6.AnnouncementThread:
+      case DiscordChannelType6.GuildForum:
+        return ChannelType8.GROUP;
+      case DiscordChannelType6.GuildVoice:
+      case DiscordChannelType6.GuildStageVoice:
+        return ChannelType8.VOICE_GROUP;
       default:
         this.runtime.logger.debug({
           src: "plugin:discord",
           agentId: this.runtime.agentId,
           channelType: channel.type
         }, "Unknown channel type, defaulting to GROUP");
-        return ChannelType7.GROUP;
+        return ChannelType8.GROUP;
     }
   }
 }
@@ -12532,12 +15062,12 @@ import {
   VoiceConnectionStatus as VoiceConnectionStatus2
 } from "@discordjs/voice";
 import {
-  logger as logger4,
+  logger as logger5,
   ModelType as ModelType21
 } from "@elizaos/core";
 import {
   AttachmentBuilder as AttachmentBuilder3,
-  ChannelType as ChannelType8,
+  ChannelType as ChannelType9,
   Events as Events2
 } from "discord.js";
 var TEST_IMAGE_URL = "https://github.com/elizaOS/awesome-eliza/blob/main/assets/eliza-logo.jpg?raw=true";
@@ -12582,9 +15112,9 @@ class DiscordTestSuite {
       }
       const discordClient = this.discordClient.client;
       if (discordClient?.isReady()) {
-        logger4.success("DiscordService is already ready.");
+        logger5.success("DiscordService is already ready.");
       } else {
-        logger4.info("Waiting for DiscordService to be ready...");
+        logger5.info("Waiting for DiscordService to be ready...");
         if (!discordClient) {
           throw new Error("Discord client instance is missing within the service.");
         }
@@ -12618,14 +15148,14 @@ class DiscordTestSuite {
         guild: channel.guild,
         deferReply: async () => {},
         editReply: async (message) => {
-          logger4.info(`JoinChannel Slash Command Response: ${message}`);
+          logger5.info(`JoinChannel Slash Command Response: ${message}`);
         }
       };
       if (!this.discordClient.voiceManager) {
         throw new Error("VoiceManager is not available on the Discord client.");
       }
       await this.discordClient.voiceManager.handleJoinChannelCommand(fakeJoinInteraction);
-      logger4.success("Join voice slash command test completed successfully.");
+      logger5.success("Join voice slash command test completed successfully.");
     } catch (error) {
       throw new Error(`Error in join voice slash commands test: ${error}`);
     }
@@ -12643,14 +15173,14 @@ class DiscordTestSuite {
       const fakeLeaveInteraction = {
         guildId: channel.guildId,
         reply: async (message) => {
-          logger4.info(`LeaveChannel Slash Command Response: ${message}`);
+          logger5.info(`LeaveChannel Slash Command Response: ${message}`);
         }
       };
       if (!this.discordClient.voiceManager) {
         throw new Error("VoiceManager is not available on the Discord client.");
       }
       await this.discordClient.voiceManager.handleLeaveChannelCommand(fakeLeaveInteraction);
-      logger4.success("Leave voice slash command test completed successfully.");
+      logger5.success("Leave voice slash command test completed successfully.");
     } catch (error) {
       throw new Error(`Error in leave voice slash commands test: ${error}`);
     }
@@ -12662,7 +15192,7 @@ class DiscordTestSuite {
     try {
       await this.waitForVoiceManagerReady(this.discordClient);
       const channel = await this.getTestChannel(runtime);
-      if (!channel || channel.type !== ChannelType8.GuildVoice) {
+      if (!channel || channel.type !== ChannelType9.GuildVoice) {
         throw new Error("Invalid voice channel.");
       }
       if (!this.discordClient.voiceManager) {
@@ -12680,7 +15210,7 @@ class DiscordTestSuite {
       }
       try {
         await entersState2(connection, VoiceConnectionStatus2.Ready, 1e4);
-        logger4.success(`Voice connection is ready in guild: ${guildId}`);
+        logger5.success(`Voice connection is ready in guild: ${guildId}`);
       } catch (error) {
         throw new Error(`Voice connection failed to become ready: ${error}`);
       }
@@ -12774,10 +15304,10 @@ class DiscordTestSuite {
     const audioResource = createAudioResource2(responseStream);
     audioPlayer.play(audioResource);
     connection.subscribe(audioPlayer);
-    logger4.success("TTS playback started successfully.");
+    logger5.success("TTS playback started successfully.");
     await new Promise((resolve, reject) => {
       audioPlayer.once(AudioPlayerStatus.Idle, () => {
-        logger4.info("TTS playback finished.");
+        logger5.info("TTS playback finished.");
         resolve();
       });
       audioPlayer.once("error", (error) => {
@@ -13718,7 +16248,7 @@ var ActivityFlags = import_v10.default.ActivityFlags;
 var ActivityPlatform = import_v10.default.ActivityPlatform;
 var ActivityType = import_v10.default.ActivityType;
 var AllowedMentionsTypes = import_v10.default.AllowedMentionsTypes;
-var ApplicationCommandOptionType = import_v10.default.ApplicationCommandOptionType;
+var ApplicationCommandOptionType2 = import_v10.default.ApplicationCommandOptionType;
 var ApplicationCommandPermissionType = import_v10.default.ApplicationCommandPermissionType;
 var ApplicationCommandType = import_v10.default.ApplicationCommandType;
 var ApplicationFlags = import_v10.default.ApplicationFlags;
@@ -13737,7 +16267,7 @@ var AutoModerationRuleTriggerType = import_v10.default.AutoModerationRuleTrigger
 var ButtonStyle = import_v10.default.ButtonStyle;
 var CDNRoutes = import_v10.default.CDNRoutes;
 var ChannelFlags = import_v10.default.ChannelFlags;
-var ChannelType9 = import_v10.default.ChannelType;
+var ChannelType10 = import_v10.default.ChannelType;
 var ComponentType = import_v10.default.ComponentType;
 var ConnectionService = import_v10.default.ConnectionService;
 var ConnectionVisibility = import_v10.default.ConnectionVisibility;
@@ -13839,7 +16369,7 @@ function buildDiscordCommandOptions(args) {
       return {
         name: arg.name,
         description: arg.description,
-        type: ApplicationCommandOptionType.Number,
+        type: ApplicationCommandOptionType2.Number,
         required
       };
     }
@@ -13847,7 +16377,7 @@ function buildDiscordCommandOptions(args) {
       return {
         name: arg.name,
         description: arg.description,
-        type: ApplicationCommandOptionType.Boolean,
+        type: ApplicationCommandOptionType2.Boolean,
         required
       };
     }
@@ -13858,7 +16388,7 @@ function buildDiscordCommandOptions(args) {
     return {
       name: arg.name,
       description: arg.description,
-      type: ApplicationCommandOptionType.String,
+      type: ApplicationCommandOptionType2.String,
       required,
       choices
     };
@@ -13876,7 +16406,7 @@ function buildDiscordSlashCommand(spec21) {
     {
       name: "input",
       description: "Command input",
-      type: ApplicationCommandOptionType.String,
+      type: ApplicationCommandOptionType2.String,
       required: false
     }
   ] : undefined);
@@ -14028,12 +16558,14 @@ var discordPlugin = {
     unpinMessage_default,
     serverInfo_default,
     editMessage_default,
-    deleteMessage_default
+    deleteMessage_default,
+    setup_credentials_default
   ],
   providers: [channelStateProvider, voiceStateProvider, guildInfoProvider],
   tests: [new DiscordTestSuite],
   init: async (_config, runtime) => {
     const token = runtime.getSetting("DISCORD_API_TOKEN");
+    const botTokens = runtime.getSetting("DISCORD_BOT_TOKENS");
     const applicationId = runtime.getSetting("DISCORD_APPLICATION_ID");
     const voiceChannelId = runtime.getSetting("DISCORD_VOICE_CHANNEL_ID");
     const channelIds = runtime.getSetting("CHANNEL_IDS");
@@ -14057,6 +16589,11 @@ var discordPlugin = {
           name: "DISCORD_APPLICATION_ID",
           value: applicationId
         },
+        {
+          name: "DISCORD_BOT_TOKENS",
+          value: botTokens,
+          sensitive: true
+        },
         {
           name: "DISCORD_VOICE_CHANNEL_ID",
           value: voiceChannelId
@@ -14087,9 +16624,9 @@ var discordPlugin = {
       ],
       runtime
     });
-    if (!token || token.trim() === "") {
-      logger5.warn("Discord API Token not provided - Discord plugin is loaded but will not be functional");
-      logger5.warn("To enable Discord functionality, please provide DISCORD_API_TOKEN in your .eliza/.env file");
+    if ((!token || token.trim() === "") && (!botTokens || botTokens.trim() === "")) {
+      logger6.warn("Discord bot token not provided - Discord plugin is loaded but will not be functional");
+      logger6.warn("To enable Discord functionality, provide DISCORD_API_TOKEN or DISCORD_BOT_TOKENS in your .env file");
     }
   }
 };
@@ -14171,5 +16708,5 @@ export {
   COMMAND_ARG_CUSTOM_ID_KEY
 };
 
-//# debugId=B20F70AAC326598264756E2164756E21
+//# debugId=4CB6B945E40708D364756E2164756E21
 //# sourceMappingURL=index.js.map