@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/draft-stream.ts

@@ -1,154 +0,0 @@
-import { createFinalizableDraftLifecycle } from "openclaw/plugin-sdk/channel-lifecycle";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import {
-  createChannelMessage,
-  deleteChannelMessage,
-  editChannelMessage,
-  type RequestClient,
-} from "./internal/discord.js";
-
-/** Discord messages cap at 2000 characters. */
-const DISCORD_STREAM_MAX_CHARS = 2000;
-const DEFAULT_THROTTLE_MS = 1200;
-const DISCORD_PREVIEW_ALLOWED_MENTIONS = { parse: [] };
-
-type DiscordDraftStream = {
-  update: (text: string) => void;
-  flush: () => Promise<void>;
-  messageId: () => string | undefined;
-  clear: () => Promise<void>;
-  discardPending: () => Promise<void>;
-  seal: () => Promise<void>;
-  stop: () => Promise<void>;
-  /** Reset internal state so the next update creates a new message instead of editing. */
-  forceNewMessage: () => void;
-};
-
-export function createDiscordDraftStream(params: {
-  rest: RequestClient;
-  channelId: string;
-  maxChars?: number;
-  replyToMessageId?: string | (() => string | undefined);
-  throttleMs?: number;
-  /** Minimum chars before sending first message (debounce for push notifications) */
-  minInitialChars?: number;
-  log?: (message: string) => void;
-  warn?: (message: string) => void;
-}): DiscordDraftStream {
-  const maxChars = Math.min(params.maxChars ?? DISCORD_STREAM_MAX_CHARS, DISCORD_STREAM_MAX_CHARS);
-  const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
-  const minInitialChars = params.minInitialChars;
-  const channelId = params.channelId;
-  const rest = params.rest;
-  const resolveReplyToMessageId = () =>
-    typeof params.replyToMessageId === "function"
-      ? params.replyToMessageId()
-      : params.replyToMessageId;
-
-  const streamState = { stopped: false, final: false };
-  let streamMessageId: string | undefined;
-  let lastSentText = "";
-
-  const sendOrEditStreamMessage = async (text: string): Promise<boolean> => {
-    // Allow final flush even if stopped (e.g., after clear()).
-    if (streamState.stopped && !streamState.final) {
-      return false;
-    }
-    const trimmed = text.trimEnd();
-    if (!trimmed) {
-      return false;
-    }
-    if (trimmed.length > maxChars) {
-      // Discord messages cap at 2000 chars.
-      // Stop streaming once we exceed the cap to avoid repeated API failures.
-      streamState.stopped = true;
-      params.warn?.(`discord stream preview stopped (text length ${trimmed.length} > ${maxChars})`);
-      return false;
-    }
-    if (trimmed === lastSentText) {
-      return true;
-    }
-
-    // Debounce first preview send for better push notification quality.
-    if (streamMessageId === undefined && minInitialChars != null && !streamState.final) {
-      if (trimmed.length < minInitialChars) {
-        return false;
-      }
-    }
-
-    lastSentText = trimmed;
-    try {
-      if (streamMessageId !== undefined) {
-        // Edit existing message
-        await editChannelMessage(rest, channelId, streamMessageId, {
-          body: { content: trimmed, allowed_mentions: DISCORD_PREVIEW_ALLOWED_MENTIONS },
-        });
-        return true;
-      }
-      // Send new message
-      const replyToMessageId = resolveReplyToMessageId()?.trim();
-      const messageReference = replyToMessageId
-        ? { message_id: replyToMessageId, fail_if_not_exists: false }
-        : undefined;
-      const sent = await createChannelMessage<{ id?: string }>(rest, channelId, {
-        body: {
-          content: trimmed,
-          allowed_mentions: DISCORD_PREVIEW_ALLOWED_MENTIONS,
-          ...(messageReference ? { message_reference: messageReference } : {}),
-        },
-      });
-      const sentMessageId = sent?.id;
-      if (typeof sentMessageId !== "string" || !sentMessageId) {
-        streamState.stopped = true;
-        params.warn?.("discord stream preview stopped (missing message id from send)");
-        return false;
-      }
-      streamMessageId = sentMessageId;
-      return true;
-    } catch (err) {
-      streamState.stopped = true;
-      params.warn?.(`discord stream preview failed: ${formatErrorMessage(err)}`);
-      return false;
-    }
-  };
-
-  const readMessageId = () => streamMessageId;
-  const clearMessageId = () => {
-    streamMessageId = undefined;
-  };
-  const isValidStreamMessageId = (value: unknown): value is string => typeof value === "string";
-  const deleteStreamMessage = async (messageId: string) => {
-    await deleteChannelMessage(rest, channelId, messageId);
-  };
-
-  const { loop, update, stop, clear, discardPending, seal } = createFinalizableDraftLifecycle({
-    throttleMs,
-    state: streamState,
-    sendOrEditStreamMessage,
-    readMessageId,
-    clearMessageId,
-    isValidMessageId: isValidStreamMessageId,
-    deleteMessage: deleteStreamMessage,
-    warn: params.warn,
-    warnPrefix: "discord stream preview cleanup failed",
-  });
-
-  const forceNewMessage = () => {
-    streamMessageId = undefined;
-    lastSentText = "";
-    loop.resetPending();
-  };
-
-  params.log?.(`discord stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
-
-  return {
-    update,
-    flush: loop.flush,
-    messageId: () => streamMessageId,
-    clear,
-    discardPending,
-    seal,
-    stop,
-    forceNewMessage,
-  };
-}

package/src/error-body.ts

@@ -1,38 +0,0 @@
-const DISCORD_RESPONSE_BODY_SUMMARY_MAX_CHARS = 240;
-
-export function summarizeDiscordResponseBody(
-  body: string,
-  opts: { emptyText?: string } = {},
-): string | undefined {
-  const summary = body
-    .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ")
-    .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ")
-    .replace(/<[^>]+>/g, " ")
-    .replace(/&nbsp;/gi, " ")
-    .replace(/&amp;/gi, "&")
-    .replace(/&lt;/gi, "<")
-    .replace(/&gt;/gi, ">")
-    .replace(/\s+/g, " ")
-    .trim();
-  if (!summary) {
-    return opts.emptyText;
-  }
-  return summary.slice(0, DISCORD_RESPONSE_BODY_SUMMARY_MAX_CHARS);
-}
-
-export function isDiscordHtmlResponseBody(body: string, contentType?: string | null): boolean {
-  return (
-    /\bhtml\b/i.test(contentType ?? "") ||
-    /^\s*<!doctype\s+html\b/i.test(body) ||
-    /^\s*<html\b/i.test(body)
-  );
-}
-
-export function isDiscordRateLimitResponseBody(body: string): boolean {
-  const normalized = body.toLowerCase();
-  return (
-    normalized.includes("error 1015") ||
-    normalized.includes("cloudflare") ||
-    normalized.includes("rate limit")
-  );
-}

package/src/exec-approvals.test.ts

@@ -1,88 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { describe, expect, it } from "vitest";
-import {
-  getDiscordExecApprovalApprovers,
-  isDiscordExecApprovalApprover,
-  isDiscordExecApprovalClientEnabled,
-} from "./exec-approvals.js";
-
-function buildConfig(
-  execApprovals?: NonNullable<NonNullable<OpenClawConfig["channels"]>["discord"]>["execApprovals"],
-  channelOverrides?: Partial<NonNullable<NonNullable<OpenClawConfig["channels"]>["discord"]>>,
-): OpenClawConfig {
-  return {
-    channels: {
-      discord: {
-        token: "discord-token",
-        ...channelOverrides,
-        execApprovals,
-      },
-    },
-  } as OpenClawConfig;
-}
-
-describe("discord exec approvals", () => {
-  it("requires explicit enablement even when owner approvers resolve", () => {
-    expect(isDiscordExecApprovalClientEnabled({ cfg: buildConfig() })).toBe(false);
-    expect(
-      isDiscordExecApprovalClientEnabled({
-        cfg: buildConfig({ enabled: true }),
-      }),
-    ).toBe(false);
-    expect(
-      isDiscordExecApprovalClientEnabled({
-        cfg: buildConfig({ approvers: ["123"] }),
-      }),
-    ).toBe(false);
-    expect(
-      isDiscordExecApprovalClientEnabled({
-        cfg: {
-          ...buildConfig(),
-          commands: { ownerAllowFrom: ["discord:789"] },
-        } as OpenClawConfig,
-      }),
-    ).toBe(false);
-    expect(
-      isDiscordExecApprovalClientEnabled({
-        cfg: buildConfig({ enabled: "auto", approvers: ["123"] }),
-      }),
-    ).toBe(true);
-    expect(
-      isDiscordExecApprovalClientEnabled({
-        cfg: buildConfig({ enabled: false, approvers: ["123"] }),
-      }),
-    ).toBe(false);
-  });
-
-  it("prefers explicit approvers when configured", () => {
-    const cfg = buildConfig({ approvers: ["456"] }, { allowFrom: ["123"], defaultTo: "user:789" });
-
-    expect(getDiscordExecApprovalApprovers({ cfg })).toEqual(["456"]);
-    expect(isDiscordExecApprovalApprover({ cfg, senderId: "456" })).toBe(true);
-    expect(isDiscordExecApprovalApprover({ cfg, senderId: "123" })).toBe(false);
-  });
-
-  it("does not infer approvers from allowFrom or default DM routes", () => {
-    const cfg = buildConfig(
-      { enabled: true },
-      {
-        allowFrom: ["123"],
-        dm: { allowFrom: ["456"] },
-        defaultTo: "user:789",
-      },
-    );
-
-    expect(getDiscordExecApprovalApprovers({ cfg })).toEqual([]);
-    expect(isDiscordExecApprovalApprover({ cfg, senderId: "789" })).toBe(false);
-  });
-
-  it("falls back to commands.ownerAllowFrom for exec approvers", () => {
-    const cfg = {
-      ...buildConfig(),
-      commands: { ownerAllowFrom: ["discord:123", "user:456", "789"] },
-    } as OpenClawConfig;
-
-    expect(getDiscordExecApprovalApprovers({ cfg })).toEqual(["123", "456", "789"]);
-    expect(isDiscordExecApprovalApprover({ cfg, senderId: "456" })).toBe(true);
-  });
-});

package/src/exec-approvals.ts

@@ -1,110 +0,0 @@
-import type { ChannelOutboundPayloadHint } from "openclaw/plugin-sdk/channel-contract";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import type { DiscordExecApprovalConfig } from "openclaw/plugin-sdk/config-types";
-import type { ReplyPayload } from "openclaw/plugin-sdk/reply-dispatch-runtime";
-import { resolveDiscordAccount } from "./accounts.js";
-import {
-  getExecApprovalReplyMetadata,
-  isChannelExecApprovalClientEnabledFromConfig,
-  matchesApprovalRequestFilters,
-  resolveApprovalApprovers,
-} from "./approval-runtime.js";
-import { parseDiscordTarget } from "./target-parsing.js";
-
-function normalizeDiscordApproverId(value: string): string | undefined {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return undefined;
-  }
-  if (/^\d+$/.test(trimmed)) {
-    return trimmed;
-  }
-  try {
-    const target = parseDiscordTarget(trimmed);
-    return target?.kind === "user" ? target.id : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function resolveDiscordOwnerApprovers(cfg: OpenClawConfig): string[] {
-  const ownerAllowFrom = cfg.commands?.ownerAllowFrom;
-  if (!Array.isArray(ownerAllowFrom) || ownerAllowFrom.length === 0) {
-    return [];
-  }
-  return resolveApprovalApprovers({
-    explicit: ownerAllowFrom,
-    normalizeApprover: (value) => normalizeDiscordApproverId(String(value)),
-  });
-}
-
-export function getDiscordExecApprovalApprovers(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  configOverride?: DiscordExecApprovalConfig | null;
-}): string[] {
-  return resolveApprovalApprovers({
-    explicit:
-      params.configOverride?.approvers ??
-      resolveDiscordAccount(params).config.execApprovals?.approvers ??
-      resolveDiscordOwnerApprovers(params.cfg),
-    normalizeApprover: (value) => normalizeDiscordApproverId(String(value)),
-  });
-}
-
-export function isDiscordExecApprovalClientEnabled(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  configOverride?: DiscordExecApprovalConfig | null;
-}): boolean {
-  const config = params.configOverride ?? resolveDiscordAccount(params).config.execApprovals;
-  return isChannelExecApprovalClientEnabledFromConfig({
-    enabled: config?.enabled,
-    approverCount: getDiscordExecApprovalApprovers({
-      cfg: params.cfg,
-      accountId: params.accountId,
-      configOverride: params.configOverride,
-    }).length,
-  });
-}
-
-export function isDiscordExecApprovalApprover(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  senderId?: string | null;
-  configOverride?: DiscordExecApprovalConfig | null;
-}): boolean {
-  const senderId = params.senderId?.trim();
-  if (!senderId) {
-    return false;
-  }
-  return getDiscordExecApprovalApprovers({
-    cfg: params.cfg,
-    accountId: params.accountId,
-    configOverride: params.configOverride,
-  }).includes(senderId);
-}
-
-export function shouldSuppressLocalDiscordExecApprovalPrompt(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  payload: ReplyPayload;
-  hint?: ChannelOutboundPayloadHint;
-}): boolean {
-  const metadata = getExecApprovalReplyMetadata(params.payload);
-  const config = resolveDiscordAccount(params).config.execApprovals;
-  return (
-    params.hint?.kind === "approval-pending" &&
-    params.hint.nativeRouteActive === true &&
-    isDiscordExecApprovalClientEnabled(params) &&
-    metadata !== null &&
-    matchesApprovalRequestFilters({
-      request: {
-        agentId: metadata.agentId,
-        sessionKey: metadata.sessionKey,
-      },
-      agentFilter: config?.agentFilter,
-      sessionFilter: config?.sessionFilter,
-    })
-  );
-}

package/src/gateway-logging.test.ts

@@ -1,98 +0,0 @@
-import { EventEmitter } from "node:events";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("openclaw/plugin-sdk/runtime-env", () => ({
-  logVerbose: vi.fn(),
-}));
-
-let logVerbose: typeof import("openclaw/plugin-sdk/runtime-env").logVerbose;
-let attachDiscordGatewayLogging: typeof import("./gateway-logging.js").attachDiscordGatewayLogging;
-
-const makeRuntime = () => ({
-  log: vi.fn(),
-  error: vi.fn(),
-  exit: vi.fn(),
-});
-
-describe("attachDiscordGatewayLogging", () => {
-  beforeAll(async () => {
-    ({ logVerbose } = await import("openclaw/plugin-sdk/runtime-env"));
-    ({ attachDiscordGatewayLogging } = await import("./gateway-logging.js"));
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-  it("logs debug events and promotes reconnect/close to info", () => {
-    const emitter = new EventEmitter();
-    const runtime = makeRuntime();
-
-    const cleanup = attachDiscordGatewayLogging({
-      emitter,
-      runtime,
-    });
-
-    emitter.emit("debug", "Gateway websocket opened");
-    emitter.emit("debug", "Gateway websocket closed: 1001");
-    emitter.emit("debug", "Gateway reconnect scheduled in 1000ms (close, resume=true)");
-    emitter.emit("debug", "Gateway forcing fresh IDENTIFY after 3 failed resume attempts");
-
-    const logVerboseMock = vi.mocked(logVerbose);
-    expect(logVerboseMock).toHaveBeenCalledTimes(4);
-    expect(runtime.log).toHaveBeenCalledTimes(3);
-    expect(runtime.log).toHaveBeenNthCalledWith(
-      1,
-      "discord gateway: Gateway websocket closed: 1001",
-    );
-    expect(runtime.log).toHaveBeenNthCalledWith(
-      2,
-      "discord gateway: Gateway reconnect scheduled in 1000ms (close, resume=true)",
-    );
-    expect(runtime.log).toHaveBeenNthCalledWith(
-      3,
-      "discord gateway: Gateway forcing fresh IDENTIFY after 3 failed resume attempts",
-    );
-
-    cleanup();
-  });
-
-  it("logs warnings and metrics only to verbose", () => {
-    const emitter = new EventEmitter();
-    const runtime = makeRuntime();
-
-    const cleanup = attachDiscordGatewayLogging({
-      emitter,
-      runtime,
-    });
-
-    emitter.emit("warning", "High latency detected: 1200ms");
-    emitter.emit("metrics", { latency: 42, errors: 1 });
-
-    const logVerboseMock = vi.mocked(logVerbose);
-    expect(logVerboseMock).toHaveBeenCalledTimes(2);
-    expect(runtime.log).not.toHaveBeenCalled();
-
-    cleanup();
-  });
-
-  it("removes listeners on cleanup", () => {
-    const emitter = new EventEmitter();
-    const runtime = makeRuntime();
-
-    const cleanup = attachDiscordGatewayLogging({
-      emitter,
-      runtime,
-    });
-    cleanup();
-
-    const logVerboseMock = vi.mocked(logVerbose);
-    logVerboseMock.mockClear();
-
-    emitter.emit("debug", "Gateway websocket closed: 1001");
-    emitter.emit("warning", "High latency detected: 1200ms");
-    emitter.emit("metrics", { latency: 42 });
-
-    expect(logVerboseMock).not.toHaveBeenCalled();
-    expect(runtime.log).not.toHaveBeenCalled();
-  });
-});

package/src/gateway-logging.ts

@@ -1,67 +0,0 @@
-import type { EventEmitter } from "node:events";
-import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
-import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
-
-type GatewayEmitter = Pick<EventEmitter, "on" | "removeListener">;
-
-const INFO_DEBUG_MARKERS = [
-  "Gateway websocket closed",
-  "Gateway reconnect scheduled in",
-  "Gateway forcing fresh IDENTIFY after",
-];
-
-const shouldPromoteGatewayDebug = (message: string) =>
-  INFO_DEBUG_MARKERS.some((marker) => message.includes(marker));
-
-const formatGatewayMetrics = (metrics: unknown) => {
-  if (metrics === null || metrics === undefined) {
-    return String(metrics);
-  }
-  if (typeof metrics === "string") {
-    return metrics;
-  }
-  if (typeof metrics === "number" || typeof metrics === "boolean" || typeof metrics === "bigint") {
-    return String(metrics);
-  }
-  try {
-    return JSON.stringify(metrics);
-  } catch {
-    return "[unserializable metrics]";
-  }
-};
-
-export function attachDiscordGatewayLogging(params: {
-  emitter?: GatewayEmitter;
-  runtime: RuntimeEnv;
-}) {
-  const { emitter, runtime } = params;
-  if (!emitter) {
-    return () => {};
-  }
-
-  const onGatewayDebug = (msg: unknown) => {
-    const message = String(msg);
-    logVerbose(`discord gateway: ${message}`);
-    if (shouldPromoteGatewayDebug(message)) {
-      runtime.log?.(`discord gateway: ${message}`);
-    }
-  };
-
-  const onGatewayWarning = (warning: unknown) => {
-    logVerbose(`discord gateway warning: ${String(warning)}`);
-  };
-
-  const onGatewayMetrics = (metrics: unknown) => {
-    logVerbose(`discord gateway metrics: ${formatGatewayMetrics(metrics)}`);
-  };
-
-  emitter.on("debug", onGatewayDebug);
-  emitter.on("warning", onGatewayWarning);
-  emitter.on("metrics", onGatewayMetrics);
-
-  return () => {
-    emitter.removeListener("debug", onGatewayDebug);
-    emitter.removeListener("warning", onGatewayWarning);
-    emitter.removeListener("metrics", onGatewayMetrics);
-  };
-}

package/src/group-policy.ts

@@ -1,113 +0,0 @@
-import type { ChannelGroupContext } from "openclaw/plugin-sdk/channel-contract";
-import {
-  resolveToolsBySender,
-  type GroupToolPolicyBySenderConfig,
-  type GroupToolPolicyConfig,
-} from "openclaw/plugin-sdk/channel-policy";
-import { normalizeAtHashSlug } from "openclaw/plugin-sdk/string-normalization-runtime";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
-import type { DiscordConfig } from "./runtime-api.js";
-
-function normalizeDiscordSlug(value?: string | null) {
-  return normalizeAtHashSlug(value);
-}
-
-type SenderScopedToolsEntry = {
-  tools?: GroupToolPolicyConfig;
-  toolsBySender?: GroupToolPolicyBySenderConfig;
-  requireMention?: boolean;
-};
-
-function resolveDiscordGuildEntry(guilds: DiscordConfig["guilds"], groupSpace?: string | null) {
-  if (!guilds || Object.keys(guilds).length === 0) {
-    return null;
-  }
-  const space = normalizeOptionalString(groupSpace) ?? "";
-  if (space && guilds[space]) {
-    return guilds[space];
-  }
-  const normalized = normalizeDiscordSlug(space);
-  if (normalized && guilds[normalized]) {
-    return guilds[normalized];
-  }
-  if (normalized) {
-    const match = Object.values(guilds).find(
-      (entry) => normalizeDiscordSlug(entry?.slug ?? undefined) === normalized,
-    );
-    if (match) {
-      return match;
-    }
-  }
-  return guilds["*"] ?? null;
-}
-
-function resolveDiscordChannelEntry<TEntry extends SenderScopedToolsEntry>(
-  channelEntries: Record<string, TEntry> | undefined,
-  params: { groupId?: string | null; groupChannel?: string | null },
-): TEntry | undefined {
-  if (!channelEntries || Object.keys(channelEntries).length === 0) {
-    return undefined;
-  }
-  const groupChannel = params.groupChannel;
-  const channelSlug = normalizeDiscordSlug(groupChannel);
-  return (
-    (params.groupId ? channelEntries[params.groupId] : undefined) ??
-    (channelSlug
-      ? (channelEntries[channelSlug] ?? channelEntries[`#${channelSlug}`])
-      : undefined) ??
-    (groupChannel ? channelEntries[normalizeDiscordSlug(groupChannel)] : undefined)
-  );
-}
-
-function resolveSenderToolsEntry(
-  entry: SenderScopedToolsEntry | undefined | null,
-  params: ChannelGroupContext,
-): GroupToolPolicyConfig | undefined {
-  if (!entry) {
-    return undefined;
-  }
-  const senderPolicy = resolveToolsBySender({
-    toolsBySender: entry.toolsBySender,
-    senderId: params.senderId,
-    senderName: params.senderName,
-    senderUsername: params.senderUsername,
-    senderE164: params.senderE164,
-  });
-  return senderPolicy ?? entry.tools;
-}
-
-function resolveDiscordPolicyContext(params: ChannelGroupContext) {
-  const guilds =
-    (params.accountId
-      ? params.cfg.channels?.discord?.accounts?.[params.accountId]?.guilds
-      : undefined) ?? params.cfg.channels?.discord?.guilds;
-  const guildEntry = resolveDiscordGuildEntry(guilds, params.groupSpace);
-  const channelEntries = guildEntry?.channels;
-  const channelEntry =
-    channelEntries && Object.keys(channelEntries).length > 0
-      ? resolveDiscordChannelEntry(channelEntries, params)
-      : undefined;
-  return { guildEntry, channelEntry };
-}
-
-export function resolveDiscordGroupRequireMention(params: ChannelGroupContext): boolean {
-  const context = resolveDiscordPolicyContext(params);
-  if (typeof context.channelEntry?.requireMention === "boolean") {
-    return context.channelEntry.requireMention;
-  }
-  if (typeof context.guildEntry?.requireMention === "boolean") {
-    return context.guildEntry.requireMention;
-  }
-  return true;
-}
-
-export function resolveDiscordGroupToolPolicy(
-  params: ChannelGroupContext,
-): GroupToolPolicyConfig | undefined {
-  const context = resolveDiscordPolicyContext(params);
-  const channelPolicy = resolveSenderToolsEntry(context.channelEntry, params);
-  if (channelPolicy) {
-    return channelPolicy;
-  }
-  return resolveSenderToolsEntry(context.guildEntry, params);
-}

package/src/guilds.ts

@@ -1,29 +0,0 @@
-import { fetchDiscord } from "./api.js";
-import { normalizeDiscordSlug } from "./monitor/allow-list.js";
-
-export type DiscordGuildSummary = {
-  id: string;
-  name: string;
-  slug: string;
-};
-
-export async function listGuilds(
-  token: string,
-  fetcher: typeof fetch,
-): Promise<DiscordGuildSummary[]> {
-  const raw = await fetchDiscord<Array<{ id?: string; name?: string }>>(
-    "/users/@me/guilds",
-    token,
-    fetcher,
-  );
-  return raw
-    .filter(
-      (guild): guild is { id: string; name: string } =>
-        typeof guild.id === "string" && typeof guild.name === "string",
-    )
-    .map((guild) => ({
-      id: guild.id,
-      name: guild.name,
-      slug: normalizeDiscordSlug(guild.name),
-    }));
-}