@elizaos/plugin-slack 2.0.0-beta.1 → 2.0.11-beta.7

package/dist/index.js

@@ -1,3036 +0,0 @@
-// src/index.ts
-import {
-  getConnectorAccountManager,
-  logger as logger2
-} from "@elizaos/core";
-
-// src/connector-account-provider.ts
-import {
-  logger
-} from "@elizaos/core";
-
-// 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/connector-credential-refs.ts
-import {
-  CONNECTOR_ACCOUNT_STORAGE_SERVICE_TYPE
-} from "@elizaos/core";
-async function persistConnectorCredentialRefs(params) {
-  const refs = [];
-  const vaultWriters = resolveVaultWriters(params.runtime, {
-    provider: params.provider,
-    accountId: params.accountIdForRef,
-    caller: params.caller
-  });
-  if (vaultWriters.length === 0) {
-    throw new Error(`No durable connector credential store or vault writer is available for ${params.provider} account ${params.accountIdForRef}. Refusing to mark OAuth account connected without persisted credentials.`);
-  }
-  if (!params.storageAccountId) {
-    throw new Error(`No durable connector account id is available for ${params.provider} account ${params.accountIdForRef}. Refusing to mark OAuth account connected without persisted credential refs.`);
-  }
-  const storageWriters = resolveCredentialRefWriters(params.runtime, params.manager, params.storageAccountId);
-  if (storageWriters.length === 0) {
-    throw new Error(`No durable connector credential ref writer is available for ${params.provider} account ${params.storageAccountId}. Refusing to mark OAuth account connected without persisted credential refs.`);
-  }
-  for (const credential of params.credentials) {
-    const plannedRef = buildConnectorCredentialVaultRef({
-      agentId: nonEmptyString(params.runtime.agentId) ?? "agent",
-      provider: params.provider,
-      accountId: params.accountIdForRef,
-      credentialType: credential.credentialType
-    });
-    const vaultRef = await writeWithFirstAvailableVault(vaultWriters, plannedRef, credential);
-    refs.push({
-      credentialType: credential.credentialType,
-      vaultRef,
-      ...credential.expiresAt !== undefined ? { expiresAt: credential.expiresAt } : {},
-      ...credential.metadata ? { metadata: credential.metadata } : {}
-    });
-  }
-  if (refs.length > 0) {
-    await writeRefsToStorage(storageWriters, refs);
-  }
-  return {
-    refs,
-    vaultAvailable: vaultWriters.length > 0,
-    storageAvailable: storageWriters.length > 0
-  };
-}
-function resolveVaultWriters(runtime, context) {
-  const writers = [];
-  const credentialStore = getFirstService(runtime, [
-    "connector_credential_store",
-    "CONNECTOR_CREDENTIAL_STORE",
-    "connectorCredentialStore",
-    "credential_store"
-  ]);
-  if (typeof credentialStore?.putSecret === "function") {
-    writers.push({
-      name: "connector_credential_store",
-      write: async (vaultRef, credential) => credentialStore.putSecret?.({
-        vaultRef,
-        agentId: nonEmptyString(runtime.agentId) ?? "agent",
-        provider: context.provider,
-        accountId: context.accountId,
-        credentialType: credential.credentialType,
-        value: credential.value,
-        caller: context.caller
-      }) ?? vaultRef
-    });
-  }
-  const vault = getFirstService(runtime, ["vault", "VAULT"]);
-  if (typeof vault?.set === "function") {
-    writers.push({
-      name: "vault",
-      write: async (vaultRef, credential) => {
-        await vault.set?.(vaultRef, credential.value, {
-          sensitive: true,
-          caller: context.caller
-        });
-        return vaultRef;
-      }
-    });
-  }
-  const secrets = getService(runtime, "SECRETS");
-  if (typeof secrets?.setGlobal === "function" || typeof secrets?.set === "function") {
-    writers.push({
-      name: "SECRETS",
-      write: async (vaultRef, credential) => {
-        if (typeof secrets.setGlobal === "function") {
-          await secrets.setGlobal(vaultRef, credential.value, {
-            sensitive: true
-          });
-          return vaultRef;
-        }
-        await secrets.set?.(vaultRef, credential.value, { level: "global", agentId: runtime.agentId }, { sensitive: true });
-        return vaultRef;
-      }
-    });
-  }
-  return writers;
-}
-function resolveCredentialRefWriters(runtime, manager, accountId) {
-  const candidates = [
-    manager?.getStorage?.(),
-    getService(runtime, CONNECTOR_ACCOUNT_STORAGE_SERVICE_TYPE),
-    runtime.adapter
-  ].filter(Boolean);
-  const writers = [];
-  for (const candidate of candidates) {
-    const writer = candidate;
-    if (typeof writer.setConnectorAccountCredentialRef === "function") {
-      writers.push({
-        name: "setConnectorAccountCredentialRef",
-        write: async (ref) => {
-          await writer.setConnectorAccountCredentialRef?.({
-            accountId,
-            credentialType: ref.credentialType,
-            vaultRef: ref.vaultRef,
-            ...ref.metadata ? { metadata: ref.metadata } : {},
-            ...ref.expiresAt !== undefined ? { expiresAt: ref.expiresAt } : {}
-          });
-        }
-      });
-    } else if (typeof writer.setCredentialRef === "function") {
-      writers.push({
-        name: "setCredentialRef",
-        write: async (ref) => {
-          await writer.setCredentialRef?.({
-            accountId,
-            credentialType: ref.credentialType,
-            vaultRef: ref.vaultRef,
-            ...ref.metadata ? { metadata: ref.metadata } : {},
-            ...ref.expiresAt !== undefined ? { expiresAt: ref.expiresAt } : {}
-          });
-        }
-      });
-    }
-  }
-  return writers;
-}
-async function writeWithFirstAvailableVault(writers, plannedRef, credential) {
-  const errors = [];
-  for (const writer of writers) {
-    try {
-      return await writer.write(plannedRef, credential);
-    } catch (error) {
-      errors.push(`${writer.name}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  throw new Error(`Failed to persist connector credential ref ${plannedRef}: ${errors.join("; ")}`);
-}
-async function writeRefsToStorage(writers, refs) {
-  const errors = [];
-  for (const writer of writers) {
-    try {
-      for (const ref of refs) {
-        await writer.write(ref);
-      }
-      return;
-    } catch (error) {
-      errors.push(`${writer.name}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  throw new Error(`Failed to persist connector credential refs: ${errors.join("; ")}`);
-}
-function buildConnectorCredentialVaultRef(params) {
-  return [
-    "connector",
-    normalizeVaultSegment(params.agentId),
-    normalizeVaultSegment(params.provider),
-    normalizeVaultSegment(params.accountId),
-    normalizeVaultSegment(params.credentialType)
-  ].join(".");
-}
-function normalizeVaultSegment(value) {
-  const normalized = value.trim().replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
-  return (normalized || "unknown").slice(0, 64);
-}
-function getFirstService(runtime, serviceTypes) {
-  for (const serviceType of serviceTypes) {
-    const service = getService(runtime, serviceType);
-    if (service)
-      return service;
-  }
-  return null;
-}
-function getService(runtime, serviceType) {
-  try {
-    return runtime.getService?.(serviceType) ?? null;
-  } catch {
-    return null;
-  }
-}
-function nonEmptyString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-// 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";
-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/connector-account-provider.ts
-var SLACK_OAUTH_AUTHORIZE_URL = "https://slack.com/oauth/v2/authorize";
-var SLACK_OAUTH_TOKEN_URL = "https://slack.com/api/oauth.v2.access";
-var DEFAULT_BOT_SCOPES = [
-  "app_mentions:read",
-  "channels:history",
-  "channels:read",
-  "chat:write",
-  "groups:history",
-  "groups:read",
-  "im:history",
-  "im:read",
-  "im:write",
-  "mpim:history",
-  "mpim:read",
-  "reactions:read",
-  "reactions:write",
-  "users:read"
-];
-var DEFAULT_PURPOSES = [
-  "messaging",
-  "posting",
-  "reading"
-];
-function nowMs() {
-  return Date.now();
-}
-function nonEmptyString2(value) {
-  if (typeof value !== "string")
-    return;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-function readSetting(runtime, key) {
-  return nonEmptyString2(runtime.getSetting?.(key));
-}
-function readClientConfig(runtime) {
-  const clientId = readSetting(runtime, "SLACK_CLIENT_ID");
-  const clientSecret = readSetting(runtime, "SLACK_CLIENT_SECRET");
-  const redirectUri = readSetting(runtime, "SLACK_REDIRECT_URI");
-  if (!clientId || !clientSecret || !redirectUri) {
-    throw new Error("Slack OAuth requires SLACK_CLIENT_ID, SLACK_CLIENT_SECRET, and SLACK_REDIRECT_URI to be configured.");
-  }
-  return { clientId, clientSecret, redirectUri };
-}
-function synthesizeAccount(accountId, name, isDefault, source) {
-  return {
-    id: accountId,
-    provider: SLACK_SERVICE_NAME,
-    label: name ?? `Slack (${accountId})`,
-    role: "OWNER",
-    purpose: DEFAULT_PURPOSES,
-    accessGate: "open",
-    status: "connected",
-    createdAt: nowMs(),
-    updatedAt: nowMs(),
-    metadata: {
-      synthesized: true,
-      source,
-      isDefault
-    }
-  };
-}
-function normalizePurposes(purpose, fallback) {
-  if (Array.isArray(purpose))
-    return purpose;
-  if (typeof purpose === "string" && purpose.trim())
-    return [purpose];
-  return fallback;
-}
-function mergeStoredAccountPatch(account, patch) {
-  return {
-    ...account,
-    ...patch,
-    provider: SLACK_SERVICE_NAME,
-    id: account.id,
-    purpose: normalizePurposes(patch.purpose, account.purpose),
-    externalId: patch.externalId === undefined ? account.externalId : patch.externalId ?? undefined,
-    displayHandle: patch.displayHandle === undefined ? account.displayHandle : patch.displayHandle ?? undefined,
-    ownerBindingId: patch.ownerBindingId === undefined ? account.ownerBindingId : patch.ownerBindingId ?? undefined,
-    ownerIdentityId: patch.ownerIdentityId === undefined ? account.ownerIdentityId : patch.ownerIdentityId ?? undefined,
-    metadata: patch.metadata ?? account.metadata,
-    createdAt: account.createdAt
-  };
-}
-function createSlackConnectorAccountProvider(runtime) {
-  return {
-    provider: SLACK_SERVICE_NAME,
-    label: "Slack",
-    listAccounts: async (manager) => {
-      const persisted = await manager.getStorage().listAccounts(SLACK_SERVICE_NAME);
-      const persistedById = new Map(persisted.map((a) => [a.id, a]));
-      const enabled = listEnabledSlackAccounts(runtime);
-      const defaultAccountId = resolveDefaultSlackAccountId(runtime);
-      const synthesized = enabled.filter((account) => !persistedById.has(account.accountId)).map((account) => synthesizeAccount(account.accountId, account.name, account.accountId === defaultAccountId, account.botTokenSource));
-      if (synthesized.length === 0 && persisted.length === 0) {
-        const fallback = resolveSlackAccount(runtime, DEFAULT_ACCOUNT_ID);
-        if (fallback.botToken) {
-          synthesized.push(synthesizeAccount(DEFAULT_ACCOUNT_ID, fallback.name, true, fallback.botTokenSource));
-        }
-      }
-      return [...persisted, ...synthesized];
-    },
-    createAccount: async (input) => {
-      return {
-        ...input,
-        provider: SLACK_SERVICE_NAME,
-        role: input.role ?? "OWNER",
-        purpose: input.purpose ?? DEFAULT_PURPOSES,
-        accessGate: input.accessGate ?? "open",
-        status: input.status ?? "pending"
-      };
-    },
-    patchAccount: async (accountId, patch, manager) => {
-      const existing = await manager.getStorage().getAccount(SLACK_SERVICE_NAME, accountId);
-      if (existing) {
-        return mergeStoredAccountPatch(existing, patch);
-      }
-      return { ...patch, provider: SLACK_SERVICE_NAME };
-    },
-    deleteAccount: async () => {},
-    startOAuth: async (request) => {
-      const config = readClientConfig(runtime);
-      const redirectUri = request.redirectUri ?? config.redirectUri;
-      const requestedScopes = request.scopes && request.scopes.length > 0 ? request.scopes : DEFAULT_BOT_SCOPES;
-      const params = new URLSearchParams({
-        client_id: config.clientId,
-        redirect_uri: redirectUri,
-        scope: requestedScopes.join(","),
-        state: request.flow.state
-      });
-      return {
-        authUrl: `${SLACK_OAUTH_AUTHORIZE_URL}?${params.toString()}`,
-        metadata: {
-          ...request.metadata,
-          requestedScopes,
-          redirectUri
-        }
-      };
-    },
-    completeOAuth: async (request, manager) => {
-      const code = nonEmptyString2(request.code);
-      if (!code) {
-        throw new Error("Slack OAuth callback is missing an authorization code.");
-      }
-      const config = readClientConfig(runtime);
-      const redirectUri = nonEmptyString2(request.flow.redirectUri) ?? nonEmptyString2(request.flow.metadata?.redirectUri) ?? config.redirectUri;
-      const tokenParams = new URLSearchParams({
-        client_id: config.clientId,
-        client_secret: config.clientSecret,
-        code,
-        redirect_uri: redirectUri
-      });
-      const response = await fetch(SLACK_OAUTH_TOKEN_URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: tokenParams.toString()
-      });
-      if (!response.ok) {
-        const body = await response.text();
-        throw new Error(`Slack token exchange failed with ${response.status}: ${body}`);
-      }
-      const parsed = await response.json();
-      if (!parsed.ok || !parsed.access_token) {
-        throw new Error(`Slack token exchange returned an error: ${parsed.error ?? "unknown"}`);
-      }
-      const teamId = parsed.team?.id;
-      if (!teamId) {
-        throw new Error("Slack token exchange did not include a team id.");
-      }
-      const teamName = parsed.team?.name;
-      const grantedScopes = parsed.scope ? parsed.scope.split(",") : [];
-      const expiresAt = typeof parsed.expires_in === "number" ? Date.now() + parsed.expires_in * 1000 : undefined;
-      const authedUserExpiresAt = typeof parsed.authed_user?.expires_in === "number" ? Date.now() + parsed.authed_user.expires_in * 1000 : undefined;
-      const oauthCredentialVersion = String(Date.now());
-      const accountMetadata = {
-        teamId,
-        teamName: teamName ?? null,
-        appId: parsed.app_id ?? null,
-        botUserId: parsed.bot_user_id ?? null,
-        enterpriseId: parsed.enterprise?.id ?? null,
-        authedUserId: parsed.authed_user?.id ?? null,
-        tokenType: parsed.token_type ?? "bot",
-        grantedScopes,
-        hasRefreshToken: Boolean(parsed.refresh_token ?? parsed.authed_user?.refresh_token),
-        expiresAt,
-        oauthCredentialVersion
-      };
-      const pendingAccount = await manager.upsertAccount(SLACK_SERVICE_NAME, {
-        provider: SLACK_SERVICE_NAME,
-        role: "OWNER",
-        purpose: DEFAULT_PURPOSES,
-        accessGate: "open",
-        status: "pending",
-        externalId: teamId,
-        displayHandle: teamName,
-        label: teamName ?? `Slack workspace ${teamId}`,
-        metadata: accountMetadata
-      }, request.flow.accountId);
-      const credentialPersist = await persistConnectorCredentialRefs({
-        runtime,
-        manager,
-        provider: SLACK_SERVICE_NAME,
-        accountIdForRef: pendingAccount.id,
-        storageAccountId: pendingAccount.id,
-        caller: "plugin-slack",
-        credentials: [
-          {
-            credentialType: "oauth.tokens",
-            value: JSON.stringify({
-              access_token: parsed.access_token,
-              ...parsed.refresh_token ? { refresh_token: parsed.refresh_token } : {},
-              token_type: parsed.token_type ?? "bot",
-              scope: parsed.scope ?? grantedScopes.join(","),
-              ...expiresAt !== undefined ? { expires_at: expiresAt } : {},
-              ...parsed.authed_user?.access_token ? {
-                authed_user: {
-                  id: parsed.authed_user.id,
-                  access_token: parsed.authed_user.access_token,
-                  ...parsed.authed_user.refresh_token ? { refresh_token: parsed.authed_user.refresh_token } : {},
-                  ...parsed.authed_user.token_type ? { token_type: parsed.authed_user.token_type } : {},
-                  ...parsed.authed_user.scope ? { scope: parsed.authed_user.scope } : {},
-                  ...authedUserExpiresAt !== undefined ? { expires_at: authedUserExpiresAt } : {}
-                }
-              } : {}
-            }),
-            ...expiresAt !== undefined ? { expiresAt } : {},
-            metadata: {
-              provider: SLACK_SERVICE_NAME,
-              hasRefreshToken: Boolean(parsed.refresh_token ?? parsed.authed_user?.refresh_token),
-              hasAuthedUserToken: Boolean(parsed.authed_user?.access_token)
-            }
-          }
-        ]
-      });
-      const accountPatch = {
-        ...pendingAccount,
-        id: pendingAccount.id,
-        provider: SLACK_SERVICE_NAME,
-        status: "connected",
-        metadata: {
-          ...accountMetadata,
-          credentialRefs: credentialPersist.refs,
-          credentialRefStorage: {
-            vaultAvailable: credentialPersist.vaultAvailable,
-            storageAvailable: credentialPersist.storageAvailable
-          }
-        }
-      };
-      logger.info({
-        src: "plugin:slack:connector",
-        teamId,
-        teamName
-      }, "Slack OAuth completed");
-      return {
-        account: accountPatch,
-        flow: { status: "completed" }
-      };
-    }
-  };
-}
-
-// src/service.ts
-import {
-  ChannelType,
-  createUniqueUuid,
-  Service,
-  stringToUuid
-} from "@elizaos/core";
-import { App, LogLevel } from "@slack/bolt";
-
-// 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/service.ts
-var SLACK_CONNECTOR_CONTEXTS = ["social", "connectors"];
-var SLACK_CONNECTOR_CAPABILITIES = [
-  "send_message",
-  "read_messages",
-  "search_messages",
-  "resolve_targets",
-  "list_rooms",
-  "list_servers",
-  "chat_context",
-  "user_context",
-  "react_message",
-  "edit_message",
-  "delete_message",
-  "pin_message",
-  "get_user"
-];
-var SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{2,}$/i;
-function normalizeSlackConnectorQuery(value) {
-  return value.trim().replace(/^<#([A-Z0-9]+)(?:\|[^>]+)?>$/i, "$1").replace(/^<@([A-Z0-9]+)>$/i, "$1").replace(/^#/, "").replace(/^@/, "").toLowerCase();
-}
-function scoreSlackConnectorMatch(query, id, labels) {
-  if (!query) {
-    return 0.45;
-  }
-  if (id.toLowerCase() === query) {
-    return 1;
-  }
-  let bestScore = 0;
-  for (const label of labels) {
-    const normalized = label?.trim().toLowerCase();
-    if (!normalized) {
-      continue;
-    }
-    if (normalized === query) {
-      bestScore = Math.max(bestScore, 0.95);
-    } else if (normalized.startsWith(query)) {
-      bestScore = Math.max(bestScore, 0.85);
-    } else if (normalized.includes(query)) {
-      bestScore = Math.max(bestScore, 0.7);
-    }
-  }
-  return bestScore;
-}
-function extractSlackUserIdFromMetadata(metadata, accountId) {
-  if (!metadata || typeof metadata !== "object") {
-    return null;
-  }
-  const record = metadata;
-  const slack = record.slack && typeof record.slack === "object" ? record.slack : null;
-  const metadataAccountId = typeof record.accountId === "string" ? record.accountId : typeof slack?.accountId === "string" ? slack.accountId : undefined;
-  if (accountId && metadataAccountId && normalizeAccountId(metadataAccountId) !== normalizeAccountId(accountId)) {
-    return null;
-  }
-  const candidates = [
-    slack?.userId,
-    slack?.id,
-    record.slackUserId,
-    record.originalId
-  ];
-  for (const candidate of candidates) {
-    if (typeof candidate === "string" && SLACK_USER_ID_PATTERN.test(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-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;
-  defaultAccountId = DEFAULT_ACCOUNT_ID;
-  accountStates = new Map;
-  accountStarts = new Map;
-  allowedChannelIds = new Set;
-  dynamicChannelIds = new Set;
-  userCache = new Map;
-  channelCache = new Map;
-  isConnected = false;
-  constructor(runtime) {
-    super(runtime);
-    this.character = runtime.character;
-    this.settings = this.loadSettings();
-    this.allowedChannelIds = this.buildAllowedChannelSet();
-    if (this.allowedChannelIds.size > 0) {
-      this.runtime.logger.debug({
-        src: "plugin:slack",
-        agentId: this.runtime.agentId,
-        allowedChannelIds: Array.from(this.allowedChannelIds)
-      }, "Channel restrictions enabled");
-    }
-  }
-  loadSettings(account) {
-    const ignoreBotMessages = this.runtime.getSetting("SLACK_SHOULD_IGNORE_BOT_MESSAGES");
-    const respondOnlyToMentions = this.runtime.getSetting("SLACK_SHOULD_RESPOND_ONLY_TO_MENTIONS");
-    return {
-      allowedChannelIds: account?.config.allowedChannelIds,
-      shouldIgnoreBotMessages: account?.config.shouldIgnoreBotMessages ?? (ignoreBotMessages === "true" || ignoreBotMessages === true),
-      shouldRespondOnlyToMentions: account?.config.shouldRespondOnlyToMentions ?? (respondOnlyToMentions === "true" || respondOnlyToMentions === true)
-    };
-  }
-  buildAllowedChannelSet(account) {
-    const allowed = new Set;
-    const configuredIds = account?.config.allowedChannelIds;
-    const channelIdsRaw = configuredIds && configuredIds.length > 0 ? configuredIds.join(",") : this.runtime.getSetting("SLACK_CHANNEL_IDS");
-    if (!channelIdsRaw?.trim()) {
-      return allowed;
-    }
-    channelIdsRaw.split(",").map((s) => s.trim()).filter((s) => s.length > 0 && isValidChannelId(s)).forEach((id) => {
-      allowed.add(id);
-    });
-    return allowed;
-  }
-  static async start(runtime) {
-    const service = new SlackService(runtime);
-    const accounts = listEnabledSlackAccounts(runtime);
-    service.defaultAccountId = resolveDefaultSlackAccountId(runtime);
-    if (accounts.length === 0) {
-      runtime.logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "No enabled Slack accounts configured, Slack service will not start");
-      return service;
-    }
-    let startedAccounts = 0;
-    let lastError;
-    for (const account of accounts) {
-      if (!account.appToken?.trim()) {
-        runtime.logger.warn({
-          src: "plugin:slack",
-          agentId: runtime.agentId,
-          accountId: account.accountId
-        }, "SLACK_APP_TOKEN not provided for Slack account, Socket Mode will not work");
-        continue;
-      }
-      try {
-        await service.initializeAccount(account);
-        startedAccounts++;
-      } catch (error) {
-        lastError = error;
-        runtime.logger.error({
-          src: "plugin:slack",
-          agentId: runtime.agentId,
-          accountId: account.accountId,
-          error: error instanceof Error ? error.message : String(error)
-        }, "Failed to initialize Slack account");
-      }
-    }
-    if (startedAccounts === 0) {
-      if (lastError) {
-        throw lastError;
-      }
-      runtime.logger.warn({ src: "plugin:slack", agentId: runtime.agentId }, "Slack service started without connected accounts");
-    }
-    return service;
-  }
-  static async stop(runtime) {
-    const service = runtime.getService(SLACK_SERVICE_NAME);
-    if (service) {
-      await service.shutdown();
-    }
-  }
-  static registerSendHandlers(runtime, serviceInstance) {
-    if (!serviceInstance) {
-      return;
-    }
-    const registerConnector = (accountId) => {
-      const normalizedAccountId = accountId ? normalizeAccountId(accountId) : undefined;
-      const state = normalizedAccountId ? serviceInstance.getAccountState(normalizedAccountId) : serviceInstance.getDefaultAccountState();
-      const sendHandler = async (handlerRuntime, target, content) => {
-        await serviceInstance.handleSendMessage(handlerRuntime, normalizedAccountId && !target.accountId ? { ...target, accountId: normalizedAccountId } : target, content);
-      };
-      const withContextAccount = (context) => normalizedAccountId && !context.accountId ? {
-        ...context,
-        accountId: normalizedAccountId,
-        account: context.account ?? {
-          source: "slack",
-          accountId: normalizedAccountId,
-          label: state?.account.name ?? normalizedAccountId
-        }
-      } : context;
-      const registration = {
-        source: "slack",
-        ...normalizedAccountId ? { accountId: normalizedAccountId } : {},
-        ...normalizedAccountId ? {
-          account: {
-            source: "slack",
-            accountId: normalizedAccountId,
-            label: state?.account.name ?? normalizedAccountId,
-            authMethod: "BOT_TOKEN",
-            metadata: {
-              teamId: state?.teamId
-            }
-          }
-        } : {},
-        label: state?.account.name ? `Slack (${state.account.name})` : "Slack",
-        description: "Slack connector for sending, reading, searching, reacting to, editing, deleting, and pinning messages in channels, threads, and users.",
-        capabilities: [...SLACK_CONNECTOR_CAPABILITIES],
-        supportedTargetKinds: ["channel", "thread", "user"],
-        contexts: [...SLACK_CONNECTOR_CONTEXTS],
-        metadata: {
-          service: SLACK_SERVICE_NAME,
-          maxMessageLength: MAX_SLACK_MESSAGE_LENGTH,
-          ...normalizedAccountId ? { accountId: normalizedAccountId } : {}
-        },
-        resolveTargets: (query, context) => serviceInstance.resolveConnectorTargets(query, withContextAccount(context)),
-        listRecentTargets: (context) => serviceInstance.listRecentConnectorTargets(withContextAccount(context)),
-        listRooms: (context) => serviceInstance.listConnectorRooms(withContextAccount(context)),
-        listServers: (context) => serviceInstance.listConnectorServers(withContextAccount(context)),
-        fetchMessages: (context, params) => serviceInstance.fetchConnectorMessages(withContextAccount(context), {
-          ...params,
-          ...normalizedAccountId && !params.accountId ? { accountId: normalizedAccountId } : {}
-        }),
-        searchMessages: (context, params) => serviceInstance.searchConnectorMessages(withContextAccount(context), {
-          ...params,
-          ...normalizedAccountId && !params.accountId ? { accountId: normalizedAccountId } : {}
-        }),
-        reactHandler: (handlerRuntime, params) => serviceInstance.reactConnectorMessage(handlerRuntime, {
-          ...params,
-          ...normalizedAccountId && !params.accountId ? { accountId: normalizedAccountId } : {}
-        }),
-        editHandler: (handlerRuntime, params) => serviceInstance.editConnectorMessage(handlerRuntime, {
-          ...params,
-          ...normalizedAccountId && !params.accountId ? { accountId: normalizedAccountId } : {}
-        }),
-        deleteHandler: (handlerRuntime, params) => serviceInstance.deleteConnectorMessage(handlerRuntime, {
-          ...params,
-          ...normalizedAccountId && !params.accountId ? { accountId: normalizedAccountId } : {}
-        }),
-        pinHandler: (handlerRuntime, params) => serviceInstance.pinConnectorMessage(handlerRuntime, {
-          ...params,
-          ...normalizedAccountId && !params.accountId ? { accountId: normalizedAccountId } : {}
-        }),
-        getUser: (handlerRuntime, params) => serviceInstance.getConnectorUser(handlerRuntime, {
-          ...params,
-          ...normalizedAccountId && !params.target ? {
-            target: {
-              source: "slack",
-              accountId: normalizedAccountId
-            }
-          } : {}
-        }),
-        getChatContext: (target, context) => serviceInstance.getConnectorChatContext(normalizedAccountId && !target.accountId ? { ...target, accountId: normalizedAccountId } : target, withContextAccount(context)),
-        getUserContext: (entityId, context) => serviceInstance.getConnectorUserContext(entityId, withContextAccount(context)),
-        sendHandler
-      };
-      runtime.registerMessageConnector(registration);
-    };
-    if (typeof runtime.registerMessageConnector === "function") {
-      registerConnector();
-      for (const accountId of serviceInstance.getRegisteredAccountIds()) {
-        registerConnector(accountId);
-      }
-      runtime.logger.info({ src: "plugin:slack", agentId: runtime.agentId }, "Registered Slack message connector");
-      return;
-    }
-    runtime.registerSendHandler("slack", serviceInstance.handleSendMessage.bind(serviceInstance));
-    runtime.logger.info({ src: "plugin:slack", agentId: runtime.agentId }, "Registered Slack send handler");
-  }
-  async stop() {
-    await this.shutdown();
-  }
-  syncDefaultAccountAliases() {
-    const state = this.getDefaultAccountState();
-    this.app = state?.app ?? null;
-    this.client = state?.client ?? null;
-    this.botUserId = state?.botUserId ?? null;
-    this.teamId = state?.teamId ?? null;
-    this.botToken = state?.account.botToken ?? null;
-    this.appToken = state?.account.appToken ?? null;
-    this.signingSecret = state?.account.signingSecret ?? null;
-    this.isConnected = Array.from(this.accountStates?.values?.() ?? []).some((accountState) => accountState.isConnected);
-  }
-  async initializeAccount(account) {
-    const accountId = normalizeAccountId(account.accountId);
-    const cached = this.accountStates.get(accountId);
-    if (cached) {
-      return cached;
-    }
-    const starting = this.accountStarts.get(accountId);
-    if (starting) {
-      return starting;
-    }
-    const startPromise = (async () => {
-      if (!account.botToken || !account.appToken) {
-        throw new Error(`Slack account ${accountId} requires bot and app tokens`);
-      }
-      this.runtime.logger.info({ src: "plugin:slack", agentId: this.runtime.agentId, accountId }, "Initializing Slack service with Socket Mode");
-      const app = new App({
-        token: account.botToken,
-        appToken: account.appToken,
-        socketMode: true,
-        logLevel: LogLevel.INFO,
-        ...account.signingSecret ? { signingSecret: account.signingSecret } : {}
-      });
-      const state = {
-        accountId,
-        account,
-        app,
-        client: app.client,
-        botUserId: null,
-        teamId: null,
-        settings: this.loadSettings(account),
-        allowedChannelIds: this.buildAllowedChannelSet(account),
-        dynamicChannelIds: new Set,
-        userCache: new Map,
-        channelCache: new Map,
-        isConnected: false
-      };
-      const authResult = await state.client.auth.test();
-      state.botUserId = authResult.user_id;
-      state.teamId = authResult.team_id;
-      this.accountStates.set(accountId, state);
-      this.syncDefaultAccountAliases();
-      this.runtime.logger.info({
-        src: "plugin:slack",
-        agentId: this.runtime.agentId,
-        accountId,
-        botUserId: state.botUserId,
-        teamId: state.teamId
-      }, "Slack bot authenticated");
-      this.registerEventHandlers(state);
-      try {
-        await app.start();
-      } catch (error) {
-        this.accountStates.delete(accountId);
-        this.syncDefaultAccountAliases();
-        throw error;
-      }
-      state.isConnected = true;
-      this.syncDefaultAccountAliases();
-      this.runtime.logger.info({ src: "plugin:slack", agentId: this.runtime.agentId, accountId }, "Slack account started successfully");
-      await this.ensureWorkspaceExists(accountId);
-      return state;
-    })();
-    this.accountStarts.set(accountId, startPromise);
-    try {
-      return await startPromise;
-    } finally {
-      this.accountStarts.delete(accountId);
-    }
-  }
-  async shutdown() {
-    const states = this.accountStates instanceof Map ? Array.from(this.accountStates.values()) : [];
-    if (states.length > 0) {
-      for (const state of states) {
-        await state.app.stop();
-        state.isConnected = false;
-        this.runtime.logger.info({
-          src: "plugin:slack",
-          agentId: this.runtime.agentId,
-          accountId: state.accountId
-        }, "Slack account stopped");
-      }
-      this.accountStates.clear();
-      this.syncDefaultAccountAliases();
-      return;
-    }
-    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(state) {
-    const app = state?.app ?? this.app;
-    const accountId = state?.accountId ?? this.defaultAccountId;
-    if (!app)
-      return;
-    app.message(async ({ message, client }) => {
-      await this.handleMessage(message, client, accountId);
-    });
-    app.event("app_mention", async ({ event, client }) => {
-      await this.handleAppMention(event, client, accountId);
-    });
-    app.event("reaction_added", async ({ event }) => {
-      await this.handleReactionAdded(event, accountId);
-    });
-    app.event("reaction_removed", async ({ event }) => {
-      await this.handleReactionRemoved(event, accountId);
-    });
-    app.event("member_joined_channel", async ({ event }) => {
-      await this.handleMemberJoinedChannel(event, accountId);
-    });
-    app.event("member_left_channel", async ({ event }) => {
-      await this.handleMemberLeftChannel(event, accountId);
-    });
-    app.event("file_shared", async ({ event }) => {
-      await this.handleFileShared(event, accountId);
-    });
-  }
-  getDefaultAccountState() {
-    const states = this.accountStates;
-    if (!(states instanceof Map) || states.size === 0) {
-      return null;
-    }
-    const defaultId = normalizeAccountId(this.defaultAccountId ?? DEFAULT_ACCOUNT_ID);
-    return states.get(defaultId) ?? states.values().next().value ?? null;
-  }
-  getAccountState(accountId) {
-    const states = this.accountStates;
-    if (!(states instanceof Map) || states.size === 0) {
-      return null;
-    }
-    if (accountId) {
-      return states.get(normalizeAccountId(accountId)) ?? null;
-    }
-    return this.getDefaultAccountState();
-  }
-  getClientForAccount(accountId) {
-    const state = this.getAccountState(accountId);
-    if (state?.client) {
-      return state.client;
-    }
-    const requested = accountId ? normalizeAccountId(accountId) : null;
-    const defaultId = normalizeAccountId(this.defaultAccountId ?? DEFAULT_ACCOUNT_ID);
-    if (!requested || requested === defaultId) {
-      return this.client;
-    }
-    return null;
-  }
-  getSettingsForAccount(accountId) {
-    return this.getAccountState(accountId)?.settings ?? this.settings;
-  }
-  getAllowedChannelIdsForAccount(accountId) {
-    return this.getAccountState(accountId)?.allowedChannelIds ?? this.allowedChannelIds;
-  }
-  getDynamicChannelIdsForAccount(accountId) {
-    return this.getAccountState(accountId)?.dynamicChannelIds ?? this.dynamicChannelIds;
-  }
-  getUserCacheForAccount(accountId) {
-    return this.getAccountState(accountId)?.userCache ?? this.userCache;
-  }
-  getChannelCacheForAccount(accountId) {
-    return this.getAccountState(accountId)?.channelCache ?? this.channelCache;
-  }
-  getBotUserIdForAccount(accountId) {
-    return this.getAccountState(accountId)?.botUserId ?? this.botUserId;
-  }
-  getTeamIdForAccount(accountId) {
-    return this.getAccountState(accountId)?.teamId ?? this.teamId;
-  }
-  getRegisteredAccountIds() {
-    const states = this.accountStates;
-    if (states instanceof Map && states.size > 0) {
-      return Array.from(states.keys());
-    }
-    return [normalizeAccountId(this.defaultAccountId ?? DEFAULT_ACCOUNT_ID)];
-  }
-  resolveAccountIdFromContext(context, target) {
-    const scopedTarget = target;
-    const scopedContext = context;
-    return scopedTarget?.accountId ?? scopedContext?.target?.accountId ?? scopedContext?.accountId ?? scopedContext?.account?.accountId ?? undefined;
-  }
-  async resolveAccountIdForTarget(runtime, target, fallback) {
-    const direct = target?.accountId ?? fallback?.accountId ?? undefined;
-    if (direct) {
-      return normalizeAccountId(direct);
-    }
-    const roomId = target?.roomId ?? fallback?.roomId;
-    if (roomId && typeof runtime.getRoom === "function") {
-      const room = await runtime.getRoom(roomId);
-      const metadata = room?.metadata;
-      if (typeof metadata?.accountId === "string" && metadata.accountId.trim()) {
-        return normalizeAccountId(metadata.accountId);
-      }
-      const slack = metadata?.slack && typeof metadata.slack === "object" ? metadata.slack : undefined;
-      if (typeof slack?.accountId === "string" && slack.accountId.trim()) {
-        return normalizeAccountId(slack.accountId);
-      }
-    }
-    return normalizeAccountId(this.defaultAccountId ?? DEFAULT_ACCOUNT_ID);
-  }
-  getCandidateAccountIds(context, target) {
-    const explicit = this.resolveAccountIdFromContext(context, target);
-    if (explicit) {
-      return [normalizeAccountId(explicit)];
-    }
-    return this.getRegisteredAccountIds();
-  }
-  scopedSlackKey(prefix, key, accountId) {
-    const normalized = normalizeAccountId(accountId ?? this.defaultAccountId ?? DEFAULT_ACCOUNT_ID);
-    return normalized === DEFAULT_ACCOUNT_ID ? `${prefix}-${key}` : `${prefix}-${normalized}-${key}`;
-  }
-  buildEventPayload(accountId) {
-    const normalized = normalizeAccountId(accountId ?? this.defaultAccountId ?? DEFAULT_ACCOUNT_ID);
-    return {
-      runtime: this.runtime,
-      source: "slack",
-      accountId: normalized,
-      metadata: { accountId: normalized }
-    };
-  }
-  async handleMessage(message, _client, accountId = this.defaultAccountId) {
-    const settings = this.getSettingsForAccount(accountId);
-    const botUserId = this.getBotUserIdForAccount(accountId);
-    if (settings.shouldIgnoreBotMessages && message.bot_id) {
-      return;
-    }
-    if (message.user === botUserId) {
-      return;
-    }
-    if (!this.isChannelAllowed(message.channel, accountId)) {
-      this.runtime.logger.debug({
-        src: "plugin:slack",
-        agentId: this.runtime.agentId,
-        accountId,
-        channelId: message.channel
-      }, "Message received in non-allowed channel, ignoring");
-      return;
-    }
-    const isMentioned = message.text?.includes(`<@${botUserId}>`);
-    if (isMentioned && message.channel_type !== "im") {
-      return;
-    }
-    if (settings.shouldRespondOnlyToMentions && !isMentioned) {
-      return;
-    }
-    const _isThreadReply = Boolean(message.thread_ts && message.thread_ts !== message.ts);
-    const memory = await this.buildMemoryFromMessage(message, accountId);
-    if (!memory)
-      return;
-    const room = await this.ensureRoomExists(message.channel, message.thread_ts, accountId);
-    const existingEntity = await this.runtime.getEntityById(memory.entityId);
-    if (!existingEntity) {
-      const user = await this.getUser(message.user, accountId);
-      const displayName = user ? getSlackUserDisplayName(user) : message.user;
-      await this.runtime.createEntity({
-        id: memory.entityId,
-        names: [displayName],
-        metadata: {
-          source: "slack",
-          accountId,
-          slack: {
-            accountId,
-            id: message.user,
-            name: displayName,
-            userName: user?.name || message.user
-          }
-        },
-        agentId: this.runtime.agentId
-      });
-    }
-    await this.runtime.createMemory(memory, "messages");
-    await this.runtime.emitEvent("SLACK_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, this.buildEventPayload(accountId));
-    await this.processAgentMessage(memory, room, message.channel, message.thread_ts || message.ts, accountId);
-  }
-  async handleAppMention(event, _client, accountId = this.defaultAccountId) {
-    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
-    }, accountId);
-    if (!memory)
-      return;
-    const room = await this.ensureRoomExists(event.channel, event.thread_ts, accountId);
-    const existingEntity = await this.runtime.getEntityById(memory.entityId);
-    if (!existingEntity) {
-      const user = await this.getUser(event.user, accountId);
-      const displayName = user ? getSlackUserDisplayName(user) : event.user;
-      await this.runtime.createEntity({
-        id: memory.entityId,
-        names: [displayName],
-        metadata: {
-          source: "slack",
-          accountId,
-          slack: {
-            accountId,
-            id: event.user,
-            name: displayName,
-            userName: user?.name || event.user
-          }
-        },
-        agentId: this.runtime.agentId
-      });
-    }
-    await this.runtime.createMemory(memory, "messages");
-    await this.runtime.emitEvent("SLACK_APP_MENTION" /* APP_MENTION */, this.buildEventPayload(accountId));
-    await this.processAgentMessage(memory, room, event.channel, event.thread_ts || event.ts, accountId);
-  }
-  async handleReactionAdded(_event, accountId = this.defaultAccountId) {
-    await this.runtime.emitEvent("SLACK_REACTION_ADDED" /* REACTION_ADDED */, this.buildEventPayload(accountId));
-  }
-  async handleReactionRemoved(_event, accountId = this.defaultAccountId) {
-    await this.runtime.emitEvent("SLACK_REACTION_REMOVED" /* REACTION_REMOVED */, this.buildEventPayload(accountId));
-  }
-  async handleMemberJoinedChannel(event, accountId = this.defaultAccountId) {
-    if (event.user === this.getBotUserIdForAccount(accountId)) {
-      this.getDynamicChannelIdsForAccount(accountId).add(event.channel);
-      await this.ensureRoomExists(event.channel, undefined, accountId);
-    }
-    await this.runtime.emitEvent("SLACK_MEMBER_JOINED_CHANNEL" /* MEMBER_JOINED_CHANNEL */, this.buildEventPayload(accountId));
-  }
-  async handleMemberLeftChannel(event, accountId = this.defaultAccountId) {
-    if (event.user === this.getBotUserIdForAccount(accountId)) {
-      this.getDynamicChannelIdsForAccount(accountId).delete(event.channel);
-    }
-    await this.runtime.emitEvent("SLACK_MEMBER_LEFT_CHANNEL" /* MEMBER_LEFT_CHANNEL */, this.buildEventPayload(accountId));
-  }
-  async handleFileShared(_event, accountId = this.defaultAccountId) {
-    await this.runtime.emitEvent("SLACK_FILE_SHARED" /* FILE_SHARED */, this.buildEventPayload(accountId));
-  }
-  isChannelAllowed(channelId, accountId) {
-    const allowedChannelIds = this.getAllowedChannelIdsForAccount(accountId);
-    const dynamicChannelIds = this.getDynamicChannelIdsForAccount(accountId);
-    if (allowedChannelIds.size === 0 && dynamicChannelIds.size === 0) {
-      return true;
-    }
-    return allowedChannelIds.has(channelId) || dynamicChannelIds.has(channelId);
-  }
-  async processAgentMessage(memory, room, channelId, threadTs, accountId = this.defaultAccountId) {
-    const callback = async (response) => {
-      const responseText = response.text || "";
-      if (!responseText.trim()) {
-        this.runtime.logger.warn({ src: "plugin:slack", channelId, roomId: room.id }, "Empty response from model, skipping sendMessage");
-        return [];
-      }
-      await this.sendMessage(channelId, responseText, {
-        threadTs,
-        replyBroadcast: undefined,
-        unfurlLinks: undefined,
-        unfurlMedia: undefined,
-        mrkdwn: undefined,
-        attachments: undefined,
-        blocks: undefined
-      }, accountId);
-      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,
-          metadata: { accountId }
-        },
-        metadata: {
-          type: "message",
-          source: "slack",
-          provider: "slack",
-          accountId,
-          fromBot: true,
-          fromId: this.runtime.agentId,
-          sourceId: this.runtime.agentId,
-          slack: {
-            accountId,
-            channelId,
-            threadTs
-          }
-        },
-        createdAt: Date.now()
-      };
-      await this.runtime.createMemory(responseMemory, "messages");
-      await this.runtime.emitEvent("SLACK_MESSAGE_SENT" /* MESSAGE_SENT */, this.buildEventPayload(accountId));
-      return [responseMemory];
-    };
-    const messageService = getMessageService(this.runtime);
-    if (messageService) {
-      await messageService.handleMessage(this.runtime, memory, callback);
-    }
-  }
-  async buildMemoryFromMessage(message, accountId = this.defaultAccountId) {
-    if (!message.user)
-      return null;
-    const roomId = await this.getRoomId(message.channel, message.thread_ts, accountId);
-    const entityId = this.getEntityId(message.user, accountId);
-    const user = await this.getUser(message.user, accountId);
-    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, this.scopedSlackKey("slack", message.ts, accountId)),
-      agentId: this.runtime.agentId,
-      roomId,
-      entityId,
-      content: {
-        text: message.text || "",
-        source: "slack",
-        name: displayName,
-        metadata: { accountId },
-        ...media.length > 0 ? { attachments: media } : {}
-      },
-      metadata: {
-        type: "message",
-        source: "slack",
-        provider: "slack",
-        accountId,
-        timestamp: this.parseSlackTimestamp(message.ts),
-        entityName: displayName,
-        entityUserName: user?.name ?? message.user,
-        fromBot: false,
-        fromId: message.user,
-        sourceId: entityId,
-        chatType: message.channel_type,
-        messageIdFull: message.ts,
-        sender: {
-          id: message.user,
-          name: displayName,
-          username: user?.name ?? message.user
-        },
-        slack: {
-          accountId,
-          teamId: this.getTeamIdForAccount(accountId) ?? undefined,
-          channelId: message.channel,
-          userId: message.user,
-          messageId: message.ts,
-          threadTs: message.thread_ts
-        },
-        slackChannelId: message.channel,
-        slackMessageTs: message.ts,
-        slackThreadTs: message.thread_ts
-      },
-      createdAt: this.parseSlackTimestamp(message.ts)
-    };
-    return memory;
-  }
-  async buildMemoryFromMention(event, accountId = this.defaultAccountId) {
-    const roomId = await this.getRoomId(event.channel, event.thread_ts, accountId);
-    const entityId = this.getEntityId(event.user, accountId);
-    const user = await this.getUser(event.user, accountId);
-    const displayName = user ? getSlackUserDisplayName(user) : event.user;
-    const cleanText = event.text.replace(`<@${this.getBotUserIdForAccount(accountId)}>`, "").trim();
-    const memory = {
-      id: createUniqueUuid(this.runtime, this.scopedSlackKey("slack-mention", event.ts, accountId)),
-      agentId: this.runtime.agentId,
-      roomId,
-      entityId,
-      content: {
-        text: cleanText,
-        source: "slack",
-        name: displayName,
-        metadata: { accountId },
-        mentionContext: { isMention: true, isReply: false, isThread: false }
-      },
-      metadata: {
-        type: "message",
-        source: "slack",
-        provider: "slack",
-        accountId,
-        timestamp: this.parseSlackTimestamp(event.ts),
-        entityName: displayName,
-        entityUserName: user?.name ?? event.user,
-        fromBot: false,
-        fromId: event.user,
-        sourceId: entityId,
-        messageIdFull: event.ts,
-        slack: {
-          accountId,
-          teamId: this.getTeamIdForAccount(accountId) ?? undefined,
-          channelId: event.channel,
-          userId: event.user,
-          messageId: event.ts,
-          threadTs: event.thread_ts
-        },
-        slackChannelId: event.channel,
-        slackMessageTs: event.ts,
-        slackThreadTs: event.thread_ts
-      },
-      createdAt: this.parseSlackTimestamp(event.ts)
-    };
-    return memory;
-  }
-  async getRoomId(channelId, threadTs, accountId) {
-    const roomKey = threadTs ? `${channelId}-${threadTs}` : channelId;
-    return createUniqueUuid(this.runtime, this.scopedSlackKey("slack-room", roomKey, accountId));
-  }
-  getEntityId(userId, accountId) {
-    return stringToUuid(this.scopedSlackKey("slack-user", userId, accountId));
-  }
-  parseSlackTimestamp(ts) {
-    const [seconds] = ts.split(".");
-    return parseInt(seconds, 10) * 1000;
-  }
-  async ensureWorkspaceExists(accountId = this.defaultAccountId) {
-    const teamId = this.getTeamIdForAccount(accountId);
-    const client = this.getClientForAccount(accountId);
-    if (!teamId || !client)
-      return;
-    const worldId = createUniqueUuid(this.runtime, this.scopedSlackKey("slack-workspace", teamId, accountId));
-    const existingWorld = await this.runtime.getWorld(worldId);
-    if (existingWorld)
-      return;
-    const teamInfo = await client.team.info();
-    const team = teamInfo.team;
-    const world = {
-      id: worldId,
-      name: team?.name || `Slack Workspace ${teamId}`,
-      agentId: this.runtime.agentId,
-      metadata: {
-        type: "slack",
-        source: "slack",
-        accountId,
-        extra: {
-          accountId,
-          teamId,
-          domain: team?.domain
-        }
-      }
-    };
-    await this.runtime.createWorld(world);
-    this.runtime.logger.info({
-      src: "plugin:slack",
-      agentId: this.runtime.agentId,
-      accountId,
-      worldId,
-      teamId
-    }, "Created Slack workspace world");
-  }
-  async ensureRoomExists(channelId, threadTs, accountId = this.defaultAccountId) {
-    const roomId = await this.getRoomId(channelId, threadTs, accountId);
-    const existingRoom = await this.runtime.getRoom(roomId);
-    if (existingRoom)
-      return existingRoom;
-    const channel = await this.getChannel(channelId, accountId);
-    const channelType = channel ? getSlackChannelType(channel) : "channel";
-    const teamId = this.getTeamIdForAccount(accountId);
-    const worldId = teamId ? createUniqueUuid(this.runtime, this.scopedSlackKey("slack-workspace", teamId, accountId)) : 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: {
-        source: "slack",
-        accountId,
-        slackChannelType: channelType,
-        threadTs,
-        topic: channel?.topic?.value,
-        purpose: channel?.purpose?.value,
-        serverId: teamId,
-        slack: {
-          accountId,
-          teamId,
-          channelId,
-          threadTs
-        }
-      }
-    };
-    await this.runtime.createRoom(room);
-    this.runtime.logger.debug({
-      src: "plugin:slack",
-      agentId: this.runtime.agentId,
-      accountId,
-      roomId,
-      channelId,
-      threadTs
-    }, "Created Slack room");
-    return room;
-  }
-  buildConnectorChannelTarget(channel, score = 0.5, accountId = this.defaultAccountId) {
-    if (!channel.id || channel.isArchived) {
-      return null;
-    }
-    if (!this.isChannelAllowed(channel.id, accountId)) {
-      return null;
-    }
-    const kind = channel.isIm ? "user" : channel.isMpim ? "group" : "channel";
-    const label = channel.name ? `#${channel.name}` : channel.id;
-    const teamId = this.getTeamIdForAccount(accountId);
-    return {
-      target: {
-        source: "slack",
-        accountId,
-        channelId: channel.id,
-        serverId: teamId ?? undefined
-      },
-      label,
-      kind,
-      description: channel.purpose?.value || channel.topic?.value || label,
-      score,
-      contexts: ["social", "connectors"],
-      metadata: {
-        accountId,
-        slackChannelId: channel.id,
-        slackTeamId: teamId,
-        slackChannelType: getSlackChannelType(channel),
-        channelName: channel.name,
-        isPrivate: channel.isPrivate,
-        isMember: channel.isMember,
-        topic: channel.topic?.value,
-        purpose: channel.purpose?.value
-      }
-    };
-  }
-  buildConnectorUserTarget(user, score = 0.5, accountId = this.defaultAccountId) {
-    if (!user.id || user.deleted || user.isBot || user.isAppUser) {
-      return null;
-    }
-    const label = getSlackUserDisplayName(user);
-    return {
-      target: {
-        source: "slack",
-        accountId,
-        entityId: user.id,
-        serverId: user.teamId ?? this.getTeamIdForAccount(accountId) ?? undefined
-      },
-      label: `@${label}`,
-      kind: "user",
-      description: user.profile.title || "Slack user",
-      score,
-      contexts: ["social", "connectors"],
-      metadata: {
-        accountId,
-        slackUserId: user.id,
-        slackTeamId: user.teamId ?? this.getTeamIdForAccount(accountId),
-        slackName: user.name,
-        slackRealName: user.realName,
-        slackDisplayName: user.profile.displayName,
-        email: user.profile.email
-      }
-    };
-  }
-  dedupeConnectorTargets(targets) {
-    const byKey = new Map;
-    for (const target of targets) {
-      const key = [
-        target.target.accountId ?? "",
-        target.kind ?? "target",
-        target.target.channelId ?? "",
-        target.target.entityId ?? "",
-        target.target.threadId ?? ""
-      ].join(":");
-      const existing = byKey.get(key);
-      if (!existing || (target.score ?? 0) > (existing.score ?? 0)) {
-        byKey.set(key, target);
-      }
-    }
-    return Array.from(byKey.values()).sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
-  }
-  async resolveSlackTargetUserId(runtime, entityId, accountId) {
-    if (SLACK_USER_ID_PATTERN.test(entityId)) {
-      return entityId;
-    }
-    const entity = typeof runtime.getEntityById === "function" ? await runtime.getEntityById(entityId) : null;
-    const metadataUserId = extractSlackUserIdFromMetadata(entity?.metadata, accountId);
-    if (metadataUserId) {
-      return metadataUserId;
-    }
-    if (typeof runtime.getRelationships !== "function") {
-      return null;
-    }
-    const relationships = await runtime.getRelationships({
-      entityIds: [entityId],
-      tags: ["identity_link"]
-    });
-    for (const relationship of relationships) {
-      const linkedEntityId = relationship.sourceEntityId === entityId ? relationship.targetEntityId : relationship.targetEntityId === entityId ? relationship.sourceEntityId : null;
-      if (!linkedEntityId || linkedEntityId === entityId) {
-        continue;
-      }
-      const linkedEntity = typeof runtime.getEntityById === "function" ? await runtime.getEntityById(linkedEntityId) : null;
-      const linkedUserId = extractSlackUserIdFromMetadata(linkedEntity?.metadata, accountId);
-      if (linkedUserId) {
-        return linkedUserId;
-      }
-    }
-    return null;
-  }
-  async openDirectMessageChannel(userId, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    const result = await client.conversations.open({ users: userId });
-    const channel = result.channel;
-    if (!channel?.id) {
-      throw new Error(`Could not open Slack DM channel for user ${userId}`);
-    }
-    return channel.id;
-  }
-  async handleSendMessage(runtime, target, content) {
-    const accountId = await this.resolveAccountIdForTarget(runtime, target);
-    if (!this.getClientForAccount(accountId)) {
-      throw new Error("Slack client not initialized");
-    }
-    const text = typeof content.text === "string" ? content.text.trim() : "";
-    if (!text) {
-      throw new Error("Slack SendHandler requires non-empty text content.");
-    }
-    let channelId = target.channelId;
-    let threadTs = target.threadId;
-    if (target.roomId && (!channelId || !threadTs)) {
-      const room = await runtime.getRoom(target.roomId);
-      channelId = channelId ?? room?.channelId;
-      const metadata = room?.metadata;
-      const metadataThreadTs = typeof metadata?.threadTs === "string" ? metadata.threadTs : undefined;
-      threadTs = threadTs ?? metadataThreadTs;
-    }
-    if (channelId && SLACK_USER_ID_PATTERN.test(channelId)) {
-      channelId = await this.openDirectMessageChannel(channelId, accountId);
-    }
-    if (!channelId && target.entityId) {
-      const slackUserId = await this.resolveSlackTargetUserId(runtime, String(target.entityId), accountId);
-      if (!slackUserId) {
-        throw new Error(`Could not resolve Slack user ID for entity ${target.entityId}`);
-      }
-      channelId = await this.openDirectMessageChannel(slackUserId, accountId);
-    }
-    if (!channelId) {
-      throw new Error("Slack SendHandler requires channelId, roomId, or entityId.");
-    }
-    await this.sendMessage(channelId, text, {
-      threadTs,
-      replyBroadcast: undefined,
-      unfurlLinks: undefined,
-      unfurlMedia: undefined,
-      mrkdwn: undefined,
-      attachments: undefined,
-      blocks: undefined
-    }, accountId);
-  }
-  async resolveConnectorTargets(query, context) {
-    const normalizedQuery = normalizeSlackConnectorQuery(query);
-    const targets = [];
-    const accountIds = this.getCandidateAccountIds(context, context.target);
-    for (const accountId of accountIds) {
-      const client = this.getClientForAccount(accountId);
-      if (!client) {
-        continue;
-      }
-      try {
-        const channels = await this.listChannels({
-          types: "public_channel,private_channel,mpim,im",
-          limit: 1000
-        }, accountId);
-        for (const channel of channels) {
-          const score = scoreSlackConnectorMatch(normalizedQuery, channel.id, [
-            channel.name,
-            channel.topic?.value,
-            channel.purpose?.value
-          ]);
-          if (score <= 0) {
-            continue;
-          }
-          const target = this.buildConnectorChannelTarget(channel, score, accountId);
-          if (target) {
-            targets.push(target);
-          }
-        }
-      } catch (error) {
-        this.runtime.logger.debug({
-          src: "plugin:slack",
-          agentId: this.runtime.agentId,
-          accountId,
-          error: error instanceof Error ? error.message : String(error)
-        }, "Slack connector channel query failed");
-      }
-      try {
-        const usersResult = await client.users.list({ limit: 200 });
-        const members = usersResult.members ?? [];
-        for (const member of members) {
-          const user = {
-            id: member.id ?? "",
-            teamId: member.team_id,
-            name: member.name ?? "",
-            deleted: Boolean(member.deleted),
-            realName: member.real_name,
-            tz: member.tz,
-            tzLabel: member.tz_label,
-            tzOffset: member.tz_offset,
-            profile: {
-              title: member.profile?.title,
-              phone: member.profile?.phone,
-              skype: member.profile?.skype,
-              realName: member.profile?.real_name,
-              realNameNormalized: member.profile?.real_name_normalized,
-              displayName: member.profile?.display_name,
-              displayNameNormalized: member.profile?.display_name_normalized,
-              statusText: member.profile?.status_text,
-              statusEmoji: member.profile?.status_emoji,
-              statusExpiration: member.profile?.status_expiration,
-              avatarHash: member.profile?.avatar_hash,
-              email: member.profile?.email,
-              image24: member.profile?.image_24,
-              image32: member.profile?.image_32,
-              image48: member.profile?.image_48,
-              image72: member.profile?.image_72,
-              image192: member.profile?.image_192,
-              image512: member.profile?.image_512,
-              image1024: member.profile?.image_1024,
-              imageOriginal: member.profile?.image_original,
-              team: member.profile?.team
-            },
-            isAdmin: Boolean(member.is_admin),
-            isOwner: Boolean(member.is_owner),
-            isPrimaryOwner: Boolean(member.is_primary_owner),
-            isRestricted: Boolean(member.is_restricted),
-            isUltraRestricted: Boolean(member.is_ultra_restricted),
-            isBot: Boolean(member.is_bot),
-            isAppUser: Boolean(member.is_app_user),
-            updated: member.updated ?? 0
-          };
-          const score = scoreSlackConnectorMatch(normalizedQuery, user.id, [
-            user.name,
-            user.realName,
-            user.profile.displayName,
-            user.profile.realName,
-            user.profile.email
-          ]);
-          if (score <= 0) {
-            continue;
-          }
-          const target = this.buildConnectorUserTarget(user, score, accountId);
-          if (target) {
-            targets.push(target);
-          }
-        }
-      } catch (error) {
-        this.runtime.logger.debug({
-          src: "plugin:slack",
-          agentId: this.runtime.agentId,
-          accountId,
-          error: error instanceof Error ? error.message : String(error)
-        }, "Slack connector user query failed");
-      }
-      if (context.target?.channelId) {
-        const channel = await this.getChannel(context.target.channelId, accountId);
-        if (channel) {
-          const target = this.buildConnectorChannelTarget(channel, 0.6, accountId);
-          if (target) {
-            targets.push(target);
-          }
-        }
-      }
-    }
-    return this.dedupeConnectorTargets(targets).slice(0, 25);
-  }
-  async listConnectorRooms(context) {
-    const targets = [];
-    for (const accountId of this.getCandidateAccountIds(context)) {
-      if (!this.getClientForAccount(accountId)) {
-        continue;
-      }
-      const channels = await this.listChannels({
-        types: "public_channel,private_channel,mpim,im",
-        limit: 1000
-      }, accountId);
-      targets.push(...channels.map((channel) => this.buildConnectorChannelTarget(channel, 0.5, accountId)).filter((target) => Boolean(target)));
-    }
-    return this.dedupeConnectorTargets(targets).slice(0, 50);
-  }
-  async listRecentConnectorTargets(context) {
-    const targets = [];
-    const room = context.roomId && typeof context.runtime.getRoom === "function" ? await context.runtime.getRoom(context.roomId) : null;
-    const accountId = await this.resolveAccountIdForTarget(context.runtime, context.target, {
-      accountId: context.accountId,
-      roomId: context.roomId
-    });
-    const channelId = context.target?.channelId ?? (room?.source === "slack" ? room.channelId : undefined);
-    const roomMetadata = room?.metadata;
-    const threadTs = context.target?.threadId ?? (typeof roomMetadata?.threadTs === "string" ? roomMetadata.threadTs : undefined);
-    if (channelId) {
-      const channel = await this.getChannel(channelId, accountId);
-      if (channel) {
-        const target = this.buildConnectorChannelTarget(channel, 0.95, accountId);
-        if (target) {
-          if (threadTs) {
-            target.kind = "thread";
-            target.target.threadId = threadTs;
-            target.label = `${target.label ?? channelId} thread`;
-            target.metadata = {
-              ...target.metadata ?? {},
-              slackThreadTs: threadTs
-            };
-          }
-          targets.push(target);
-        }
-      }
-    }
-    targets.push(...await this.listConnectorRooms({
-      ...context,
-      accountId
-    }));
-    return this.dedupeConnectorTargets(targets).slice(0, 25);
-  }
-  async getConnectorChatContext(target, context) {
-    const accountId = await this.resolveAccountIdForTarget(context.runtime, target, {
-      accountId: context.accountId,
-      roomId: context.roomId
-    });
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      return null;
-    }
-    const room = target.roomId && typeof context.runtime.getRoom === "function" ? await context.runtime.getRoom(target.roomId) : null;
-    const channelId = target.channelId ?? room?.channelId;
-    if (!channelId) {
-      return null;
-    }
-    const metadata = room?.metadata;
-    const threadTs = target.threadId ?? (typeof metadata?.threadTs === "string" ? metadata.threadTs : undefined);
-    const channel = await this.getChannel(channelId, accountId);
-    const messages = threadTs ? await client.conversations.replies({
-      channel: channelId,
-      ts: threadTs,
-      limit: 10
-    }) : {
-      messages: await this.readHistory(channelId, { limit: 10 }, accountId)
-    };
-    const rawMessages = messages.messages ?? [];
-    const recentMessages = [];
-    for (const rawMessage of rawMessages.slice().reverse()) {
-      const text = String(rawMessage.text ?? "");
-      if (!text.trim()) {
-        continue;
-      }
-      const userId = rawMessage.user ?? rawMessage.user;
-      const user = typeof userId === "string" ? await this.getUser(userId, accountId) : null;
-      recentMessages.push({
-        entityId: userId ? userId : undefined,
-        name: user ? getSlackUserDisplayName(user) : userId,
-        text,
-        timestamp: Number(rawMessage.ts) * 1000 || undefined,
-        metadata: {
-          accountId,
-          slackMessageTs: rawMessage.ts,
-          slackUserId: userId
-        }
-      });
-    }
-    return {
-      target: {
-        source: "slack",
-        accountId,
-        roomId: target.roomId ?? room?.id,
-        channelId,
-        serverId: target.serverId ?? this.getTeamIdForAccount(accountId) ?? undefined,
-        threadId: threadTs
-      },
-      label: channel?.name ? `#${channel.name}` : channelId,
-      summary: channel?.purpose?.value || channel?.topic?.value,
-      recentMessages,
-      metadata: {
-        accountId,
-        slackChannelId: channelId,
-        slackTeamId: this.getTeamIdForAccount(accountId),
-        slackThreadTs: threadTs,
-        channelName: channel?.name
-      }
-    };
-  }
-  async resolveConnectorMessageLocation(target, fallback) {
-    const accountId = await this.resolveAccountIdForTarget(this.runtime, target, fallback);
-    let channelId = target?.channelId ?? fallback?.channelId;
-    let threadTs = target?.threadId ?? fallback?.threadId;
-    const roomId = target?.roomId ?? fallback?.roomId;
-    if (roomId && (!channelId || !threadTs)) {
-      const room = await this.runtime.getRoom(roomId);
-      channelId = channelId ?? room?.channelId;
-      const metadata = room?.metadata;
-      const roomThreadTs = typeof metadata?.threadTs === "string" ? metadata.threadTs : undefined;
-      threadTs = threadTs ?? roomThreadTs;
-    }
-    if (channelId && SLACK_USER_ID_PATTERN.test(channelId)) {
-      channelId = await this.openDirectMessageChannel(channelId, accountId);
-    }
-    if (!channelId && target?.entityId) {
-      const slackUserId = await this.resolveSlackTargetUserId(this.runtime, String(target.entityId), accountId);
-      if (slackUserId) {
-        channelId = await this.openDirectMessageChannel(slackUserId, accountId);
-      }
-    }
-    if (!channelId) {
-      throw new Error("Slack message operation requires channelId, roomId, or entityId.");
-    }
-    return { accountId, channelId, threadTs };
-  }
-  async slackMessageToMemory(message, channelId, threadTs, accountId = this.defaultAccountId) {
-    const effectiveThreadTs = threadTs ?? message.threadTs;
-    const roomId = await this.getRoomId(channelId, effectiveThreadTs, accountId);
-    const botUserId = this.getBotUserIdForAccount(accountId);
-    const slackUserId = message.user ?? botUserId ?? "unknown";
-    const entityId = slackUserId === botUserId ? this.runtime.agentId : this.getEntityId(slackUserId, accountId);
-    const user = message.user ? await this.getUser(message.user, accountId) : null;
-    const displayName = user ? getSlackUserDisplayName(user) : slackUserId;
-    const channel = await this.getChannel(channelId, accountId).catch(() => null);
-    const channelType = effectiveThreadTs ? ChannelType.THREAD : channel?.isIm ? ChannelType.DM : ChannelType.GROUP;
-    const attachments = (message.files ?? []).map((file) => ({
-      id: file.id,
-      url: file.urlPrivate,
-      title: file.title || file.name,
-      source: "slack",
-      description: file.name
-    }));
-    return {
-      id: createUniqueUuid(this.runtime, this.scopedSlackKey("slack", `${channelId}-${message.ts}`, accountId)),
-      agentId: this.runtime.agentId,
-      roomId,
-      entityId,
-      content: {
-        text: message.text || "",
-        source: "slack",
-        name: displayName,
-        channelType,
-        metadata: { accountId },
-        ...effectiveThreadTs && effectiveThreadTs !== message.ts ? {
-          inReplyTo: createUniqueUuid(this.runtime, this.scopedSlackKey("slack", `${channelId}-${effectiveThreadTs}`, accountId))
-        } : {},
-        ...attachments.length > 0 ? { attachments } : {}
-      },
-      metadata: {
-        type: "message",
-        source: "slack",
-        provider: "slack",
-        accountId,
-        timestamp: this.parseSlackTimestamp(message.ts),
-        entityName: displayName,
-        entityUserName: user?.name ?? slackUserId,
-        fromBot: slackUserId === botUserId,
-        fromId: slackUserId,
-        sourceId: entityId,
-        chatType: channelType,
-        messageIdFull: message.ts,
-        sender: {
-          id: slackUserId,
-          name: displayName,
-          username: user?.name ?? slackUserId
-        },
-        slack: {
-          accountId,
-          teamId: this.getTeamIdForAccount(accountId) ?? undefined,
-          channelId,
-          userId: slackUserId,
-          messageId: message.ts,
-          threadTs: effectiveThreadTs
-        },
-        slackChannelId: channelId,
-        slackMessageTs: message.ts,
-        slackThreadTs: effectiveThreadTs,
-        reactions: message.reactions
-      },
-      createdAt: this.parseSlackTimestamp(message.ts)
-    };
-  }
-  async listConnectorServers(context) {
-    const worlds = [];
-    for (const accountId of this.getCandidateAccountIds(context)) {
-      const teamId = this.getTeamIdForAccount(accountId);
-      if (!teamId) {
-        continue;
-      }
-      let name = `Slack Workspace ${teamId}`;
-      try {
-        const client = this.getClientForAccount(accountId);
-        if (client) {
-          const teamInfo = await client.team.info();
-          const team = teamInfo.team;
-          name = team?.name || name;
-        }
-      } catch {}
-      worlds.push({
-        id: createUniqueUuid(this.runtime, this.scopedSlackKey("slack-workspace", teamId, accountId)),
-        agentId: this.runtime.agentId,
-        name,
-        metadata: {
-          source: "slack",
-          accountId,
-          teamId
-        }
-      });
-    }
-    return worlds;
-  }
-  async fetchConnectorMessages(_context, params) {
-    const accountId = await this.resolveAccountIdForTarget(_context.runtime, params.target, { accountId: params.accountId, roomId: params.roomId });
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      return [];
-    }
-    const { channelId, threadTs } = await this.resolveConnectorMessageLocation(params.target, { ...params, accountId });
-    const limit = Number.isFinite(params.limit) ? Math.max(1, Math.min(Number(params.limit), 100)) : 25;
-    const rawMessages = threadTs ? (await client.conversations.replies({
-      channel: channelId,
-      ts: threadTs,
-      limit,
-      latest: params.before,
-      oldest: params.after,
-      cursor: params.cursor
-    })).messages ?? [] : await this.readHistory(channelId, {
-      limit,
-      before: params.before,
-      after: params.after
-    }, accountId);
-    const memories = [];
-    for (const rawMessage of rawMessages) {
-      const message = rawMessage;
-      if (!message.ts) {
-        continue;
-      }
-      memories.push(await this.slackMessageToMemory(message, channelId, threadTs, accountId));
-    }
-    return memories.sort((left, right) => Number(right.createdAt ?? 0) - Number(left.createdAt ?? 0));
-  }
-  async searchConnectorMessages(context, params) {
-    const query = params.query?.trim().toLowerCase();
-    if (!query) {
-      return [];
-    }
-    const memories = await this.fetchConnectorMessages(context, {
-      ...params,
-      limit: Math.max(params.limit ?? 100, 100)
-    });
-    return memories.filter((memory) => {
-      const text = String(memory.content?.text ?? "").toLowerCase();
-      const name = String(memory.content?.name ?? "").toLowerCase();
-      return text.includes(query) || name.includes(query);
-    }).slice(0, params.limit ?? 25);
-  }
-  async reactConnectorMessage(_runtime, params) {
-    const { accountId, channelId } = await this.resolveConnectorMessageLocation(params.target, params);
-    const messageTs = params.messageTs ?? params.messageId;
-    const emoji = params.emoji?.trim();
-    if (!messageTs || !emoji) {
-      throw new Error("Slack reaction requires messageId/messageTs and emoji.");
-    }
-    if (params.remove) {
-      await this.removeReaction(channelId, messageTs, emoji, accountId);
-      return;
-    }
-    await this.sendReaction(channelId, messageTs, emoji, accountId);
-  }
-  async editConnectorMessage(_runtime, params) {
-    const { accountId, channelId, threadTs } = await this.resolveConnectorMessageLocation(params.target, params);
-    const messageTs = params.messageTs ?? params.messageId;
-    const text = params.content?.text ?? params.text;
-    if (!messageTs || !text?.trim()) {
-      throw new Error("Slack edit requires messageId/messageTs and text.");
-    }
-    await this.editMessage(channelId, messageTs, text, accountId);
-    return this.slackMessageToMemory({
-      type: "message",
-      ts: messageTs,
-      user: this.getBotUserIdForAccount(accountId) ?? undefined,
-      text,
-      threadTs,
-      subtype: undefined,
-      replyCount: undefined,
-      replyUsersCount: undefined,
-      latestReply: undefined,
-      reactions: undefined,
-      files: undefined,
-      attachments: undefined,
-      blocks: undefined
-    }, channelId, threadTs, accountId);
-  }
-  async deleteConnectorMessage(_runtime, params) {
-    const { accountId, channelId } = await this.resolveConnectorMessageLocation(params.target, params);
-    const messageTs = params.messageTs ?? params.messageId;
-    if (!messageTs) {
-      throw new Error("Slack delete requires messageId/messageTs.");
-    }
-    await this.deleteMessage(channelId, messageTs, accountId);
-  }
-  async pinConnectorMessage(_runtime, params) {
-    const { accountId, channelId } = await this.resolveConnectorMessageLocation(params.target, params);
-    const messageTs = params.messageTs ?? params.messageId;
-    if (!messageTs) {
-      throw new Error("Slack pin requires messageId/messageTs.");
-    }
-    if (params.pin === false) {
-      await this.unpinMessage(channelId, messageTs, accountId);
-      return;
-    }
-    await this.pinMessage(channelId, messageTs, accountId);
-  }
-  async getConnectorUser(runtime, params) {
-    const accountId = normalizeAccountId(params.target?.accountId ?? this.defaultAccountId ?? DEFAULT_ACCOUNT_ID);
-    const lookup = params.userId ?? params.handle ?? params.username ?? params.query;
-    if (!lookup) {
-      return null;
-    }
-    let slackUserId = SLACK_USER_ID_PATTERN.test(lookup) ? lookup : await this.resolveSlackTargetUserId(runtime, lookup, accountId);
-    const client = this.getClientForAccount(accountId);
-    if (!slackUserId && client) {
-      const usersResult = await client.users.list({ limit: 200 });
-      const members = usersResult.members ?? [];
-      const normalized = normalizeSlackConnectorQuery(lookup);
-      const match = members.find((member) => [
-        member.id,
-        member.name,
-        member.real_name,
-        member.profile?.display_name,
-        member.profile?.email
-      ].filter((value) => Boolean(value)).some((value) => normalizeSlackConnectorQuery(value).includes(normalized)));
-      slackUserId = match?.id ?? null;
-    }
-    if (!slackUserId) {
-      return null;
-    }
-    const user = await this.getUser(slackUserId, accountId);
-    if (!user) {
-      return null;
-    }
-    return {
-      id: this.getEntityId(user.id, accountId),
-      agentId: this.runtime.agentId,
-      names: [getSlackUserDisplayName(user), user.name, user.realName].filter((value) => Boolean(value)),
-      metadata: {
-        source: "slack",
-        accountId,
-        slack: {
-          accountId,
-          id: user.id,
-          teamId: user.teamId ?? this.getTeamIdForAccount(accountId),
-          name: user.name,
-          realName: user.realName,
-          profile: { ...user.profile }
-        }
-      }
-    };
-  }
-  async getConnectorUserContext(entityId, context) {
-    const accountId = normalizeAccountId(context.target?.accountId ?? context.accountId ?? context.account?.accountId ?? this.defaultAccountId ?? DEFAULT_ACCOUNT_ID);
-    const slackUserId = await this.resolveSlackTargetUserId(context.runtime, String(entityId), accountId);
-    if (!slackUserId) {
-      return null;
-    }
-    const user = await this.getUser(slackUserId, accountId);
-    if (!user) {
-      return null;
-    }
-    return {
-      entityId,
-      label: getSlackUserDisplayName(user),
-      aliases: [
-        user.name,
-        user.realName,
-        user.profile.displayName,
-        user.profile.realName,
-        user.profile.email
-      ].filter((value) => Boolean(value)),
-      handles: {
-        slack: user.id,
-        ...user.profile.email ? { email: user.profile.email } : {}
-      },
-      metadata: {
-        accountId,
-        slackUserId: user.id,
-        slackTeamId: user.teamId ?? this.getTeamIdForAccount(accountId),
-        profile: { ...user.profile }
-      }
-    };
-  }
-  async getUser(userId, accountId) {
-    const userCache = this.getUserCacheForAccount(accountId);
-    const cachedUser = userCache.get(userId);
-    if (cachedUser) {
-      return cachedUser;
-    }
-    const client = this.getClientForAccount(accountId);
-    if (!client)
-      return null;
-    const result = await client.users.info({ user: userId });
-    if (!result.user)
-      return null;
-    const user = {
-      id: result.user.id ?? userId,
-      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
-    };
-    userCache.set(userId, user);
-    return user;
-  }
-  async getChannel(channelId, accountId) {
-    const channelCache = this.getChannelCacheForAccount(accountId);
-    const cachedChannel = channelCache.get(channelId);
-    if (cachedChannel) {
-      return cachedChannel;
-    }
-    const client = this.getClientForAccount(accountId);
-    if (!client)
-      return null;
-    const result = await 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
-    };
-    channelCache.set(channelId, channel);
-    return channel;
-  }
-  async sendMessage(channelId, text, options, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    const convertedText = markdownToSlackMrkdwn(text);
-    const messages = this.splitMessage(convertedText);
-    let lastTs = "";
-    for (const msg of messages) {
-      const result = await 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, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    const cleanEmoji = emoji.replace(/^:/, "").replace(/:$/, "");
-    await client.reactions.add({
-      channel: channelId,
-      timestamp: messageTs,
-      name: cleanEmoji
-    });
-  }
-  async removeReaction(channelId, messageTs, emoji, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    const cleanEmoji = emoji.replace(/^:/, "").replace(/:$/, "");
-    await client.reactions.remove({
-      channel: channelId,
-      timestamp: messageTs,
-      name: cleanEmoji
-    });
-  }
-  async editMessage(channelId, messageTs, text, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    await client.chat.update({
-      channel: channelId,
-      ts: messageTs,
-      text
-    });
-  }
-  async deleteMessage(channelId, messageTs, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    await client.chat.delete({
-      channel: channelId,
-      ts: messageTs
-    });
-  }
-  async pinMessage(channelId, messageTs, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    await client.pins.add({
-      channel: channelId,
-      timestamp: messageTs
-    });
-  }
-  async unpinMessage(channelId, messageTs, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    await client.pins.remove({
-      channel: channelId,
-      timestamp: messageTs
-    });
-  }
-  async listPins(channelId, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    const result = await 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, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    const result = await 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, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    const result = await 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 ?? 0
-      } : undefined,
-      purpose: ch.purpose ? {
-        value: ch.purpose.value ?? "",
-        creator: ch.purpose.creator ?? "",
-        lastSet: ch.purpose.last_set ?? 0
-      } : undefined,
-      numMembers: ch.num_members,
-      created: ch.created || 0,
-      creator: ch.creator || ""
-    }));
-  }
-  async getEmojiList(accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    const result = await client.emoji.list();
-    return result.emoji || {};
-  }
-  async uploadFile(channelId, content, filename, options, accountId) {
-    const client = this.getClientForAccount(accountId);
-    if (!client) {
-      throw new Error("Slack client not initialized");
-    }
-    const result = await 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, accountId) {
-    if (isValidChannelId(channelId)) {
-      this.getDynamicChannelIdsForAccount(accountId).add(channelId);
-    }
-  }
-  removeAllowedChannel(channelId, accountId) {
-    this.getDynamicChannelIdsForAccount(accountId).delete(channelId);
-  }
-  getAllowedChannelIds(accountId) {
-    return [
-      ...this.getAllowedChannelIdsForAccount(accountId),
-      ...this.getDynamicChannelIdsForAccount(accountId)
-    ];
-  }
-  isServiceConnected() {
-    return this.isConnected && this.app !== null;
-  }
-  getBotUserId() {
-    return this.botUserId;
-  }
-  getTeamId() {
-    return this.teamId;
-  }
-  clearUserCache() {
-    this.userCache.clear();
-  }
-  clearChannelCache() {
-    this.channelCache.clear();
-  }
-}
-
-// src/workflow-credential-provider.ts
-import { Service as Service2 } from "@elizaos/core";
-var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
-var SUPPORTED = ["slackApi", "slackOAuth2Api"];
-
-class SlackWorkflowCredentialProvider extends Service2 {
-  static serviceType = WORKFLOW_CREDENTIAL_PROVIDER_TYPE;
-  capabilityDescription = "Supplies Slack credentials to the workflow plugin.";
-  static async start(runtime) {
-    return new SlackWorkflowCredentialProvider(runtime);
-  }
-  async stop() {}
-  async resolve(_userId, credType) {
-    const botToken = this.runtime.getSetting("SLACK_BOT_TOKEN");
-    const userToken = this.runtime.getSetting("SLACK_USER_TOKEN");
-    if (credType === "slackApi" && botToken?.trim()) {
-      return {
-        status: "credential_data",
-        data: { accessToken: botToken.trim() }
-      };
-    }
-    if (credType === "slackOAuth2Api" && userToken?.trim()) {
-      return {
-        status: "credential_data",
-        data: { accessToken: userToken.trim() }
-      };
-    }
-    return null;
-  }
-  checkCredentialTypes(credTypes) {
-    return {
-      supported: credTypes.filter((t) => SUPPORTED.includes(t)),
-      unsupported: credTypes.filter((t) => !SUPPORTED.includes(t))
-    };
-  }
-}
-
-// src/index.ts
-var slackPlugin = {
-  name: "slack",
-  description: "Slack integration plugin for ElizaOS with Socket Mode support",
-  services: [SlackService, SlackWorkflowCredentialProvider],
-  actions: [],
-  providers: [],
-  autoEnable: {
-    connectorKeys: ["slack"]
-  },
-  init: async (_config, runtime) => {
-    try {
-      const manager = getConnectorAccountManager(runtime);
-      manager.registerProvider(createSlackConnectorAccountProvider(runtime));
-    } catch (err) {
-      logger2.warn({
-        src: "plugin:slack",
-        err: err instanceof Error ? err.message : String(err)
-      }, "Failed to register Slack provider with ConnectorAccountManager");
-    }
-    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)}`;
-    };
-    logger2.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() === "") {
-      logger2.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_BOT_TOKEN not provided - Slack plugin is loaded but will not be functional");
-      logger2.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() === "") {
-      logger2.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_APP_TOKEN not provided - Socket Mode will not work");
-      logger2.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-")) {
-      logger2.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_BOT_TOKEN should start with 'xoxb-'. Please verify your token.");
-    }
-    if (!appToken.startsWith("xapp-")) {
-      logger2.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_APP_TOKEN should start with 'xapp-'. Please verify your token.");
-    }
-    if (userToken && !userToken.startsWith("xoxp-")) {
-      logger2.warn({ src: "plugin:slack", agentId: runtime.agentId }, "SLACK_USER_TOKEN should start with 'xoxp-'. Please verify your token.");
-    }
-    logger2.info({ src: "plugin:slack", agentId: runtime.agentId }, "Slack plugin configuration validated successfully");
-  }
-};
-var src_default = slackPlugin;
-export {
-  truncateText,
-  stripSlackFormatting,
-  resolveSlackUserToken,
-  resolveSlackSystemLocation,
-  resolveSlackReplyToMode,
-  resolveSlackBotToken,
-  resolveSlackAppToken,
-  resolveSlackAccount,
-  resolveDefaultSlackAccountId,
-  parseSlackMessagePermalink,
-  parseSlackMessageLink,
-  normalizeAccountId,
-  markdownToSlackMrkdwnChunks,
-  markdownToSlackMrkdwn,
-  listSlackAccountIds,
-  listEnabledSlackAccounts,
-  isValidUserId,
-  isValidTeamId,
-  isValidMessageTs,
-  isValidChannelId,
-  isPrivateChannel,
-  isMultiAccountEnabled,
-  isGroupDm,
-  isDirectMessage,
-  getSlackUserDisplayName,
-  getSlackChannelType,
-  getChannelTypeString,
-  formatSlackUserMention,
-  formatSlackUserGroupMention,
-  formatSlackUserDisplayName,
-  formatSlackSpecialMention,
-  formatSlackLink,
-  formatSlackDate,
-  formatSlackChannelMention,
-  formatSlackChannel,
-  formatMessageTsForLink,
-  extractUserIdFromMention,
-  extractUrlFromSlackLink,
-  extractChannelIdFromMention,
-  escapeSlackMrkdwn,
-  src_default as default,
-  createSlackConnectorAccountProvider,
-  chunkSlackText,
-  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=3501C22F83015CAC64756E2164756E21