@elizaos/plugin-slack 2.0.0-alpha

package/dist/index.js

@@ -0,0 +1,3211 @@
+// src/index.ts
+import { logger } from "@elizaos/core";
+
+// src/actions/deleteMessage.ts
+import {
+  composePromptFromState,
+  ModelType,
+  parseJSONObjectFromText
+} from "@elizaos/core";
+
+// src/types.ts
+var SlackEventTypes;
+((SlackEventTypes2) => {
+  SlackEventTypes2["MESSAGE_RECEIVED"] = "SLACK_MESSAGE_RECEIVED";
+  SlackEventTypes2["MESSAGE_SENT"] = "SLACK_MESSAGE_SENT";
+  SlackEventTypes2["REACTION_ADDED"] = "SLACK_REACTION_ADDED";
+  SlackEventTypes2["REACTION_REMOVED"] = "SLACK_REACTION_REMOVED";
+  SlackEventTypes2["CHANNEL_JOINED"] = "SLACK_CHANNEL_JOINED";
+  SlackEventTypes2["CHANNEL_LEFT"] = "SLACK_CHANNEL_LEFT";
+  SlackEventTypes2["MEMBER_JOINED_CHANNEL"] = "SLACK_MEMBER_JOINED_CHANNEL";
+  SlackEventTypes2["MEMBER_LEFT_CHANNEL"] = "SLACK_MEMBER_LEFT_CHANNEL";
+  SlackEventTypes2["APP_MENTION"] = "SLACK_APP_MENTION";
+  SlackEventTypes2["SLASH_COMMAND"] = "SLACK_SLASH_COMMAND";
+  SlackEventTypes2["FILE_SHARED"] = "SLACK_FILE_SHARED";
+  SlackEventTypes2["THREAD_REPLY"] = "SLACK_THREAD_REPLY";
+})(SlackEventTypes ||= {});
+var SLACK_SERVICE_NAME = "slack";
+var ServiceType = {
+  SLACK: "slack"
+};
+
+class SlackPluginError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SlackPluginError";
+  }
+}
+
+class SlackServiceNotInitializedError extends SlackPluginError {
+  constructor() {
+    super("Slack service is not initialized", "SERVICE_NOT_INITIALIZED");
+    this.name = "SlackServiceNotInitializedError";
+  }
+}
+
+class SlackClientNotAvailableError extends SlackPluginError {
+  constructor() {
+    super("Slack client is not available", "CLIENT_NOT_AVAILABLE");
+    this.name = "SlackClientNotAvailableError";
+  }
+}
+
+class SlackConfigurationError extends SlackPluginError {
+  constructor(missingConfig) {
+    super(`Missing required configuration: ${missingConfig}`, "MISSING_CONFIG");
+    this.name = "SlackConfigurationError";
+  }
+}
+
+class SlackApiError extends SlackPluginError {
+  apiErrorCode;
+  constructor(message, apiErrorCode) {
+    super(message, "API_ERROR");
+    this.apiErrorCode = apiErrorCode;
+    this.name = "SlackApiError";
+  }
+}
+function isValidChannelId(id) {
+  return /^[CGD][A-Z0-9]{8,}$/i.test(id);
+}
+function isValidUserId(id) {
+  return /^[UW][A-Z0-9]{8,}$/i.test(id);
+}
+function isValidTeamId(id) {
+  return /^T[A-Z0-9]{8,}$/i.test(id);
+}
+function isValidMessageTs(ts) {
+  return /^\d+\.\d{6}$/.test(ts);
+}
+function parseSlackMessageLink(link) {
+  const match = link.match(/\/archives\/([CGD][A-Z0-9]+)\/p(\d+)/i);
+  if (!match)
+    return null;
+  const channelId = match[1];
+  const ts = match[2];
+  const messageTs = `${ts.slice(0, 10)}.${ts.slice(10)}`;
+  return { channelId, messageTs };
+}
+function formatMessageTsForLink(ts) {
+  return `p${ts.replace(".", "")}`;
+}
+function getSlackUserDisplayName(user) {
+  return user.profile.displayName || user.profile.realName || user.name;
+}
+function getSlackChannelType(channel) {
+  if (channel.isIm)
+    return "im";
+  if (channel.isMpim)
+    return "mpim";
+  if (channel.isGroup || channel.isPrivate)
+    return "group";
+  return "channel";
+}
+var MAX_SLACK_MESSAGE_LENGTH = 4000;
+var MAX_SLACK_BLOCKS = 50;
+var MAX_SLACK_FILE_SIZE = 1024 * 1024 * 1024;
+
+// src/actions/deleteMessage.ts
+var deleteMessageTemplate = `You are helping to extract delete message parameters for Slack.
+
+The user wants to delete a Slack message.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. messageTs: The message timestamp to delete (format: 1234567890.123456)
+2. channelId: The channel ID (optional, defaults to current channel)
+
+Respond with a JSON object like:
+{
+  "messageTs": "1234567890.123456",
+  "channelId": null
+}
+
+Only respond with the JSON object, no other text.`;
+var deleteMessage = {
+  name: "SLACK_DELETE_MESSAGE",
+  similes: ["REMOVE_SLACK_MESSAGE", "DELETE_MESSAGE", "SLACK_REMOVE"],
+  description: "Delete a Slack message",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const prompt = composePromptFromState({
+      state,
+      template: deleteMessageTemplate
+    });
+    let deleteInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText(response2);
+      if (parsedResponse?.messageTs) {
+        deleteInfo = {
+          messageTs: String(parsedResponse.messageTs),
+          channelId: parsedResponse.channelId ? String(parsedResponse.channelId) : null
+        };
+        break;
+      }
+    }
+    if (!deleteInfo || !deleteInfo.messageTs) {
+      runtime.logger.debug({ src: "plugin:slack:action:delete-message" }, "[SLACK_DELETE_MESSAGE] Could not extract delete info");
+      await callback?.({
+        text: "I couldn't understand which message to delete. Please specify the message timestamp.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not extract delete parameters" };
+    }
+    if (!isValidMessageTs(deleteInfo.messageTs)) {
+      await callback?.({
+        text: "The message timestamp format is invalid. Please provide a valid Slack message timestamp.",
+        source: "slack"
+      });
+      return { success: false, error: "Invalid message timestamp" };
+    }
+    const stateData = state?.data;
+    const room = stateData?.room || await runtime.getRoom(message.roomId);
+    const channelId = deleteInfo.channelId || room?.channelId;
+    if (!channelId) {
+      await callback?.({
+        text: "I couldn't determine the channel for the message deletion.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not determine channel" };
+    }
+    await slackService.deleteMessage(channelId, deleteInfo.messageTs);
+    const response = {
+      text: "Message deleted successfully.",
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:delete-message",
+      messageTs: deleteInfo.messageTs,
+      channelId
+    }, "[SLACK_DELETE_MESSAGE] Message deleted");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        messageTs: deleteInfo.messageTs,
+        channelId
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Delete that last message I sent"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll delete that message for you.",
+          actions: ["SLACK_DELETE_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+var deleteMessage_default = deleteMessage;
+
+// src/actions/editMessage.ts
+import {
+  composePromptFromState as composePromptFromState2,
+  ModelType as ModelType2,
+  parseJSONObjectFromText as parseJSONObjectFromText2
+} from "@elizaos/core";
+var editMessageTemplate = `You are helping to extract edit message parameters for Slack.
+
+The user wants to edit an existing Slack message.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. messageTs: The message timestamp to edit (format: 1234567890.123456)
+2. newText: The new text content for the message
+3. channelId: The channel ID (optional, defaults to current channel)
+
+Respond with a JSON object like:
+{
+  "messageTs": "1234567890.123456",
+  "newText": "The updated message content",
+  "channelId": null
+}
+
+Only respond with the JSON object, no other text.`;
+var editMessage = {
+  name: "SLACK_EDIT_MESSAGE",
+  similes: [
+    "UPDATE_SLACK_MESSAGE",
+    "MODIFY_MESSAGE",
+    "CHANGE_MESSAGE",
+    "SLACK_UPDATE"
+  ],
+  description: "Edit an existing Slack message",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const prompt = composePromptFromState2({
+      state,
+      template: editMessageTemplate
+    });
+    let editInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType2.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText2(response2);
+      if (parsedResponse?.messageTs && parsedResponse?.newText) {
+        editInfo = {
+          messageTs: String(parsedResponse.messageTs),
+          newText: String(parsedResponse.newText),
+          channelId: parsedResponse.channelId ? String(parsedResponse.channelId) : null
+        };
+        break;
+      }
+    }
+    if (!editInfo || !editInfo.messageTs || !editInfo.newText) {
+      runtime.logger.debug({ src: "plugin:slack:action:edit-message" }, "[SLACK_EDIT_MESSAGE] Could not extract edit info");
+      await callback?.({
+        text: "I couldn't understand the edit request. Please specify the message timestamp and new content.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not extract edit parameters" };
+    }
+    if (!isValidMessageTs(editInfo.messageTs)) {
+      await callback?.({
+        text: "The message timestamp format is invalid. Please provide a valid Slack message timestamp.",
+        source: "slack"
+      });
+      return { success: false, error: "Invalid message timestamp" };
+    }
+    const stateData = state?.data;
+    const room = stateData?.room || await runtime.getRoom(message.roomId);
+    const channelId = editInfo.channelId || room?.channelId;
+    if (!channelId) {
+      await callback?.({
+        text: "I couldn't determine the channel for the message edit.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not determine channel" };
+    }
+    await slackService.editMessage(channelId, editInfo.messageTs, editInfo.newText);
+    const response = {
+      text: "Message edited successfully.",
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:edit-message",
+      messageTs: editInfo.messageTs,
+      channelId
+    }, "[SLACK_EDIT_MESSAGE] Message edited");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        messageTs: editInfo.messageTs,
+        channelId,
+        newText: editInfo.newText
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Edit that message to say 'Meeting at 3pm' instead"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll update that message for you.",
+          actions: ["SLACK_EDIT_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+var editMessage_default = editMessage;
+
+// src/actions/emojiList.ts
+var emojiList = {
+  name: "SLACK_EMOJI_LIST",
+  similes: [
+    "LIST_SLACK_EMOJI",
+    "SHOW_EMOJI",
+    "GET_CUSTOM_EMOJI",
+    "CUSTOM_EMOJI",
+    "WORKSPACE_EMOJI"
+  ],
+  description: "List custom emoji available in the Slack workspace",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const emoji = await slackService.getEmojiList();
+    const emojiNames = Object.keys(emoji).sort();
+    if (emojiNames.length === 0) {
+      const response2 = {
+        text: "There are no custom emoji in this workspace.",
+        source: message.content.source
+      };
+      await callback?.(response2);
+      return {
+        success: true,
+        data: {
+          emojiCount: 0,
+          emoji: {}
+        }
+      };
+    }
+    const _chunkSize = 20;
+    const displayCount = Math.min(emojiNames.length, 100);
+    const displayEmoji = emojiNames.slice(0, displayCount);
+    const aliases = [];
+    const custom = [];
+    for (const name of displayEmoji) {
+      const value = emoji[name];
+      if (value.startsWith("alias:")) {
+        aliases.push(name);
+      } else {
+        custom.push(name);
+      }
+    }
+    const emojiDisplay = custom.map((name) => `:${name}:`).join(" ");
+    const aliasDisplay = aliases.length > 0 ? `
+
+Aliases: ${aliases.map((name) => `:${name}:`).join(" ")}` : "";
+    const truncationNote = emojiNames.length > displayCount ? `
+
+(Showing ${displayCount} of ${emojiNames.length} total custom emoji)` : "";
+    const response = {
+      text: `Custom emoji in this workspace (${emojiNames.length} total):
+
+${emojiDisplay}${aliasDisplay}${truncationNote}`,
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:emoji-list",
+      emojiCount: emojiNames.length
+    }, "[SLACK_EMOJI_LIST] Emoji listed");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        emojiCount: emojiNames.length,
+        emoji: Object.fromEntries(displayEmoji.map((name) => [name, emoji[name]]))
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Show me the custom emoji in this workspace"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll list the custom emoji available.",
+          actions: ["SLACK_EMOJI_LIST"]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "What emoji can I use here?"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Let me show you the custom emoji in this workspace.",
+          actions: ["SLACK_EMOJI_LIST"]
+        }
+      }
+    ]
+  ]
+};
+var emojiList_default = emojiList;
+
+// src/actions/getUserInfo.ts
+import {
+  composePromptFromState as composePromptFromState3,
+  ModelType as ModelType3,
+  parseJSONObjectFromText as parseJSONObjectFromText3
+} from "@elizaos/core";
+var getUserInfoTemplate = `You are helping to extract user info parameters for Slack.
+
+The user wants to get information about a Slack user.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. userId: The Slack user ID to look up (format: U followed by alphanumeric characters, e.g., U0123456789)
+
+Respond with a JSON object like:
+{
+  "userId": "U0123456789"
+}
+
+Only respond with the JSON object, no other text.`;
+var getUserInfo = {
+  name: "SLACK_GET_USER_INFO",
+  similes: [
+    "GET_SLACK_USER",
+    "USER_INFO",
+    "SLACK_USER",
+    "MEMBER_INFO",
+    "WHO_IS"
+  ],
+  description: "Get information about a Slack user",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const prompt = composePromptFromState3({
+      state,
+      template: getUserInfoTemplate
+    });
+    let userInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType3.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText3(response2);
+      if (parsedResponse?.userId) {
+        userInfo = {
+          userId: String(parsedResponse.userId)
+        };
+        break;
+      }
+    }
+    if (!userInfo || !userInfo.userId) {
+      runtime.logger.debug({ src: "plugin:slack:action:get-user-info" }, "[SLACK_GET_USER_INFO] Could not extract user info");
+      await callback?.({
+        text: "I couldn't determine which user to look up. Please specify a user ID.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not extract user ID" };
+    }
+    if (!isValidUserId(userInfo.userId)) {
+      await callback?.({
+        text: "The user ID format is invalid. Slack user IDs start with U followed by alphanumeric characters.",
+        source: "slack"
+      });
+      return { success: false, error: "Invalid user ID format" };
+    }
+    const user = await slackService.getUser(userInfo.userId);
+    if (!user) {
+      await callback?.({
+        text: `I couldn't find a user with ID ${userInfo.userId}.`,
+        source: "slack"
+      });
+      return { success: false, error: "User not found" };
+    }
+    const displayName = getSlackUserDisplayName(user);
+    const roles = [];
+    if (user.isAdmin)
+      roles.push("Admin");
+    if (user.isOwner)
+      roles.push("Owner");
+    if (user.isPrimaryOwner)
+      roles.push("Primary Owner");
+    if (user.isBot)
+      roles.push("Bot");
+    if (user.isRestricted)
+      roles.push("Guest");
+    const userDetails = [
+      `**Name:** ${displayName}`,
+      user.profile.realName && user.profile.realName !== displayName ? `**Real Name:** ${user.profile.realName}` : null,
+      `**Username:** @${user.name}`,
+      user.profile.title ? `**Title:** ${user.profile.title}` : null,
+      user.profile.email ? `**Email:** ${user.profile.email}` : null,
+      user.tz ? `**Timezone:** ${user.tzLabel || user.tz}` : null,
+      user.profile.statusText ? `**Status:** ${user.profile.statusEmoji || ""} ${user.profile.statusText}` : null,
+      roles.length > 0 ? `**Roles:** ${roles.join(", ")}` : null
+    ].filter(Boolean).join(`
+`);
+    const response = {
+      text: `User information for ${displayName}:
+
+${userDetails}`,
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:get-user-info",
+      userId: userInfo.userId,
+      displayName
+    }, "[SLACK_GET_USER_INFO] User info retrieved");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        userId: user.id,
+        name: user.name,
+        displayName,
+        realName: user.profile.realName,
+        title: user.profile.title,
+        email: user.profile.email,
+        timezone: user.tz,
+        isAdmin: user.isAdmin,
+        isOwner: user.isOwner,
+        isBot: user.isBot,
+        statusText: user.profile.statusText,
+        statusEmoji: user.profile.statusEmoji,
+        avatar: user.profile.image192 || user.profile.image72
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Who is U0123456789?"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Let me look up that user for you.",
+          actions: ["SLACK_GET_USER_INFO"]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Get information about the user who sent the last message"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll fetch their profile information.",
+          actions: ["SLACK_GET_USER_INFO"]
+        }
+      }
+    ]
+  ]
+};
+var getUserInfo_default = getUserInfo;
+
+// src/actions/listChannels.ts
+var listChannels = {
+  name: "SLACK_LIST_CHANNELS",
+  similes: [
+    "LIST_SLACK_CHANNELS",
+    "SHOW_CHANNELS",
+    "GET_CHANNELS",
+    "CHANNELS_LIST"
+  ],
+  description: "List available Slack channels in the workspace",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const channels = await slackService.listChannels({
+      types: "public_channel,private_channel",
+      limit: 100
+    });
+    const sortedChannels = channels.filter((ch) => !ch.isArchived).sort((a, b) => a.name.localeCompare(b.name));
+    const channelList = sortedChannels.map((ch) => {
+      const memberCount = ch.numMembers !== undefined ? ` (${ch.numMembers} members)` : "";
+      const privateIndicator = ch.isPrivate ? " \uD83D\uDD12" : "";
+      const topic = ch.topic?.value ? ` - ${ch.topic.value.slice(0, 50)}${ch.topic.value.length > 50 ? "..." : ""}` : "";
+      return `• #${ch.name}${privateIndicator}${memberCount}${topic}`;
+    });
+    const response = {
+      text: `Found ${sortedChannels.length} channels:
+
+${channelList.join(`
+`)}`,
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:list-channels",
+      channelCount: sortedChannels.length
+    }, "[SLACK_LIST_CHANNELS] Channels listed");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        channelCount: sortedChannels.length,
+        channels: sortedChannels.map((ch) => ({
+          id: ch.id,
+          name: ch.name,
+          isPrivate: ch.isPrivate,
+          numMembers: ch.numMembers,
+          topic: ch.topic?.value,
+          purpose: ch.purpose?.value
+        }))
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Show me all the channels in this workspace"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll list all the available channels.",
+          actions: ["SLACK_LIST_CHANNELS"]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "What channels can I join?"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Let me show you the available channels.",
+          actions: ["SLACK_LIST_CHANNELS"]
+        }
+      }
+    ]
+  ]
+};
+var listChannels_default = listChannels;
+
+// src/actions/listPins.ts
+import {
+  composePromptFromState as composePromptFromState4,
+  ModelType as ModelType4,
+  parseJSONObjectFromText as parseJSONObjectFromText4
+} from "@elizaos/core";
+var listPinsTemplate = `You are helping to extract list pins parameters for Slack.
+
+The user wants to see pinned messages in a Slack channel.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. channelRef: The channel to list pins from (default: "current" for the current channel, or a channel name/ID)
+
+Respond with a JSON object like:
+{
+  "channelRef": "current"
+}
+
+Only respond with the JSON object, no other text.`;
+var listPins = {
+  name: "SLACK_LIST_PINS",
+  similes: [
+    "LIST_SLACK_PINS",
+    "SHOW_PINS",
+    "GET_PINNED_MESSAGES",
+    "PINNED_MESSAGES"
+  ],
+  description: "List pinned messages in a Slack channel",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const prompt = composePromptFromState4({
+      state,
+      template: listPinsTemplate
+    });
+    let listInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType4.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText4(response2);
+      if (parsedResponse) {
+        listInfo = {
+          channelRef: parsedResponse.channelRef ? String(parsedResponse.channelRef) : "current"
+        };
+        break;
+      }
+    }
+    if (!listInfo) {
+      listInfo = { channelRef: "current" };
+    }
+    const stateData = state?.data;
+    const room = stateData?.room || await runtime.getRoom(message.roomId);
+    if (!room || !room.channelId) {
+      await callback?.({
+        text: "I couldn't determine the current channel.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not determine channel" };
+    }
+    let targetChannelId = room.channelId;
+    if (listInfo.channelRef && listInfo.channelRef !== "current") {
+      const channels = await slackService.listChannels();
+      const targetChannel = channels.find((ch) => {
+        const channelName2 = ch.name?.toLowerCase() || "";
+        const searchTerm = listInfo?.channelRef?.toLowerCase() || "";
+        return channelName2 === searchTerm || channelName2 === searchTerm.replace(/^#/, "") || ch.id === listInfo?.channelRef;
+      });
+      if (targetChannel) {
+        targetChannelId = targetChannel.id;
+      }
+    }
+    const pins = await slackService.listPins(targetChannelId);
+    if (pins.length === 0) {
+      const channelInfo2 = await slackService.getChannel(targetChannelId);
+      const channelName2 = channelInfo2?.name || targetChannelId;
+      const response2 = {
+        text: `There are no pinned messages in #${channelName2}.`,
+        source: message.content.source
+      };
+      await callback?.(response2);
+      return {
+        success: true,
+        data: {
+          channelId: targetChannelId,
+          pinCount: 0,
+          pins: []
+        }
+      };
+    }
+    const formattedPins = pins.map((pin, index) => {
+      const timestamp = new Date(parseFloat(pin.ts) * 1000).toISOString();
+      const user = pin.user || "unknown";
+      const text = pin.text?.slice(0, 100) || "[no text]";
+      const truncated = pin.text && pin.text.length > 100 ? "..." : "";
+      return `${index + 1}. [${timestamp}] ${user}: ${text}${truncated}`;
+    });
+    const channelInfo = await slackService.getChannel(targetChannelId);
+    const channelName = channelInfo?.name || targetChannelId;
+    const response = {
+      text: `Pinned messages in #${channelName} (${pins.length}):
+
+${formattedPins.join(`
+
+`)}`,
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:list-pins",
+      channelId: targetChannelId,
+      pinCount: pins.length
+    }, "[SLACK_LIST_PINS] Pins listed");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        channelId: targetChannelId,
+        channelName,
+        pinCount: pins.length,
+        pins: pins.map((p) => ({
+          ts: p.ts,
+          user: p.user,
+          text: p.text
+        }))
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Show me the pinned messages in this channel"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll list the pinned messages.",
+          actions: ["SLACK_LIST_PINS"]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "What's pinned in #announcements?"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Let me check the pins in #announcements.",
+          actions: ["SLACK_LIST_PINS"]
+        }
+      }
+    ]
+  ]
+};
+var listPins_default = listPins;
+
+// src/actions/pinMessage.ts
+import {
+  composePromptFromState as composePromptFromState5,
+  ModelType as ModelType5,
+  parseJSONObjectFromText as parseJSONObjectFromText5
+} from "@elizaos/core";
+var pinMessageTemplate = `You are helping to extract pin message parameters for Slack.
+
+The user wants to pin a message in a Slack channel.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. messageTs: The message timestamp to pin (format: 1234567890.123456)
+2. channelId: The channel ID (optional, defaults to current channel)
+
+Respond with a JSON object like:
+{
+  "messageTs": "1234567890.123456",
+  "channelId": null
+}
+
+Only respond with the JSON object, no other text.`;
+var pinMessage = {
+  name: "SLACK_PIN_MESSAGE",
+  similes: ["PIN_SLACK_MESSAGE", "PIN_MESSAGE", "SLACK_PIN", "SAVE_MESSAGE"],
+  description: "Pin a message in a Slack channel",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const prompt = composePromptFromState5({
+      state,
+      template: pinMessageTemplate
+    });
+    let pinInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType5.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText5(response2);
+      if (parsedResponse?.messageTs) {
+        pinInfo = {
+          messageTs: String(parsedResponse.messageTs),
+          channelId: parsedResponse.channelId ? String(parsedResponse.channelId) : null
+        };
+        break;
+      }
+    }
+    if (!pinInfo || !pinInfo.messageTs) {
+      runtime.logger.debug({ src: "plugin:slack:action:pin-message" }, "[SLACK_PIN_MESSAGE] Could not extract pin info");
+      await callback?.({
+        text: "I couldn't understand which message to pin. Please specify the message timestamp.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not extract pin parameters" };
+    }
+    if (!isValidMessageTs(pinInfo.messageTs)) {
+      await callback?.({
+        text: "The message timestamp format is invalid. Please provide a valid Slack message timestamp.",
+        source: "slack"
+      });
+      return { success: false, error: "Invalid message timestamp" };
+    }
+    const stateData = state?.data;
+    const room = stateData?.room || await runtime.getRoom(message.roomId);
+    const channelId = pinInfo.channelId || room?.channelId;
+    if (!channelId) {
+      await callback?.({
+        text: "I couldn't determine the channel for pinning the message.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not determine channel" };
+    }
+    await slackService.pinMessage(channelId, pinInfo.messageTs);
+    const response = {
+      text: "Message pinned successfully.",
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:pin-message",
+      messageTs: pinInfo.messageTs,
+      channelId
+    }, "[SLACK_PIN_MESSAGE] Message pinned");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        messageTs: pinInfo.messageTs,
+        channelId
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Pin that important announcement"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll pin that message to the channel.",
+          actions: ["SLACK_PIN_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+var pinMessage_default = pinMessage;
+
+// src/actions/reactToMessage.ts
+import {
+  composePromptFromState as composePromptFromState6,
+  ModelType as ModelType6,
+  parseJSONObjectFromText as parseJSONObjectFromText6
+} from "@elizaos/core";
+var reactToMessageTemplate = `You are helping to extract reaction parameters for Slack.
+
+The user wants to add a reaction (emoji) to a Slack message.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. emoji: The emoji name to react with (without colons, e.g., "thumbsup" not ":thumbsup:")
+2. messageTs: The message timestamp to react to (format: 1234567890.123456)
+3. channelId: The channel ID (optional, defaults to current channel)
+4. remove: Whether to remove the reaction instead of adding it (default: false)
+
+Respond with a JSON object like:
+{
+  "emoji": "thumbsup",
+  "messageTs": "1234567890.123456",
+  "channelId": null,
+  "remove": false
+}
+
+Only respond with the JSON object, no other text.`;
+var reactToMessage = {
+  name: "SLACK_REACT_TO_MESSAGE",
+  similes: [
+    "ADD_SLACK_REACTION",
+    "REACT_SLACK",
+    "SLACK_EMOJI",
+    "ADD_EMOJI",
+    "REMOVE_REACTION"
+  ],
+  description: "Add or remove an emoji reaction to a Slack message",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const prompt = composePromptFromState6({
+      state,
+      template: reactToMessageTemplate
+    });
+    let reactionInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType6.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText6(response2);
+      if (parsedResponse?.emoji && parsedResponse?.messageTs) {
+        reactionInfo = {
+          emoji: String(parsedResponse.emoji),
+          messageTs: String(parsedResponse.messageTs),
+          channelId: parsedResponse.channelId ? String(parsedResponse.channelId) : null,
+          remove: Boolean(parsedResponse.remove)
+        };
+        break;
+      }
+    }
+    if (!reactionInfo || !reactionInfo.emoji || !reactionInfo.messageTs) {
+      runtime.logger.debug({ src: "plugin:slack:action:react-to-message" }, "[SLACK_REACT_TO_MESSAGE] Could not extract reaction info");
+      await callback?.({
+        text: "I couldn't understand the reaction request. Please specify the emoji and message to react to.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not extract reaction parameters" };
+    }
+    if (!isValidMessageTs(reactionInfo.messageTs)) {
+      await callback?.({
+        text: "The message timestamp format is invalid. Please provide a valid Slack message timestamp.",
+        source: "slack"
+      });
+      return { success: false, error: "Invalid message timestamp" };
+    }
+    const stateData = state?.data;
+    const room = stateData?.room || await runtime.getRoom(message.roomId);
+    const channelId = reactionInfo.channelId || room?.channelId;
+    if (!channelId) {
+      await callback?.({
+        text: "I couldn't determine the channel for the reaction.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not determine channel" };
+    }
+    if (reactionInfo.remove) {
+      await slackService.removeReaction(channelId, reactionInfo.messageTs, reactionInfo.emoji);
+    } else {
+      await slackService.sendReaction(channelId, reactionInfo.messageTs, reactionInfo.emoji);
+    }
+    const actionWord = reactionInfo.remove ? "removed" : "added";
+    const response = {
+      text: `Reaction :${reactionInfo.emoji}: ${actionWord} successfully.`,
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:react-to-message",
+      emoji: reactionInfo.emoji,
+      messageTs: reactionInfo.messageTs,
+      channelId,
+      remove: reactionInfo.remove
+    }, `[SLACK_REACT_TO_MESSAGE] Reaction ${actionWord}`);
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        emoji: reactionInfo.emoji,
+        messageTs: reactionInfo.messageTs,
+        channelId,
+        action: reactionInfo.remove ? "removed" : "added"
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "React to the last message with a thumbs up"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll add a thumbs up reaction to that message.",
+          actions: ["SLACK_REACT_TO_MESSAGE"]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Add a :tada: emoji to that announcement"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Adding the tada emoji reaction now.",
+          actions: ["SLACK_REACT_TO_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+var reactToMessage_default = reactToMessage;
+
+// src/actions/readChannel.ts
+import {
+  composePromptFromState as composePromptFromState7,
+  ModelType as ModelType7,
+  parseJSONObjectFromText as parseJSONObjectFromText7
+} from "@elizaos/core";
+var readChannelTemplate = `You are helping to extract read channel parameters for Slack.
+
+The user wants to read message history from a Slack channel.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. channelRef: The channel to read from (default: "current" for the current channel, or a channel name/ID)
+2. limit: Number of messages to retrieve (default: 10, max: 100)
+3. before: Optional message timestamp to fetch messages before
+4. after: Optional message timestamp to fetch messages after
+
+Respond with a JSON object like:
+{
+  "channelRef": "current",
+  "limit": 10,
+  "before": null,
+  "after": null
+}
+
+Only respond with the JSON object, no other text.`;
+var readChannel = {
+  name: "SLACK_READ_CHANNEL",
+  similes: [
+    "READ_SLACK_MESSAGES",
+    "GET_CHANNEL_HISTORY",
+    "SLACK_HISTORY",
+    "FETCH_MESSAGES",
+    "LIST_MESSAGES"
+  ],
+  description: "Read message history from a Slack channel",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const prompt = composePromptFromState7({
+      state,
+      template: readChannelTemplate
+    });
+    let readInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType7.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText7(response2);
+      if (parsedResponse) {
+        readInfo = {
+          channelRef: parsedResponse.channelRef ? String(parsedResponse.channelRef) : "current",
+          limit: parsedResponse.limit ? Math.min(Number(parsedResponse.limit), 100) : 10,
+          before: parsedResponse.before ? String(parsedResponse.before) : undefined,
+          after: parsedResponse.after ? String(parsedResponse.after) : undefined
+        };
+        break;
+      }
+    }
+    if (!readInfo) {
+      readInfo = { channelRef: "current", limit: 10 };
+    }
+    const stateData = state?.data;
+    const room = stateData?.room || await runtime.getRoom(message.roomId);
+    if (!room || !room.channelId) {
+      await callback?.({
+        text: "I couldn't determine the current channel.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not determine channel" };
+    }
+    let targetChannelId = room.channelId;
+    if (readInfo.channelRef && readInfo.channelRef !== "current") {
+      const channels = await slackService.listChannels();
+      const targetChannel = channels.find((ch) => {
+        const channelName2 = ch.name?.toLowerCase() || "";
+        const searchTerm = readInfo?.channelRef?.toLowerCase() || "";
+        return channelName2 === searchTerm || channelName2 === searchTerm.replace(/^#/, "") || ch.id === readInfo?.channelRef;
+      });
+      if (targetChannel) {
+        targetChannelId = targetChannel.id;
+      }
+    }
+    const messages = await slackService.readHistory(targetChannelId, {
+      limit: readInfo.limit,
+      before: readInfo.before || undefined,
+      after: readInfo.after || undefined
+    });
+    const formattedMessages = messages.map((msg) => {
+      const timestamp = new Date(parseFloat(msg.ts) * 1000).toISOString();
+      const user = msg.user || "unknown";
+      const text = msg.text || "[no text]";
+      return `[${timestamp}] ${user}: ${text}`;
+    });
+    const channelInfo = await slackService.getChannel(targetChannelId);
+    const channelName = channelInfo?.name || targetChannelId;
+    const response = {
+      text: `Here are the last ${messages.length} messages from #${channelName}:
+
+${formattedMessages.join(`
+`)}`,
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:read-channel",
+      channelId: targetChannelId,
+      messageCount: messages.length
+    }, "[SLACK_READ_CHANNEL] Channel history retrieved");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        channelId: targetChannelId,
+        channelName,
+        messageCount: messages.length,
+        messages: messages.map((m) => ({
+          ts: m.ts,
+          user: m.user,
+          text: m.text,
+          threadTs: m.threadTs
+        }))
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Show me the last 5 messages in this channel"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll fetch the recent messages for you.",
+          actions: ["SLACK_READ_CHANNEL"]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "What's been happening in #announcements?"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Let me check the recent messages in #announcements.",
+          actions: ["SLACK_READ_CHANNEL"]
+        }
+      }
+    ]
+  ]
+};
+var readChannel_default = readChannel;
+
+// src/actions/sendMessage.ts
+import {
+  composePromptFromState as composePromptFromState8,
+  ModelType as ModelType8,
+  parseJSONObjectFromText as parseJSONObjectFromText8
+} from "@elizaos/core";
+var sendMessageTemplate = `You are helping to extract send message parameters for Slack.
+
+The user wants to send a message to a Slack channel.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. text: The message text to send
+2. channelRef: The channel to send to (default: "current" for the current channel, or a channel name/ID)
+3. threadTs: Optional thread timestamp to reply in a thread (default: null)
+
+Respond with a JSON object like:
+{
+  "text": "The message to send",
+  "channelRef": "current",
+  "threadTs": null
+}
+
+Only respond with the JSON object, no other text.`;
+var sendMessage = {
+  name: "SLACK_SEND_MESSAGE",
+  similes: [
+    "SEND_SLACK_MESSAGE",
+    "POST_TO_SLACK",
+    "MESSAGE_SLACK",
+    "SLACK_POST",
+    "SEND_TO_CHANNEL"
+  ],
+  description: "Send a message to a Slack channel or thread",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const prompt = composePromptFromState8({
+      state,
+      template: sendMessageTemplate
+    });
+    let messageInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType8.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText8(response2);
+      if (parsedResponse?.text) {
+        messageInfo = {
+          text: String(parsedResponse.text),
+          channelRef: parsedResponse.channelRef ? String(parsedResponse.channelRef) : "current",
+          threadTs: parsedResponse.threadTs ? String(parsedResponse.threadTs) : undefined
+        };
+        break;
+      }
+    }
+    if (!messageInfo || !messageInfo.text) {
+      runtime.logger.debug({ src: "plugin:slack:action:send-message" }, "[SLACK_SEND_MESSAGE] Could not extract message info");
+      await callback?.({
+        text: "I couldn't understand what message you want me to send. Please try again with a clearer request.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not extract message parameters" };
+    }
+    const stateData = state?.data;
+    const room = stateData?.room || await runtime.getRoom(message.roomId);
+    if (!room || !room.channelId) {
+      await callback?.({
+        text: "I couldn't determine the current channel.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not determine channel" };
+    }
+    let targetChannelId = room.channelId;
+    if (messageInfo.channelRef && messageInfo.channelRef !== "current") {
+      const channels = await slackService.listChannels();
+      const targetChannel = channels.find((ch) => {
+        const channelName = ch.name?.toLowerCase() || "";
+        const searchTerm = messageInfo?.channelRef?.toLowerCase() || "";
+        return channelName === searchTerm || channelName === searchTerm.replace(/^#/, "") || ch.id === messageInfo?.channelRef;
+      });
+      if (targetChannel) {
+        targetChannelId = targetChannel.id;
+      }
+    }
+    const result = await slackService.sendMessage(targetChannelId, messageInfo.text, {
+      threadTs: messageInfo.threadTs || undefined,
+      replyBroadcast: undefined,
+      unfurlLinks: undefined,
+      unfurlMedia: undefined,
+      mrkdwn: undefined,
+      attachments: undefined,
+      blocks: undefined
+    });
+    const response = {
+      text: "Message sent successfully.",
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:send-message",
+      messageTs: result.ts,
+      channelId: targetChannelId
+    }, "[SLACK_SEND_MESSAGE] Message sent successfully");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        messageTs: result.ts,
+        channelId: targetChannelId
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Send a message to #general saying 'Hello everyone!'"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll send that message to #general for you.",
+          actions: ["SLACK_SEND_MESSAGE"]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Post 'Meeting starts in 5 minutes' to this channel"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll post that announcement here.",
+          actions: ["SLACK_SEND_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+var sendMessage_default = sendMessage;
+
+// src/actions/unpinMessage.ts
+import {
+  composePromptFromState as composePromptFromState9,
+  ModelType as ModelType9,
+  parseJSONObjectFromText as parseJSONObjectFromText9
+} from "@elizaos/core";
+var unpinMessageTemplate = `You are helping to extract unpin message parameters for Slack.
+
+The user wants to unpin a message from a Slack channel.
+
+Recent conversation:
+{{recentMessages}}
+
+Extract the following:
+1. messageTs: The message timestamp to unpin (format: 1234567890.123456)
+2. channelId: The channel ID (optional, defaults to current channel)
+
+Respond with a JSON object like:
+{
+  "messageTs": "1234567890.123456",
+  "channelId": null
+}
+
+Only respond with the JSON object, no other text.`;
+var unpinMessage = {
+  name: "SLACK_UNPIN_MESSAGE",
+  similes: [
+    "UNPIN_SLACK_MESSAGE",
+    "UNPIN_MESSAGE",
+    "SLACK_UNPIN",
+    "REMOVE_PIN"
+  ],
+  description: "Unpin a message from a Slack channel",
+  validate: async (_runtime, message, _state) => {
+    return message.content.source === "slack";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const slackService = runtime.getService(SLACK_SERVICE_NAME);
+    if (!slackService || !slackService.client) {
+      await callback?.({
+        text: "Slack service is not available.",
+        source: "slack"
+      });
+      return { success: false, error: "Slack service not available" };
+    }
+    const prompt = composePromptFromState9({
+      state,
+      template: unpinMessageTemplate
+    });
+    let unpinInfo = null;
+    for (let attempt = 0;attempt < 3; attempt++) {
+      const response2 = await runtime.useModel(ModelType9.TEXT_SMALL, {
+        prompt
+      });
+      const parsedResponse = parseJSONObjectFromText9(response2);
+      if (parsedResponse?.messageTs) {
+        unpinInfo = {
+          messageTs: String(parsedResponse.messageTs),
+          channelId: parsedResponse.channelId ? String(parsedResponse.channelId) : null
+        };
+        break;
+      }
+    }
+    if (!unpinInfo || !unpinInfo.messageTs) {
+      runtime.logger.debug({ src: "plugin:slack:action:unpin-message" }, "[SLACK_UNPIN_MESSAGE] Could not extract unpin info");
+      await callback?.({
+        text: "I couldn't understand which message to unpin. Please specify the message timestamp.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not extract unpin parameters" };
+    }
+    if (!isValidMessageTs(unpinInfo.messageTs)) {
+      await callback?.({
+        text: "The message timestamp format is invalid. Please provide a valid Slack message timestamp.",
+        source: "slack"
+      });
+      return { success: false, error: "Invalid message timestamp" };
+    }
+    const stateData = state?.data;
+    const room = stateData?.room || await runtime.getRoom(message.roomId);
+    const channelId = unpinInfo.channelId || room?.channelId;
+    if (!channelId) {
+      await callback?.({
+        text: "I couldn't determine the channel for unpinning the message.",
+        source: "slack"
+      });
+      return { success: false, error: "Could not determine channel" };
+    }
+    await slackService.unpinMessage(channelId, unpinInfo.messageTs);
+    const response = {
+      text: "Message unpinned successfully.",
+      source: message.content.source
+    };
+    runtime.logger.debug({
+      src: "plugin:slack:action:unpin-message",
+      messageTs: unpinInfo.messageTs,
+      channelId
+    }, "[SLACK_UNPIN_MESSAGE] Message unpinned");
+    await callback?.(response);
+    return {
+      success: true,
+      data: {
+        messageTs: unpinInfo.messageTs,
+        channelId
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Unpin that old announcement"
+        }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "I'll remove the pin from that message.",
+          actions: ["SLACK_UNPIN_MESSAGE"]
+        }
+      }
+    ]
+  ]
+};
+var unpinMessage_default = unpinMessage;
+
+// src/providers/channelState.ts
+var channelStateProvider = {
+  name: "slackChannelState",
+  description: "Provides information about the current Slack channel context",
+  get: async (runtime, message, state) => {
+    const room = state.data?.room ?? await runtime.getRoom(message.roomId);
+    if (!room) {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    if (message.content.source !== "slack") {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const agentName = state?.agentName || "The agent";
+    const senderName = state?.senderName || "someone";
+    let responseText = "";
+    let channelType = "";
+    let workspaceName = "";
+    let channelName = "";
+    const channelId = room.channelId ?? "";
+    const threadTs = room.metadata?.threadTs;
+    const slackService = runtime.getService(ServiceType.SLACK);
+    if (!slackService || !slackService.client) {
+      runtime.logger.warn({
+        src: "plugin:slack:provider:channelState",
+        agentId: runtime.agentId,
+        channelId
+      }, "No Slack client found");
+      return {
+        data: {
+          room,
+          channelType: "unknown",
+          channelId
+        },
+        values: {
+          channelType: "unknown",
+          channelId
+        },
+        text: ""
+      };
+    }
+    const channel = channelId ? await slackService.getChannel(channelId) : null;
+    if (channel) {
+      channelName = channel.name;
+      const slackChannelType = getSlackChannelType(channel);
+      if (slackChannelType === "im") {
+        channelType = "DM";
+        responseText = `${agentName} is currently in a direct message conversation with ${senderName} on Slack. ${agentName} should engage in conversation, responding to messages that are addressed to them.`;
+      } else if (slackChannelType === "mpim") {
+        channelType = "GROUP_DM";
+        responseText = `${agentName} is currently in a group direct message on Slack. ${agentName} should be aware that multiple people can see this conversation.`;
+      } else {
+        channelType = slackChannelType === "group" ? "PRIVATE_CHANNEL" : "PUBLIC_CHANNEL";
+        if (threadTs) {
+          responseText = `${agentName} is currently in a thread within the channel #${channelName} on Slack.`;
+          responseText += `
+${agentName} should keep responses focused on the thread topic and be mindful of thread etiquette.`;
+        } else {
+          responseText = `${agentName} is currently having a conversation in the Slack channel #${channelName}.`;
+          responseText += `
+${agentName} is in a channel with other users and should only participate when directly addressed or when the conversation is relevant to them.`;
+        }
+        if (channel.topic?.value) {
+          responseText += `
+Channel topic: ${channel.topic.value}`;
+        }
+        if (channel.purpose?.value) {
+          responseText += `
+Channel purpose: ${channel.purpose.value}`;
+        }
+      }
+    } else {
+      channelType = "unknown";
+      responseText = `${agentName} is in a Slack conversation but couldn't retrieve channel details.`;
+    }
+    const teamId = slackService.getTeamId();
+    if (teamId && room.worldId) {
+      const world = await runtime.getWorld(room.worldId);
+      if (world) {
+        workspaceName = world.name;
+        responseText += `
+Workspace: ${workspaceName}`;
+      }
+    }
+    if (threadTs) {
+      responseText += `
+This is a threaded conversation (thread timestamp: ${threadTs}).`;
+    }
+    return {
+      data: {
+        room,
+        channelType,
+        workspaceName,
+        channelName,
+        channelId,
+        threadTs,
+        isThread: Boolean(threadTs),
+        topic: channel?.topic?.value,
+        purpose: channel?.purpose?.value,
+        isPrivate: channel?.isPrivate,
+        numMembers: channel?.numMembers
+      },
+      values: {
+        channelType,
+        workspaceName,
+        channelName,
+        channelId,
+        isThread: Boolean(threadTs)
+      },
+      text: responseText
+    };
+  }
+};
+
+// src/providers/memberList.ts
+var memberListProvider = {
+  name: "slackMemberList",
+  description: "Provides information about members in the current Slack channel",
+  get: async (runtime, message, state) => {
+    if (message.content.source !== "slack") {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const room = state.data?.room ?? await runtime.getRoom(message.roomId);
+    if (!room || !room.channelId) {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const slackService = runtime.getService(ServiceType.SLACK);
+    if (!slackService || !slackService.client) {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const channelId = room.channelId;
+    const membersResult = await slackService.client.conversations.members({
+      channel: channelId,
+      limit: 100
+    });
+    const memberIds = membersResult.members || [];
+    if (memberIds.length === 0) {
+      return {
+        data: {
+          channelId,
+          memberCount: 0,
+          members: []
+        },
+        values: {
+          memberCount: 0
+        },
+        text: "No members found in this channel."
+      };
+    }
+    const memberLimit = 20;
+    const limitedMemberIds = memberIds.slice(0, memberLimit);
+    const members = [];
+    for (const memberId of limitedMemberIds) {
+      const user = await slackService.getUser(memberId);
+      if (user) {
+        members.push({
+          id: user.id,
+          name: user.name,
+          displayName: getSlackUserDisplayName(user),
+          isBot: user.isBot,
+          isAdmin: user.isAdmin || user.isOwner
+        });
+      }
+    }
+    const channel = await slackService.getChannel(channelId);
+    const channelName = channel?.name || channelId;
+    const botUserId = slackService.getBotUserId();
+    const memberDescriptions = members.map((m) => {
+      const tags = [];
+      if (m.id === botUserId)
+        tags.push("this bot");
+      if (m.isBot && m.id !== botUserId)
+        tags.push("bot");
+      if (m.isAdmin)
+        tags.push("admin");
+      const tagStr = tags.length > 0 ? ` (${tags.join(", ")})` : "";
+      return `- ${m.displayName} (@${m.name})${tagStr}`;
+    });
+    const truncationNote = memberIds.length > memberLimit ? `
+
+(Showing ${memberLimit} of ${memberIds.length} total members)` : "";
+    const responseText = `Members in #${channelName}:
+${memberDescriptions.join(`
+`)}${truncationNote}`;
+    return {
+      data: {
+        channelId,
+        channelName,
+        memberCount: memberIds.length,
+        members,
+        hasMoreMembers: memberIds.length > memberLimit
+      },
+      values: {
+        channelId,
+        channelName,
+        memberCount: memberIds.length
+      },
+      text: responseText
+    };
+  }
+};
+
+// src/providers/workspaceInfo.ts
+var workspaceInfoProvider = {
+  name: "slackWorkspaceInfo",
+  description: "Provides information about the Slack workspace",
+  get: async (runtime, message, state) => {
+    if (message.content.source !== "slack") {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const slackService = runtime.getService(ServiceType.SLACK);
+    if (!slackService || !slackService.client) {
+      return {
+        data: {},
+        values: {},
+        text: ""
+      };
+    }
+    const teamId = slackService.getTeamId();
+    const botUserId = slackService.getBotUserId();
+    const isConnected = slackService.isServiceConnected();
+    let workspaceName = "";
+    let domain = "";
+    const room = state.data?.room ?? await runtime.getRoom(message.roomId);
+    if (room?.worldId) {
+      const world = await runtime.getWorld(room.worldId);
+      if (world) {
+        workspaceName = world.name;
+        const worldMetadata = world.metadata;
+        domain = worldMetadata?.domain || "";
+      }
+    }
+    const channels = await slackService.listChannels({
+      types: "public_channel,private_channel"
+    });
+    const publicChannels = channels.filter((ch) => !ch.isPrivate && !ch.isArchived);
+    const privateChannels = channels.filter((ch) => ch.isPrivate && !ch.isArchived);
+    const memberChannels = channels.filter((ch) => ch.isMember && !ch.isArchived);
+    const allowedChannelIds = slackService.getAllowedChannelIds();
+    const hasChannelRestrictions = allowedChannelIds.length > 0;
+    const agentName = state?.agentName || "The agent";
+    let responseText = `${agentName} is connected to the Slack workspace`;
+    if (workspaceName) {
+      responseText += ` "${workspaceName}"`;
+    }
+    if (domain) {
+      responseText += ` (${domain}.slack.com)`;
+    }
+    responseText += ".";
+    responseText += `
+
+Workspace statistics:`;
+    responseText += `
+- Public channels: ${publicChannels.length}`;
+    responseText += `
+- Private channels: ${privateChannels.length}`;
+    responseText += `
+- Channels the bot is a member of: ${memberChannels.length}`;
+    if (hasChannelRestrictions) {
+      responseText += `
+
+Note: The bot is restricted to ${allowedChannelIds.length} specific channel(s).`;
+    }
+    return {
+      data: {
+        teamId,
+        botUserId,
+        workspaceName,
+        domain,
+        isConnected,
+        publicChannelCount: publicChannels.length,
+        privateChannelCount: privateChannels.length,
+        memberChannelCount: memberChannels.length,
+        hasChannelRestrictions,
+        allowedChannelIds
+      },
+      values: {
+        teamId: teamId || "",
+        botUserId: botUserId || "",
+        workspaceName,
+        domain,
+        isConnected,
+        publicChannelCount: publicChannels.length,
+        privateChannelCount: privateChannels.length,
+        memberChannelCount: memberChannels.length
+      },
+      text: responseText
+    };
+  }
+};
+
+// src/service.ts
+import {
+  ChannelType,
+  createUniqueUuid,
+  Service,
+  stringToUuid
+} from "@elizaos/core";
+import { App, LogLevel } from "@slack/bolt";
+var getMessageService = (runtime) => {
+  if ("messageService" in runtime) {
+    const withMessageService = runtime;
+    return withMessageService.messageService ?? null;
+  }
+  return null;
+};
+
+class SlackService extends Service {
+  static serviceType = SLACK_SERVICE_NAME;
+  capabilityDescription = "The agent is able to send and receive messages on Slack";
+  app = null;
+  client = null;
+  character;
+  botUserId = null;
+  teamId = null;
+  settings;
+  botToken = null;
+  appToken = null;
+  signingSecret = null;
+  allowedChannelIds = new Set;
+  dynamicChannelIds = new Set;
+  userCache = new Map;
+  channelCache = new Map;
+  isStarting = false;
+  isConnected = false;
+  constructor(runtime) {
+    super(runtime);
+    this.character = runtime.character;
+    this.settings = this.loadSettings();
+    const channelIdsRaw = runtime.getSetting("SLACK_CHANNEL_IDS");
+    if (channelIdsRaw?.trim()) {
+      channelIdsRaw.split(",").map((s) => s.trim()).filter((s) => s.length > 0 && isValidChannelId(s)).forEach((id) => this.allowedChannelIds.add(id));
+      this.runtime.logger.debug({
+        src: "plugin:slack",
+        agentId: this.runtime.agentId,
+        allowedChannelIds: Array.from(this.allowedChannelIds)
+      }, "Channel restrictions enabled");
+    }
+  }
+  loadSettings() {
+    const ignoreBotMessages = this.runtime.getSetting("SLACK_SHOULD_IGNORE_BOT_MESSAGES");
+    const respondOnlyToMentions = this.runtime.getSetting("SLACK_SHOULD_RESPOND_ONLY_TO_MENTIONS");
+    return {
+      allowedChannelIds: undefined,
+      shouldIgnoreBotMessages: ignoreBotMessages === "true" || ignoreBotMessages === true,
+      shouldRespondOnlyToMentions: respondOnlyToMentions === "true" || respondOnlyToMentions === true
+    };
+  }
+  static async start(runtime) {
+    const service = new SlackService(runtime);
+    const botToken = runtime.getSetting("SLACK_BOT_TOKEN");
+    const appToken = runtime.getSetting("SLACK_APP_TOKEN");
+    const signingSecret = runtime.getSetting("SLACK_SIGNING_SECRET");
+    const userToken = runtime.getSetting("SLACK_USER_TOKEN");
+    if (!botToken || !botToken.trim()) {
+      runtime.logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_BOT_TOKEN not provided, Slack service will not start");
+      return service;
+    }
+    if (!appToken || !appToken.trim()) {
+      runtime.logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_APP_TOKEN not provided, Socket Mode will not work");
+      return service;
+    }
+    service.botToken = botToken;
+    service.appToken = appToken;
+    service.signingSecret = signingSecret || undefined;
+    service.userToken = userToken || undefined;
+    await service.initialize();
+    return service;
+  }
+  static async stop(runtime) {
+    const service = runtime.getService(SLACK_SERVICE_NAME);
+    if (service) {
+      await service.shutdown();
+    }
+  }
+  async stop() {
+    await this.shutdown();
+  }
+  async initialize() {
+    if (this.isStarting || this.isConnected) {
+      return;
+    }
+    this.isStarting = true;
+    this.runtime.logger.info({ src: "plugin:slack", agentId: this.runtime.agentId }, "Initializing Slack service with Socket Mode");
+    this.app = new App({
+      token: this.botToken,
+      appToken: this.appToken,
+      socketMode: true,
+      logLevel: LogLevel.INFO,
+      ...this.signingSecret ? { signingSecret: this.signingSecret } : {}
+    });
+    this.client = this.app.client;
+    const authResult = await this.client.auth.test();
+    this.botUserId = authResult.user_id;
+    this.teamId = authResult.team_id;
+    this.runtime.logger.info({
+      src: "plugin:slack",
+      agentId: this.runtime.agentId,
+      botUserId: this.botUserId,
+      teamId: this.teamId
+    }, "Slack bot authenticated");
+    this.registerEventHandlers();
+    await this.app.start();
+    this.isConnected = true;
+    this.isStarting = false;
+    this.runtime.logger.info({ src: "plugin:slack", agentId: this.runtime.agentId }, "Slack service started successfully");
+    await this.ensureWorkspaceExists();
+  }
+  async shutdown() {
+    if (this.app) {
+      await this.app.stop();
+      this.app = null;
+      this.client = null;
+      this.isConnected = false;
+      this.runtime.logger.info({ src: "plugin:slack", agentId: this.runtime.agentId }, "Slack service stopped");
+    }
+  }
+  registerEventHandlers() {
+    if (!this.app)
+      return;
+    this.app.message(async ({ message, client }) => {
+      await this.handleMessage(message, client);
+    });
+    this.app.event("app_mention", async ({ event, client }) => {
+      await this.handleAppMention(event, client);
+    });
+    this.app.event("reaction_added", async ({ event }) => {
+      await this.handleReactionAdded(event);
+    });
+    this.app.event("reaction_removed", async ({ event }) => {
+      await this.handleReactionRemoved(event);
+    });
+    this.app.event("member_joined_channel", async ({ event }) => {
+      await this.handleMemberJoinedChannel(event);
+    });
+    this.app.event("member_left_channel", async ({ event }) => {
+      await this.handleMemberLeftChannel(event);
+    });
+    this.app.event("file_shared", async ({ event }) => {
+      await this.handleFileShared(event);
+    });
+  }
+  async handleMessage(message, _client) {
+    if (this.settings.shouldIgnoreBotMessages && message.bot_id) {
+      return;
+    }
+    if (message.user === this.botUserId) {
+      return;
+    }
+    if (!this.isChannelAllowed(message.channel)) {
+      this.runtime.logger.debug({
+        src: "plugin:slack",
+        agentId: this.runtime.agentId,
+        channelId: message.channel
+      }, "Message received in non-allowed channel, ignoring");
+      return;
+    }
+    const isMentioned = message.text?.includes(`<@${this.botUserId}>`);
+    if (this.settings.shouldRespondOnlyToMentions && !isMentioned) {
+      return;
+    }
+    const _isThreadReply = Boolean(message.thread_ts && message.thread_ts !== message.ts);
+    const memory = await this.buildMemoryFromMessage(message);
+    if (!memory)
+      return;
+    const room = await this.ensureRoomExists(message.channel, message.thread_ts);
+    await this.runtime.createMemory(memory, "messages");
+    await this.runtime.emitEvent("SLACK_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, {
+      runtime: this.runtime,
+      source: "slack"
+    });
+    await this.processAgentMessage(memory, room, message.channel, message.thread_ts || message.ts);
+  }
+  async handleAppMention(event, _client) {
+    if (!event.user)
+      return;
+    const memory = await this.buildMemoryFromMention({
+      user: event.user,
+      text: event.text,
+      channel: event.channel,
+      ts: event.ts,
+      thread_ts: event.thread_ts
+    });
+    if (!memory)
+      return;
+    const room = await this.ensureRoomExists(event.channel, event.thread_ts);
+    await this.runtime.createMemory(memory, "messages");
+    await this.runtime.emitEvent("SLACK_APP_MENTION" /* APP_MENTION */, {
+      runtime: this.runtime,
+      source: "slack"
+    });
+    await this.processAgentMessage(memory, room, event.channel, event.thread_ts || event.ts);
+  }
+  async handleReactionAdded(_event) {
+    await this.runtime.emitEvent("SLACK_REACTION_ADDED" /* REACTION_ADDED */, {
+      runtime: this.runtime,
+      source: "slack"
+    });
+  }
+  async handleReactionRemoved(_event) {
+    await this.runtime.emitEvent("SLACK_REACTION_REMOVED" /* REACTION_REMOVED */, {
+      runtime: this.runtime,
+      source: "slack"
+    });
+  }
+  async handleMemberJoinedChannel(event) {
+    if (event.user === this.botUserId) {
+      this.dynamicChannelIds.add(event.channel);
+      await this.ensureRoomExists(event.channel);
+    }
+    await this.runtime.emitEvent("SLACK_MEMBER_JOINED_CHANNEL" /* MEMBER_JOINED_CHANNEL */, {
+      runtime: this.runtime,
+      source: "slack"
+    });
+  }
+  async handleMemberLeftChannel(event) {
+    if (event.user === this.botUserId) {
+      this.dynamicChannelIds.delete(event.channel);
+    }
+    await this.runtime.emitEvent("SLACK_MEMBER_LEFT_CHANNEL" /* MEMBER_LEFT_CHANNEL */, {
+      runtime: this.runtime,
+      source: "slack"
+    });
+  }
+  async handleFileShared(_event) {
+    await this.runtime.emitEvent("SLACK_FILE_SHARED" /* FILE_SHARED */, {
+      runtime: this.runtime,
+      source: "slack"
+    });
+  }
+  isChannelAllowed(channelId) {
+    if (this.allowedChannelIds.size === 0 && this.dynamicChannelIds.size === 0) {
+      return true;
+    }
+    return this.allowedChannelIds.has(channelId) || this.dynamicChannelIds.has(channelId);
+  }
+  async processAgentMessage(memory, room, channelId, threadTs) {
+    const callback = async (response) => {
+      await this.sendMessage(channelId, response.text || "", {
+        threadTs,
+        replyBroadcast: undefined,
+        unfurlLinks: undefined,
+        unfurlMedia: undefined,
+        mrkdwn: undefined,
+        attachments: undefined,
+        blocks: undefined
+      });
+      const responseMemory = {
+        id: createUniqueUuid(this.runtime, `slack-response-${Date.now()}`),
+        agentId: this.runtime.agentId,
+        roomId: room.id,
+        entityId: this.runtime.agentId,
+        content: {
+          text: response.text || "",
+          source: "slack",
+          inReplyTo: memory.id
+        },
+        createdAt: Date.now()
+      };
+      await this.runtime.createMemory(responseMemory, "messages");
+      await this.runtime.emitEvent("SLACK_MESSAGE_SENT" /* MESSAGE_SENT */, {
+        runtime: this.runtime,
+        source: "slack"
+      });
+      return [responseMemory];
+    };
+    const messageService = getMessageService(this.runtime);
+    if (messageService) {
+      await messageService.handleMessage(this.runtime, memory, callback);
+    }
+  }
+  async buildMemoryFromMessage(message) {
+    if (!message.user)
+      return null;
+    const roomId = await this.getRoomId(message.channel, message.thread_ts);
+    const entityId = this.getEntityId(message.user);
+    const user = await this.getUser(message.user);
+    const displayName = user ? getSlackUserDisplayName(user) : message.user;
+    const media = [];
+    if ("files" in message && message.files) {
+      for (const file of message.files) {
+        media.push({
+          id: file.id,
+          url: file.urlPrivate,
+          title: file.title || file.name,
+          source: "slack",
+          description: file.name
+        });
+      }
+    }
+    const memory = {
+      id: createUniqueUuid(this.runtime, `slack-${message.ts}`),
+      agentId: this.runtime.agentId,
+      roomId,
+      entityId,
+      content: {
+        text: message.text || "",
+        source: "slack",
+        name: displayName,
+        ...media.length > 0 ? { attachments: media } : {}
+      },
+      createdAt: this.parseSlackTimestamp(message.ts)
+    };
+    return memory;
+  }
+  async buildMemoryFromMention(event) {
+    const roomId = await this.getRoomId(event.channel, event.thread_ts);
+    const entityId = this.getEntityId(event.user);
+    const user = await this.getUser(event.user);
+    const displayName = user ? getSlackUserDisplayName(user) : event.user;
+    const cleanText = event.text.replace(`<@${this.botUserId}>`, "").trim();
+    const memory = {
+      id: createUniqueUuid(this.runtime, `slack-mention-${event.ts}`),
+      agentId: this.runtime.agentId,
+      roomId,
+      entityId,
+      content: {
+        text: cleanText,
+        source: "slack",
+        name: displayName
+      },
+      createdAt: this.parseSlackTimestamp(event.ts)
+    };
+    return memory;
+  }
+  async getRoomId(channelId, threadTs) {
+    const roomKey = threadTs ? `${channelId}-${threadTs}` : channelId;
+    return createUniqueUuid(this.runtime, `slack-room-${roomKey}`);
+  }
+  getEntityId(userId) {
+    return stringToUuid(`slack-user-${userId}`);
+  }
+  parseSlackTimestamp(ts) {
+    const [seconds] = ts.split(".");
+    return parseInt(seconds, 10) * 1000;
+  }
+  async ensureWorkspaceExists() {
+    if (!this.teamId || !this.client)
+      return;
+    const worldId = createUniqueUuid(this.runtime, `slack-workspace-${this.teamId}`);
+    const existingWorld = await this.runtime.getWorld(worldId);
+    if (existingWorld)
+      return;
+    const teamInfo = await this.client.team.info();
+    const team = teamInfo.team;
+    const world = {
+      id: worldId,
+      name: team?.name || `Slack Workspace ${this.teamId}`,
+      agentId: this.runtime.agentId,
+      metadata: {
+        type: "slack",
+        extra: {
+          teamId: this.teamId,
+          domain: team?.domain
+        }
+      }
+    };
+    await this.runtime.createWorld(world);
+    this.runtime.logger.info({
+      src: "plugin:slack",
+      agentId: this.runtime.agentId,
+      worldId,
+      teamId: this.teamId
+    }, "Created Slack workspace world");
+  }
+  async ensureRoomExists(channelId, threadTs) {
+    const roomId = await this.getRoomId(channelId, threadTs);
+    const existingRoom = await this.runtime.getRoom(roomId);
+    if (existingRoom)
+      return existingRoom;
+    const channel = await this.getChannel(channelId);
+    const channelType = channel ? getSlackChannelType(channel) : "channel";
+    const worldId = this.teamId ? createUniqueUuid(this.runtime, `slack-workspace-${this.teamId}`) : undefined;
+    const elizaChannelType = channelType === "im" ? ChannelType.DM : channelType === "mpim" ? ChannelType.GROUP : ChannelType.GROUP;
+    const room = {
+      id: roomId,
+      name: channel?.name || channelId,
+      agentId: this.runtime.agentId,
+      source: "slack",
+      type: elizaChannelType,
+      channelId,
+      worldId,
+      metadata: {
+        slackChannelType: channelType,
+        threadTs,
+        topic: channel?.topic?.value,
+        purpose: channel?.purpose?.value,
+        serverId: this.teamId
+      }
+    };
+    await this.runtime.createRoom(room);
+    this.runtime.logger.debug({
+      src: "plugin:slack",
+      agentId: this.runtime.agentId,
+      roomId,
+      channelId,
+      threadTs
+    }, "Created Slack room");
+    return room;
+  }
+  async getUser(userId) {
+    if (this.userCache.has(userId)) {
+      return this.userCache.get(userId);
+    }
+    if (!this.client)
+      return null;
+    const result = await this.client.users.info({ user: userId });
+    if (!result.user)
+      return null;
+    const user = {
+      id: result.user.id,
+      teamId: result.user.team_id,
+      name: result.user.name,
+      deleted: result.user.deleted || false,
+      realName: result.user.real_name,
+      tz: result.user.tz,
+      tzLabel: result.user.tz_label,
+      tzOffset: result.user.tz_offset,
+      profile: {
+        title: result.user.profile?.title,
+        phone: result.user.profile?.phone,
+        skype: result.user.profile?.skype,
+        realName: result.user.profile?.real_name,
+        realNameNormalized: result.user.profile?.real_name_normalized,
+        displayName: result.user.profile?.display_name,
+        displayNameNormalized: result.user.profile?.display_name_normalized,
+        statusText: result.user.profile?.status_text,
+        statusEmoji: result.user.profile?.status_emoji,
+        statusExpiration: result.user.profile?.status_expiration,
+        avatarHash: result.user.profile?.avatar_hash,
+        email: result.user.profile?.email,
+        image24: result.user.profile?.image_24,
+        image32: result.user.profile?.image_32,
+        image48: result.user.profile?.image_48,
+        image72: result.user.profile?.image_72,
+        image192: result.user.profile?.image_192,
+        image512: result.user.profile?.image_512,
+        image1024: result.user.profile?.image_1024,
+        imageOriginal: result.user.profile?.image_original,
+        team: result.user.profile?.team
+      },
+      isAdmin: result.user.is_admin || false,
+      isOwner: result.user.is_owner || false,
+      isPrimaryOwner: result.user.is_primary_owner || false,
+      isRestricted: result.user.is_restricted || false,
+      isUltraRestricted: result.user.is_ultra_restricted || false,
+      isBot: result.user.is_bot || false,
+      isAppUser: result.user.is_app_user || false,
+      updated: result.user.updated || 0
+    };
+    this.userCache.set(userId, user);
+    return user;
+  }
+  async getChannel(channelId) {
+    if (this.channelCache.has(channelId)) {
+      return this.channelCache.get(channelId);
+    }
+    if (!this.client)
+      return null;
+    const result = await this.client.conversations.info({ channel: channelId });
+    if (!result.channel)
+      return null;
+    const channel = {
+      id: result.channel.id,
+      name: result.channel.name || "",
+      isChannel: result.channel.is_channel || false,
+      isGroup: result.channel.is_group || false,
+      isIm: result.channel.is_im || false,
+      isMpim: result.channel.is_mpim || false,
+      isPrivate: result.channel.is_private || false,
+      isArchived: result.channel.is_archived || false,
+      isGeneral: result.channel.is_general || false,
+      isShared: result.channel.is_shared || false,
+      isOrgShared: result.channel.is_org_shared || false,
+      isMember: result.channel.is_member || false,
+      topic: result.channel.topic ? {
+        value: result.channel.topic.value,
+        creator: result.channel.topic.creator,
+        lastSet: result.channel.topic.last_set
+      } : undefined,
+      purpose: result.channel.purpose ? {
+        value: result.channel.purpose.value,
+        creator: result.channel.purpose.creator,
+        lastSet: result.channel.purpose.last_set
+      } : undefined,
+      numMembers: result.channel.num_members,
+      created: result.channel.created,
+      creator: result.channel.creator
+    };
+    this.channelCache.set(channelId, channel);
+    return channel;
+  }
+  async sendMessage(channelId, text, options) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    const messages = this.splitMessage(text);
+    let lastTs = "";
+    for (const msg of messages) {
+      const result = await this.client.chat.postMessage({
+        channel: channelId,
+        text: msg,
+        thread_ts: options?.threadTs,
+        reply_broadcast: options?.replyBroadcast,
+        unfurl_links: options?.unfurlLinks,
+        unfurl_media: options?.unfurlMedia,
+        mrkdwn: options?.mrkdwn ?? true,
+        attachments: options?.attachments,
+        blocks: options?.blocks
+      });
+      lastTs = result.ts;
+    }
+    return { ts: lastTs, channelId };
+  }
+  async sendReaction(channelId, messageTs, emoji) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    const cleanEmoji = emoji.replace(/^:/, "").replace(/:$/, "");
+    await this.client.reactions.add({
+      channel: channelId,
+      timestamp: messageTs,
+      name: cleanEmoji
+    });
+  }
+  async removeReaction(channelId, messageTs, emoji) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    const cleanEmoji = emoji.replace(/^:/, "").replace(/:$/, "");
+    await this.client.reactions.remove({
+      channel: channelId,
+      timestamp: messageTs,
+      name: cleanEmoji
+    });
+  }
+  async editMessage(channelId, messageTs, text) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    await this.client.chat.update({
+      channel: channelId,
+      ts: messageTs,
+      text
+    });
+  }
+  async deleteMessage(channelId, messageTs) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    await this.client.chat.delete({
+      channel: channelId,
+      ts: messageTs
+    });
+  }
+  async pinMessage(channelId, messageTs) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    await this.client.pins.add({
+      channel: channelId,
+      timestamp: messageTs
+    });
+  }
+  async unpinMessage(channelId, messageTs) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    await this.client.pins.remove({
+      channel: channelId,
+      timestamp: messageTs
+    });
+  }
+  async listPins(channelId) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    const result = await this.client.pins.list({ channel: channelId });
+    return (result.items || []).filter((item) => item.type === "message" && ("message" in item) && !!item.message).map((item) => ({
+      type: item.message.type,
+      subtype: item.message.subtype,
+      ts: item.message.ts,
+      user: item.message.user,
+      text: item.message.text,
+      threadTs: item.message.thread_ts,
+      replyCount: item.message.reply_count,
+      replyUsersCount: item.message.reply_users_count,
+      latestReply: item.message.latest_reply,
+      reactions: item.message.reactions,
+      files: item.message.files,
+      attachments: item.message.attachments,
+      blocks: item.message.blocks
+    }));
+  }
+  async readHistory(channelId, options) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    const result = await this.client.conversations.history({
+      channel: channelId,
+      limit: options?.limit || 100,
+      latest: options?.before,
+      oldest: options?.after
+    });
+    return (result.messages || []).map((msg) => ({
+      type: msg.type,
+      subtype: msg.subtype,
+      ts: msg.ts,
+      user: msg.user,
+      text: msg.text,
+      threadTs: msg.thread_ts,
+      replyCount: msg.reply_count,
+      replyUsersCount: msg.reply_users_count,
+      latestReply: msg.latest_reply,
+      reactions: msg.reactions,
+      files: msg.files,
+      attachments: msg.attachments,
+      blocks: msg.blocks
+    }));
+  }
+  async listChannels(options) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    const result = await this.client.conversations.list({
+      types: options?.types || "public_channel,private_channel",
+      limit: options?.limit || 1000
+    });
+    return (result.channels || []).map((ch) => ({
+      id: ch.id,
+      name: ch.name || "",
+      isChannel: ch.is_channel || false,
+      isGroup: ch.is_group || false,
+      isIm: ch.is_im || false,
+      isMpim: ch.is_mpim || false,
+      isPrivate: ch.is_private || false,
+      isArchived: ch.is_archived || false,
+      isGeneral: ch.is_general || false,
+      isShared: ch.is_shared || false,
+      isOrgShared: ch.is_org_shared || false,
+      isMember: ch.is_member || false,
+      topic: ch.topic ? {
+        value: ch.topic.value,
+        creator: ch.topic.creator,
+        lastSet: ch.topic.last_set
+      } : undefined,
+      purpose: ch.purpose ? {
+        value: ch.purpose.value,
+        creator: ch.purpose.creator,
+        lastSet: ch.purpose.last_set
+      } : undefined,
+      numMembers: ch.num_members,
+      created: ch.created || 0,
+      creator: ch.creator || ""
+    }));
+  }
+  async getEmojiList() {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    const result = await this.client.emoji.list();
+    return result.emoji || {};
+  }
+  async uploadFile(channelId, content, filename, options) {
+    if (!this.client) {
+      throw new Error("Slack client not initialized");
+    }
+    const result = await this.client.files.uploadV2({
+      channel_id: channelId,
+      content: typeof content === "string" ? content : undefined,
+      file: typeof content !== "string" ? content : undefined,
+      filename,
+      title: options?.title,
+      initial_comment: options?.initialComment,
+      thread_ts: options?.threadTs
+    });
+    const resultWithFile = result;
+    const file = resultWithFile.file;
+    return {
+      fileId: file?.id || "",
+      permalink: file?.permalink || ""
+    };
+  }
+  splitMessage(text) {
+    if (text.length <= MAX_SLACK_MESSAGE_LENGTH) {
+      return [text];
+    }
+    const messages = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+      if (remaining.length <= MAX_SLACK_MESSAGE_LENGTH) {
+        messages.push(remaining);
+        break;
+      }
+      let splitIndex = MAX_SLACK_MESSAGE_LENGTH;
+      const lastNewline = remaining.lastIndexOf(`
+`, MAX_SLACK_MESSAGE_LENGTH);
+      if (lastNewline > MAX_SLACK_MESSAGE_LENGTH / 2) {
+        splitIndex = lastNewline + 1;
+      } else {
+        const lastSpace = remaining.lastIndexOf(" ", MAX_SLACK_MESSAGE_LENGTH);
+        if (lastSpace > MAX_SLACK_MESSAGE_LENGTH / 2) {
+          splitIndex = lastSpace + 1;
+        }
+      }
+      messages.push(remaining.slice(0, splitIndex));
+      remaining = remaining.slice(splitIndex);
+    }
+    return messages;
+  }
+  addAllowedChannel(channelId) {
+    if (isValidChannelId(channelId)) {
+      this.dynamicChannelIds.add(channelId);
+    }
+  }
+  removeAllowedChannel(channelId) {
+    this.dynamicChannelIds.delete(channelId);
+  }
+  getAllowedChannelIds() {
+    return [...this.allowedChannelIds, ...this.dynamicChannelIds];
+  }
+  isServiceConnected() {
+    return this.isConnected && this.app !== null;
+  }
+  getBotUserId() {
+    return this.botUserId;
+  }
+  getTeamId() {
+    return this.teamId;
+  }
+  clearUserCache() {
+    this.userCache.clear();
+  }
+  clearChannelCache() {
+    this.channelCache.clear();
+  }
+}
+
+// src/accounts.ts
+var DEFAULT_ACCOUNT_ID = "default";
+function normalizeAccountId(accountId) {
+  if (!accountId || typeof accountId !== "string") {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  const trimmed = accountId.trim().toLowerCase();
+  return trimmed || DEFAULT_ACCOUNT_ID;
+}
+function normalizeSlackToken(raw, prefix) {
+  const trimmed = raw?.trim();
+  return trimmed?.startsWith(prefix) ? trimmed : undefined;
+}
+function resolveSlackBotToken(raw) {
+  return normalizeSlackToken(raw, "xoxb-");
+}
+function resolveSlackAppToken(raw) {
+  return normalizeSlackToken(raw, "xapp-");
+}
+function resolveSlackUserToken(raw) {
+  return normalizeSlackToken(raw, "xoxp-");
+}
+function getMultiAccountConfig(runtime) {
+  const characterSlack = runtime.character?.settings?.slack;
+  return {
+    enabled: characterSlack?.enabled,
+    botToken: characterSlack?.botToken,
+    appToken: characterSlack?.appToken,
+    accounts: characterSlack?.accounts
+  };
+}
+function listSlackAccountIds(runtime) {
+  const config = getMultiAccountConfig(runtime);
+  const accounts = config.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  const ids = Object.keys(accounts).filter(Boolean);
+  if (ids.length === 0) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return ids.slice().sort((a, b) => a.localeCompare(b));
+}
+function resolveDefaultSlackAccountId(runtime) {
+  const ids = listSlackAccountIds(runtime);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function getAccountConfig(runtime, accountId) {
+  const config = getMultiAccountConfig(runtime);
+  const accounts = config.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return;
+  }
+  return accounts[accountId];
+}
+function filterDefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+function mergeSlackAccountConfig(runtime, accountId) {
+  const multiConfig = getMultiAccountConfig(runtime);
+  const { accounts: _ignored, ...baseConfig } = multiConfig;
+  const accountConfig = getAccountConfig(runtime, accountId) ?? {};
+  const envChannelIds = runtime.getSetting("SLACK_CHANNEL_IDS");
+  const envConfig = {
+    shouldIgnoreBotMessages: runtime.getSetting("SLACK_SHOULD_IGNORE_BOT_MESSAGES")?.toLowerCase() === "true",
+    shouldRespondOnlyToMentions: runtime.getSetting("SLACK_SHOULD_RESPOND_ONLY_TO_MENTIONS")?.toLowerCase() === "true",
+    allowedChannelIds: envChannelIds ? envChannelIds.split(",").map((s) => s.trim()).filter(Boolean) : undefined
+  };
+  return {
+    ...filterDefined(envConfig),
+    ...filterDefined(baseConfig),
+    ...filterDefined(accountConfig)
+  };
+}
+function resolveSlackAccount(runtime, accountId) {
+  const normalizedAccountId = normalizeAccountId(accountId);
+  const multiConfig = getMultiAccountConfig(runtime);
+  const baseEnabled = multiConfig.enabled !== false;
+  const merged = mergeSlackAccountConfig(runtime, normalizedAccountId);
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const allowEnv = normalizedAccountId === DEFAULT_ACCOUNT_ID;
+  const envBotToken = allowEnv ? resolveSlackBotToken(runtime.getSetting("SLACK_BOT_TOKEN")) : undefined;
+  const configBotToken = resolveSlackBotToken(merged.botToken);
+  const botToken = configBotToken ?? envBotToken;
+  const botTokenSource = configBotToken ? "config" : envBotToken ? "env" : "none";
+  const envAppToken = allowEnv ? resolveSlackAppToken(runtime.getSetting("SLACK_APP_TOKEN")) : undefined;
+  const configAppToken = resolveSlackAppToken(merged.appToken);
+  const appToken = configAppToken ?? envAppToken;
+  const appTokenSource = configAppToken ? "config" : envAppToken ? "env" : "none";
+  const signingSecret = merged.signingSecret ?? runtime.getSetting("SLACK_SIGNING_SECRET");
+  const envUserToken = allowEnv ? resolveSlackUserToken(runtime.getSetting("SLACK_USER_TOKEN")) : undefined;
+  const configUserToken = resolveSlackUserToken(merged.userToken);
+  const userToken = configUserToken ?? envUserToken;
+  return {
+    accountId: normalizedAccountId,
+    enabled,
+    name: merged.name?.trim() || undefined,
+    botToken,
+    appToken,
+    signingSecret,
+    userToken,
+    botTokenSource,
+    appTokenSource,
+    config: merged
+  };
+}
+function listEnabledSlackAccounts(runtime) {
+  return listSlackAccountIds(runtime).map((accountId) => resolveSlackAccount(runtime, accountId)).filter((account) => account.enabled && account.botToken);
+}
+function isMultiAccountEnabled(runtime) {
+  const accounts = listEnabledSlackAccounts(runtime);
+  return accounts.length > 1;
+}
+function resolveSlackReplyToMode(account, chatType) {
+  const normalized = chatType?.toLowerCase().trim();
+  if (normalized && account.config.replyToModeByChatType?.[normalized] !== undefined) {
+    return account.config.replyToModeByChatType[normalized] ?? "off";
+  }
+  if (normalized === "direct" || normalized === "im") {
+    if (account.config.dm?.replyToMode !== undefined) {
+      return account.config.dm.replyToMode;
+    }
+  }
+  return account.config.replyToMode ?? "off";
+}
+// src/formatting.ts
+function escapeSlackMrkdwnSegment(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+var SLACK_ANGLE_TOKEN_RE = /<[^>\n]+>/g;
+function isAllowedSlackAngleToken(token) {
+  if (!token.startsWith("<") || !token.endsWith(">")) {
+    return false;
+  }
+  const inner = token.slice(1, -1);
+  return inner.startsWith("@") || inner.startsWith("#") || inner.startsWith("!") || inner.startsWith("mailto:") || inner.startsWith("tel:") || inner.startsWith("http://") || inner.startsWith("https://") || inner.startsWith("slack://");
+}
+function escapeSlackMrkdwnContent(text) {
+  if (!text.includes("&") && !text.includes("<") && !text.includes(">")) {
+    return text;
+  }
+  SLACK_ANGLE_TOKEN_RE.lastIndex = 0;
+  const out = [];
+  let lastIndex = 0;
+  for (let match = SLACK_ANGLE_TOKEN_RE.exec(text);match; match = SLACK_ANGLE_TOKEN_RE.exec(text)) {
+    const matchIndex = match.index ?? 0;
+    out.push(escapeSlackMrkdwnSegment(text.slice(lastIndex, matchIndex)));
+    const token = match[0] ?? "";
+    out.push(isAllowedSlackAngleToken(token) ? token : escapeSlackMrkdwnSegment(token));
+    lastIndex = matchIndex + token.length;
+  }
+  out.push(escapeSlackMrkdwnSegment(text.slice(lastIndex)));
+  return out.join("");
+}
+function escapeSlackMrkdwn(text) {
+  if (!text.includes("&") && !text.includes("<") && !text.includes(">")) {
+    return text;
+  }
+  return text.split(`
+`).map((line) => {
+    if (line.startsWith("> ")) {
+      return `> ${escapeSlackMrkdwnContent(line.slice(2))}`;
+    }
+    return escapeSlackMrkdwnContent(line);
+  }).join(`
+`);
+}
+var BOLD_PLACEHOLDER = "\x00BOLD\x00";
+function convertBold(text) {
+  return text.replace(/\*\*(.+?)\*\*/g, `${BOLD_PLACEHOLDER}$1${BOLD_PLACEHOLDER}`);
+}
+function convertItalic(text) {
+  const converted = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "_$1_");
+  return converted.replace(new RegExp(BOLD_PLACEHOLDER, "g"), "*");
+}
+function convertStrikethrough(text) {
+  return text.replace(/~~(.+?)~~/g, "~$1~");
+}
+function convertCodeBlocks(text) {
+  return text.replace(/```(\w*)\n?([\s\S]*?)```/g, "```\n$2```");
+}
+function convertLinks(text) {
+  return text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, linkText, url) => {
+    const trimmedUrl = url.trim();
+    const trimmedText = linkText.trim();
+    if (trimmedText === trimmedUrl || trimmedText === trimmedUrl.replace(/^mailto:/, "")) {
+      return `<${escapeSlackMrkdwnSegment(trimmedUrl)}>`;
+    }
+    return `<${escapeSlackMrkdwnSegment(trimmedUrl)}|${escapeSlackMrkdwnSegment(trimmedText)}>`;
+  });
+}
+function convertHeadings(text) {
+  return text.replace(/^#{1,6}\s+(.+)$/gm, `${BOLD_PLACEHOLDER}$1${BOLD_PLACEHOLDER}`);
+}
+function markdownToSlackMrkdwn(markdown) {
+  if (!markdown) {
+    return "";
+  }
+  let result = convertCodeBlocks(markdown);
+  result = convertLinks(result);
+  result = convertHeadings(result);
+  result = convertBold(result);
+  result = convertItalic(result);
+  result = convertStrikethrough(result);
+  result = escapeSlackMrkdwn(result);
+  return result;
+}
+var DEFAULT_MAX_CHARS = 4000;
+function chunkSlackText(text, maxChars = DEFAULT_MAX_CHARS) {
+  if (!text) {
+    return [];
+  }
+  if (text.length <= maxChars) {
+    return [text];
+  }
+  const chunks = [];
+  let remaining = text;
+  let inCodeBlock = false;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxChars) {
+      chunks.push(remaining);
+      break;
+    }
+    let breakPoint = maxChars;
+    const codeBlockCount = (remaining.slice(0, maxChars).match(/```/g) || []).length;
+    inCodeBlock = codeBlockCount % 2 !== 0;
+    const newlineIndex = remaining.lastIndexOf(`
+`, maxChars);
+    if (newlineIndex > maxChars * 0.5) {
+      breakPoint = newlineIndex + 1;
+    } else {
+      const spaceIndex = remaining.lastIndexOf(" ", maxChars);
+      if (spaceIndex > maxChars * 0.5) {
+        breakPoint = spaceIndex + 1;
+      }
+    }
+    let chunk = remaining.slice(0, breakPoint);
+    if (inCodeBlock) {
+      chunk += "\n```";
+    }
+    chunks.push(chunk);
+    remaining = remaining.slice(breakPoint);
+    if (inCodeBlock) {
+      remaining = `\`\`\`
+${remaining}`;
+    }
+  }
+  return chunks;
+}
+function markdownToSlackMrkdwnChunks(markdown, limit) {
+  return chunkSlackText(markdownToSlackMrkdwn(markdown), limit);
+}
+function formatSlackUserMention(userId) {
+  return `<@${userId}>`;
+}
+function formatSlackChannelMention(channelId) {
+  return `<#${channelId}>`;
+}
+function formatSlackUserGroupMention(groupId) {
+  return `<!subteam^${groupId}>`;
+}
+function formatSlackSpecialMention(type) {
+  return `<!${type}>`;
+}
+function formatSlackLink(url, text) {
+  const safeUrl = escapeSlackMrkdwnSegment(url);
+  if (text && text !== url) {
+    return `<${safeUrl}|${escapeSlackMrkdwnSegment(text)}>`;
+  }
+  return `<${safeUrl}>`;
+}
+function formatSlackDate(timestamp, format = "{date_short_pretty} at {time}", fallbackText) {
+  const unix = Math.floor((typeof timestamp === "number" ? timestamp : timestamp.getTime()) / 1000);
+  const fallback = fallbackText || new Date(unix * 1000).toISOString();
+  return `<!date^${unix}^${format}|${fallback}>`;
+}
+function extractUserIdFromMention(mention) {
+  const match = mention.match(/^<@([UW][A-Z0-9]+)(?:\|[^>]*)?>$/i);
+  return match ? match[1] : null;
+}
+function extractChannelIdFromMention(mention) {
+  const match = mention.match(/^<#([CGD][A-Z0-9]+)(?:\|[^>]*)?>$/i);
+  return match ? match[1] : null;
+}
+function extractUrlFromSlackLink(link) {
+  const match = link.match(/^<(https?:\/\/[^|>]+)(?:\|[^>]*)?>$/);
+  return match ? match[1] : null;
+}
+function formatSlackUserDisplayName(user) {
+  return user.profile.displayName || user.profile.realName || user.name;
+}
+function formatSlackChannel(channel) {
+  if (channel.isIm) {
+    return "Direct Message";
+  }
+  if (channel.isMpim) {
+    return `Group DM: ${channel.name}`;
+  }
+  return `#${channel.name}`;
+}
+function getChannelTypeString(channel) {
+  if (channel.isIm) {
+    return "DM";
+  }
+  if (channel.isMpim) {
+    return "Group DM";
+  }
+  if (channel.isPrivate || channel.isGroup) {
+    return "Private Channel";
+  }
+  return "Channel";
+}
+function resolveSlackSystemLocation(channel, teamName) {
+  const channelType = getChannelTypeString(channel);
+  const channelName = formatSlackChannel(channel);
+  if (teamName) {
+    return `${teamName} - ${channelType}: ${channelName}`;
+  }
+  return `${channelType}: ${channelName}`;
+}
+function isDirectMessage(channel) {
+  return channel.isIm;
+}
+function isGroupDm(channel) {
+  return channel.isMpim;
+}
+function isPrivateChannel(channel) {
+  return channel.isPrivate || channel.isGroup;
+}
+function truncateText(text, maxLength, ellipsis = "…") {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength - ellipsis.length) + ellipsis;
+}
+function stripSlackFormatting(text) {
+  return text.replace(/```[\s\S]*?```/g, "").replace(/\*([^*]+)\*/g, "$1").replace(/_([^_]+)_/g, "$1").replace(/~([^~]+)~/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/<@[UW][A-Z0-9]+(?:\|[^>]*)?>/gi, "").replace(/<#[CGD][A-Z0-9]+(?:\|[^>]*)?>/gi, "").replace(/<!subteam\^[A-Z0-9]+(?:\|[^>]*)?>/gi, "").replace(/<!(?:here|channel|everyone)(?:\|[^>]*)?>/gi, "").replace(/<(https?:\/\/[^|>]+)(?:\|([^>]*))?>/, "$2").replace(/<(https?:\/\/[^>]+)>/, "$1").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").trim();
+}
+function buildSlackMessagePermalink(workspaceDomain, channelId, messageTs) {
+  const formattedTs = `p${messageTs.replace(".", "")}`;
+  return `https://${workspaceDomain}.slack.com/archives/${channelId}/${formattedTs}`;
+}
+function parseSlackMessagePermalink(link) {
+  const match = link.match(/^https?:\/\/([^.]+)\.slack\.com\/archives\/([CGD][A-Z0-9]+)\/p(\d+)/i);
+  if (!match) {
+    return null;
+  }
+  const ts = match[3];
+  const messageTs = `${ts.slice(0, 10)}.${ts.slice(10)}`;
+  return {
+    workspaceDomain: match[1],
+    channelId: match[2],
+    messageTs
+  };
+}
+
+// src/index.ts
+var slackPlugin = {
+  name: "slack",
+  description: "Slack integration plugin for ElizaOS with Socket Mode support",
+  services: [SlackService],
+  actions: [
+    sendMessage_default,
+    reactToMessage_default,
+    readChannel_default,
+    editMessage_default,
+    deleteMessage_default,
+    pinMessage_default,
+    unpinMessage_default,
+    listChannels_default,
+    getUserInfo_default,
+    listPins_default,
+    emojiList_default
+  ],
+  providers: [channelStateProvider, workspaceInfoProvider, memberListProvider],
+  init: async (_config, runtime) => {
+    const botToken = runtime.getSetting("SLACK_BOT_TOKEN");
+    const appToken = runtime.getSetting("SLACK_APP_TOKEN");
+    const signingSecret = runtime.getSetting("SLACK_SIGNING_SECRET");
+    const userToken = runtime.getSetting("SLACK_USER_TOKEN");
+    const channelIds = runtime.getSetting("SLACK_CHANNEL_IDS");
+    const ignoreBotMessages = runtime.getSetting("SLACK_SHOULD_IGNORE_BOT_MESSAGES");
+    const respondOnlyToMentions = runtime.getSetting("SLACK_SHOULD_RESPOND_ONLY_TO_MENTIONS");
+    const maskToken = (token) => {
+      if (!token || token.trim() === "")
+        return "[not set]";
+      if (token.length <= 8)
+        return "***";
+      return `${token.slice(0, 4)}...${token.slice(-4)}`;
+    };
+    logger.info({
+      src: "plugin:slack",
+      agentId: runtime.agentId,
+      settings: {
+        botToken: maskToken(botToken),
+        appToken: maskToken(appToken),
+        signingSecret: signingSecret ? "[set]" : "[not set]",
+        userToken: maskToken(userToken),
+        channelIds: channelIds || "[all channels]",
+        ignoreBotMessages: ignoreBotMessages || "false",
+        respondOnlyToMentions: respondOnlyToMentions || "false"
+      }
+    }, "Slack plugin initializing");
+    if (!botToken || botToken.trim() === "") {
+      logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_BOT_TOKEN not provided - Slack plugin is loaded but will not be functional");
+      logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "To enable Slack functionality, please provide SLACK_BOT_TOKEN in your .env file");
+      return;
+    }
+    if (!appToken || appToken.trim() === "") {
+      logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_APP_TOKEN not provided - Socket Mode will not work");
+      logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "To enable Socket Mode, please provide SLACK_APP_TOKEN in your .env file");
+      return;
+    }
+    if (!botToken.startsWith("xoxb-")) {
+      logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_BOT_TOKEN should start with 'xoxb-'. Please verify your token.");
+    }
+    if (!appToken.startsWith("xapp-")) {
+      logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_APP_TOKEN should start with 'xapp-'. Please verify your token.");
+    }
+    if (userToken && !userToken.startsWith("xoxp-")) {
+      logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_USER_TOKEN should start with 'xoxp-'. Please verify your token.");
+    }
+    logger.info({ src: "plugin:slack", agentId: runtime.agentId }, "Slack plugin configuration validated successfully");
+  }
+};
+var src_default = slackPlugin;
+export {
+  workspaceInfoProvider,
+  unpinMessage,
+  truncateText,
+  stripSlackFormatting,
+  sendMessage,
+  resolveSlackUserToken,
+  resolveSlackSystemLocation,
+  resolveSlackReplyToMode,
+  resolveSlackBotToken,
+  resolveSlackAppToken,
+  resolveSlackAccount,
+  resolveDefaultSlackAccountId,
+  readChannel,
+  reactToMessage,
+  pinMessage,
+  parseSlackMessagePermalink,
+  parseSlackMessageLink,
+  normalizeAccountId,
+  memberListProvider,
+  markdownToSlackMrkdwnChunks,
+  markdownToSlackMrkdwn,
+  listSlackAccountIds,
+  listPins,
+  listEnabledSlackAccounts,
+  listChannels,
+  isValidUserId,
+  isValidTeamId,
+  isValidMessageTs,
+  isValidChannelId,
+  isPrivateChannel,
+  isMultiAccountEnabled,
+  isGroupDm,
+  isDirectMessage,
+  getUserInfo,
+  getSlackUserDisplayName,
+  getSlackChannelType,
+  getChannelTypeString,
+  formatSlackUserMention,
+  formatSlackUserGroupMention,
+  formatSlackUserDisplayName,
+  formatSlackSpecialMention,
+  formatSlackLink,
+  formatSlackDate,
+  formatSlackChannelMention,
+  formatSlackChannel,
+  formatMessageTsForLink,
+  extractUserIdFromMention,
+  extractUrlFromSlackLink,
+  extractChannelIdFromMention,
+  escapeSlackMrkdwn,
+  emojiList,
+  editMessage,
+  deleteMessage,
+  src_default as default,
+  chunkSlackText,
+  channelStateProvider,
+  buildSlackMessagePermalink,
+  SlackServiceNotInitializedError,
+  SlackService,
+  SlackPluginError,
+  SlackEventTypes,
+  SlackConfigurationError,
+  SlackClientNotAvailableError,
+  SlackApiError,
+  SLACK_SERVICE_NAME,
+  MAX_SLACK_MESSAGE_LENGTH,
+  MAX_SLACK_FILE_SIZE,
+  MAX_SLACK_BLOCKS,
+  DEFAULT_ACCOUNT_ID
+};
+
+//# debugId=B812885F9371C56F64756E2164756E21