@openclaw/discord 2026.3.13 → 2026.5.1-beta.1

package/src/monitor/message-handler.context.ts

@@ -0,0 +1,393 @@
+import {
+  formatInboundEnvelope,
+  resolveEnvelopeFormatOptions,
+} from "openclaw/plugin-sdk/channel-inbound";
+import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
+import { resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/conversation-runtime";
+import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
+import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
+import { buildPendingHistoryContextFromMap } from "openclaw/plugin-sdk/reply-history";
+import { buildAgentSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
+import { danger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { evaluateSupplementalContextVisibility } from "openclaw/plugin-sdk/security-runtime";
+import { readSessionUpdatedAt, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-runtime";
+import { resolveDiscordConversationIdentity } from "../conversation-identity.js";
+import { ChannelType } from "../internal/discord.js";
+import { normalizeDiscordAllowList, normalizeDiscordSlug } from "./allow-list.js";
+import { resolveTimestampMs } from "./format.js";
+import {
+  buildDiscordInboundAccessContext,
+  createDiscordSupplementalContextAccessChecker,
+} from "./inbound-context.js";
+import type { DiscordMessagePreflightContext } from "./message-handler.preflight.js";
+import {
+  buildDiscordMediaPayload,
+  resolveDiscordMessageText,
+  type DiscordMediaInfo,
+} from "./message-utils.js";
+import { buildDirectLabel, buildGuildLabel, resolveReplyContext } from "./reply-context.js";
+import { resolveDiscordAutoThreadReplyPlan, resolveDiscordThreadStarter } from "./threading.js";
+
+function normalizeDiscordDmOwnerEntry(entry: string): string | undefined {
+  const normalized = normalizeDiscordAllowList([entry], ["discord:", "user:", "pk:"]);
+  const candidate = normalized?.ids.values().next().value;
+  return typeof candidate === "string" && /^\d+$/.test(candidate) ? candidate : undefined;
+}
+
+export async function buildDiscordMessageProcessContext(params: {
+  ctx: DiscordMessagePreflightContext;
+  text: string;
+  mediaList: DiscordMediaInfo[];
+}) {
+  const { ctx, text, mediaList } = params;
+  const {
+    cfg,
+    discordConfig,
+    accountId,
+    runtime,
+    guildHistories,
+    historyLimit,
+    replyToMode,
+    message,
+    author,
+    sender,
+    data,
+    client,
+    channelInfo,
+    channelName,
+    messageChannelId,
+    isGuildMessage,
+    isDirectMessage,
+    baseText,
+    preflightAudioTranscript,
+    threadChannel,
+    threadParentId,
+    threadParentName,
+    threadParentType,
+    threadName,
+    displayChannelSlug,
+    guildInfo,
+    guildSlug,
+    memberRoleIds,
+    channelConfig,
+    baseSessionKey,
+    boundSessionKey,
+    route,
+    commandAuthorized,
+  } = ctx;
+
+  const fromLabel = isDirectMessage
+    ? buildDirectLabel(author)
+    : buildGuildLabel({
+        guild: data.guild ?? undefined,
+        channelName: channelName ?? messageChannelId,
+        channelId: messageChannelId,
+      });
+  const senderLabel = sender.label;
+  const isForumParent =
+    threadParentType === ChannelType.GuildForum || threadParentType === ChannelType.GuildMedia;
+  const forumParentSlug =
+    isForumParent && threadParentName ? normalizeDiscordSlug(threadParentName) : "";
+  const threadChannelId = threadChannel?.id;
+  const threadParentInheritanceEnabled = discordConfig?.thread?.inheritParent ?? false;
+  const isForumStarter =
+    Boolean(threadChannelId && isForumParent && forumParentSlug) && message.id === threadChannelId;
+  const forumContextLine = isForumStarter ? `[Forum parent: #${forumParentSlug}]` : null;
+  const groupChannel = isGuildMessage && displayChannelSlug ? `#${displayChannelSlug}` : undefined;
+  const groupSubject = isDirectMessage ? undefined : groupChannel;
+  const senderName = sender.isPluralKit
+    ? (sender.name ?? author.username)
+    : (data.member?.nickname ?? author.globalName ?? author.username);
+  const senderUsername = sender.isPluralKit
+    ? (sender.tag ?? sender.name ?? author.username)
+    : author.username;
+  const { groupSystemPrompt, ownerAllowFrom, untrustedContext } = buildDiscordInboundAccessContext({
+    channelConfig,
+    guildInfo,
+    sender: { id: sender.id, name: sender.name, tag: sender.tag },
+    allowNameMatching: isDangerousNameMatchingEnabled(discordConfig),
+    isGuild: isGuildMessage,
+    channelTopic: channelInfo?.topic,
+    messageBody: text,
+  });
+  const pinnedMainDmOwner = isDirectMessage
+    ? resolvePinnedMainDmOwnerFromAllowlist({
+        dmScope: cfg.session?.dmScope,
+        allowFrom: channelConfig?.users ?? guildInfo?.users,
+        normalizeEntry: normalizeDiscordDmOwnerEntry,
+      })
+    : null;
+  const contextVisibilityMode = resolveChannelContextVisibilityMode({
+    cfg,
+    channel: "discord",
+    accountId,
+  });
+  const allowNameMatching = isDangerousNameMatchingEnabled(discordConfig);
+  const isSupplementalContextSenderAllowed = createDiscordSupplementalContextAccessChecker({
+    channelConfig,
+    guildInfo,
+    allowNameMatching,
+    isGuild: isGuildMessage,
+  });
+  const storePath = resolveStorePath(cfg.session?.store, {
+    agentId: route.agentId,
+  });
+  const envelopeOptions = resolveEnvelopeFormatOptions(cfg);
+  const previousTimestamp = readSessionUpdatedAt({
+    storePath,
+    sessionKey: route.sessionKey,
+  });
+  let combinedBody = formatInboundEnvelope({
+    channel: "Discord",
+    from: fromLabel,
+    timestamp: resolveTimestampMs(message.timestamp),
+    body: text,
+    chatType: isDirectMessage ? "direct" : "channel",
+    senderLabel,
+    previousTimestamp,
+    envelope: envelopeOptions,
+  });
+  const shouldIncludeChannelHistory =
+    !isDirectMessage && !(isGuildMessage && channelConfig?.autoThread && !threadChannel);
+  if (shouldIncludeChannelHistory) {
+    combinedBody = buildPendingHistoryContextFromMap({
+      historyMap: guildHistories,
+      historyKey: messageChannelId,
+      limit: historyLimit,
+      currentMessage: combinedBody,
+      formatEntry: (entry) =>
+        formatInboundEnvelope({
+          channel: "Discord",
+          from: fromLabel,
+          timestamp: entry.timestamp,
+          body: `${entry.body} [id:${entry.messageId ?? "unknown"} channel:${messageChannelId}]`,
+          chatType: "channel",
+          senderLabel: entry.sender,
+          envelope: envelopeOptions,
+        }),
+    });
+  }
+  const replyContext = resolveReplyContext(message, resolveDiscordMessageText);
+  const replyVisibility = replyContext
+    ? evaluateSupplementalContextVisibility({
+        mode: contextVisibilityMode,
+        kind: "quote",
+        senderAllowed: isSupplementalContextSenderAllowed({
+          id: replyContext.senderId,
+          name: replyContext.senderName,
+          tag: replyContext.senderTag,
+          memberRoleIds: replyContext.memberRoleIds,
+        }),
+      })
+    : null;
+  const filteredReplyContext = replyContext && replyVisibility?.include ? replyContext : null;
+  if (replyContext && !filteredReplyContext && isGuildMessage) {
+    logVerbose(`discord: drop reply context (mode=${contextVisibilityMode})`);
+  }
+  if (forumContextLine) {
+    combinedBody = `${combinedBody}\n${forumContextLine}`;
+  }
+
+  let threadStarterBody: string | undefined;
+  let threadLabel: string | undefined;
+  let parentSessionKey: string | undefined;
+  let modelParentSessionKey: string | undefined;
+  if (threadChannel) {
+    const includeThreadStarter = channelConfig?.includeThreadStarter !== false;
+    if (includeThreadStarter) {
+      const starter = await resolveDiscordThreadStarter({
+        channel: threadChannel,
+        client,
+        parentId: threadParentId,
+        parentType: threadParentType,
+        resolveTimestampMs,
+      });
+      if (starter?.text) {
+        const starterVisibility = evaluateSupplementalContextVisibility({
+          mode: contextVisibilityMode,
+          kind: "thread",
+          senderAllowed: isSupplementalContextSenderAllowed({
+            id: starter.authorId,
+            name: starter.authorName ?? starter.author,
+            tag: starter.authorTag,
+            memberRoleIds: starter.memberRoleIds,
+          }),
+        });
+        if (starterVisibility.include) {
+          threadStarterBody = starter.text;
+        } else {
+          logVerbose(`discord: drop thread starter context (mode=${contextVisibilityMode})`);
+        }
+      }
+    }
+    const parentName = threadParentName ?? "parent";
+    threadLabel = threadName
+      ? `Discord thread #${normalizeDiscordSlug(parentName)} › ${threadName}`
+      : `Discord thread #${normalizeDiscordSlug(parentName)}`;
+    if (threadParentId) {
+      parentSessionKey = buildAgentSessionKey({
+        agentId: route.agentId,
+        channel: route.channel,
+        peer: { kind: "channel", id: threadParentId },
+      });
+      modelParentSessionKey = parentSessionKey;
+    }
+    if (!threadParentInheritanceEnabled) {
+      parentSessionKey = undefined;
+    }
+  }
+  const mediaPayload = buildDiscordMediaPayload(mediaList);
+  const preflightAudioIndex =
+    preflightAudioTranscript === undefined
+      ? -1
+      : mediaList.findIndex((media) => media.contentType?.startsWith("audio/"));
+  const threadKeys = resolveThreadSessionKeys({
+    baseSessionKey,
+    threadId: threadChannel ? messageChannelId : undefined,
+    parentSessionKey,
+    useSuffix: false,
+  });
+  const replyPlan = await resolveDiscordAutoThreadReplyPlan({
+    client,
+    message,
+    messageChannelId,
+    isGuildMessage,
+    channelConfig,
+    threadChannel,
+    channelType: channelInfo?.type,
+    channelName: channelInfo?.name,
+    channelDescription: channelInfo?.topic,
+    baseText: baseText ?? "",
+    combinedBody,
+    replyToMode,
+    agentId: route.agentId,
+    channel: route.channel,
+    cfg,
+    threadParentInheritanceEnabled,
+  });
+  const deliverTarget = replyPlan.deliverTarget;
+  const replyTarget = replyPlan.replyTarget;
+  const replyReference = replyPlan.replyReference;
+  const autoThreadContext = replyPlan.autoThreadContext;
+
+  const effectiveFrom = isDirectMessage
+    ? `discord:${author.id}`
+    : (autoThreadContext?.From ?? `discord:channel:${messageChannelId}`);
+  const dmConversationTarget = isDirectMessage
+    ? resolveDiscordConversationIdentity({
+        isDirectMessage,
+        userId: author.id,
+      })
+    : undefined;
+  const effectiveTo = autoThreadContext?.To ?? dmConversationTarget ?? replyTarget;
+  if (!effectiveTo) {
+    runtime.error?.(danger("discord: missing reply target"));
+    return null;
+  }
+  const lastRouteTo = dmConversationTarget ?? effectiveTo;
+  const inboundHistory =
+    shouldIncludeChannelHistory && historyLimit > 0
+      ? (guildHistories.get(messageChannelId) ?? []).map((entry) => ({
+          sender: entry.sender,
+          body: entry.body,
+          timestamp: entry.timestamp,
+        }))
+      : undefined;
+  const originatingTo = autoThreadContext?.OriginatingTo ?? dmConversationTarget ?? replyTarget;
+
+  const ctxPayload = finalizeInboundContext({
+    Body: combinedBody,
+    BodyForAgent: preflightAudioTranscript ?? baseText ?? text,
+    InboundHistory: inboundHistory,
+    RawBody: preflightAudioTranscript ?? baseText,
+    CommandBody: preflightAudioTranscript ?? baseText,
+    ...(preflightAudioTranscript !== undefined ? { Transcript: preflightAudioTranscript } : {}),
+    From: effectiveFrom,
+    To: effectiveTo,
+    SessionKey: boundSessionKey ?? autoThreadContext?.SessionKey ?? threadKeys.sessionKey,
+    AccountId: route.accountId,
+    ChatType: isDirectMessage ? "direct" : "channel",
+    ConversationLabel: fromLabel,
+    SenderName: senderName,
+    SenderId: sender.id,
+    SenderUsername: senderUsername,
+    SenderTag: sender.tag,
+    GroupSubject: groupSubject,
+    GroupChannel: groupChannel,
+    MemberRoleIds: memberRoleIds,
+    UntrustedContext: untrustedContext,
+    GroupSystemPrompt: isGuildMessage ? groupSystemPrompt : undefined,
+    GroupSpace: isGuildMessage ? (guildInfo?.id ?? guildSlug) || undefined : undefined,
+    OwnerAllowFrom: ownerAllowFrom,
+    Provider: "discord" as const,
+    Surface: "discord" as const,
+    WasMentioned: ctx.effectiveWasMentioned,
+    MessageSid: message.id,
+    ReplyToId: filteredReplyContext?.id,
+    ReplyToBody: filteredReplyContext?.body,
+    ReplyToSender: filteredReplyContext?.sender,
+    ParentSessionKey: autoThreadContext?.ParentSessionKey ?? threadKeys.parentSessionKey,
+    ModelParentSessionKey:
+      autoThreadContext?.ModelParentSessionKey ?? modelParentSessionKey ?? undefined,
+    MessageThreadId: threadChannel?.id ?? autoThreadContext?.createdThreadId ?? undefined,
+    ThreadStarterBody: threadStarterBody,
+    ThreadLabel: threadLabel,
+    Timestamp: resolveTimestampMs(message.timestamp),
+    ...mediaPayload,
+    ...(preflightAudioIndex >= 0 ? { MediaTranscribedIndexes: [preflightAudioIndex] } : {}),
+    CommandAuthorized: commandAuthorized,
+    CommandSource: "text" as const,
+    OriginatingChannel: "discord" as const,
+    OriginatingTo: originatingTo,
+  });
+  const persistedSessionKey = ctxPayload.SessionKey ?? route.sessionKey;
+
+  if (shouldLogVerbose()) {
+    const preview = truncateUtf16Safe(combinedBody, 200).replace(/\n/g, "\\n");
+    logVerbose(
+      `discord inbound: channel=${messageChannelId} deliver=${deliverTarget} from=${ctxPayload.From} preview="${preview}"`,
+    );
+  }
+
+  return {
+    ctxPayload,
+    persistedSessionKey,
+    turn: {
+      storePath,
+      record: {
+        updateLastRoute: {
+          sessionKey: persistedSessionKey,
+          channel: "discord",
+          to: lastRouteTo,
+          accountId: route.accountId,
+          mainDmOwnerPin:
+            isDirectMessage && persistedSessionKey === route.mainSessionKey && pinnedMainDmOwner
+              ? {
+                  ownerRecipient: pinnedMainDmOwner,
+                  senderRecipient: author.id,
+                  onSkip: ({
+                    ownerRecipient,
+                    senderRecipient,
+                  }: {
+                    ownerRecipient: string;
+                    senderRecipient: string;
+                  }) => {
+                    logVerbose(
+                      `discord: skip main-session last route for ${senderRecipient} (pinned owner ${ownerRecipient})`,
+                    );
+                  },
+                }
+              : undefined,
+        },
+        onRecordError: (err: unknown) => {
+          logVerbose(`discord: failed updating session meta: ${String(err)}`);
+        },
+      },
+    },
+    replyPlan,
+    deliverTarget,
+    replyTarget,
+    replyReference,
+  };
+}

package/src/monitor/message-handler.dm-preflight.ts

@@ -0,0 +1,123 @@
+import { formatAllowlistMatchMeta } from "openclaw/plugin-sdk/allow-from";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { resolveDiscordConversationIdentity } from "../conversation-identity.js";
+import type { User } from "../internal/discord.js";
+import { resolveDiscordDmCommandAccess, type DiscordDmPolicy } from "./dm-command-auth.js";
+import { handleDiscordDmCommandDecision } from "./dm-command-decision.js";
+import { formatDiscordUserTag } from "./format.js";
+import type {
+  DiscordMessagePreflightParams,
+  DiscordSenderIdentity,
+} from "./message-handler.preflight.types.js";
+
+let conversationRuntimePromise:
+  | Promise<typeof import("openclaw/plugin-sdk/conversation-binding-runtime")>
+  | undefined;
+let discordSendRuntimePromise: Promise<typeof import("../send.js")> | undefined;
+
+async function loadConversationRuntime() {
+  conversationRuntimePromise ??= import("openclaw/plugin-sdk/conversation-binding-runtime");
+  return await conversationRuntimePromise;
+}
+
+async function loadDiscordSendRuntime() {
+  discordSendRuntimePromise ??= import("../send.js");
+  return await discordSendRuntimePromise;
+}
+
+export async function resolveDiscordDmPreflightAccess(params: {
+  preflight: DiscordMessagePreflightParams;
+  author: User;
+  sender: DiscordSenderIdentity;
+  dmPolicy: DiscordDmPolicy;
+  resolvedAccountId: string;
+  allowNameMatching: boolean;
+  useAccessGroups: boolean;
+}): Promise<{ commandAuthorized: boolean } | null> {
+  if (params.dmPolicy === "disabled") {
+    logVerbose("discord: drop dm (dmPolicy: disabled)");
+    return null;
+  }
+
+  const directBindingConversationId =
+    resolveDiscordConversationIdentity({
+      isDirectMessage: true,
+      userId: params.author.id,
+    }) ?? `user:${params.author.id}`;
+  const directBindingRecord = (await loadConversationRuntime())
+    .getSessionBindingService()
+    .resolveByConversation({
+      channel: "discord",
+      accountId: params.preflight.accountId,
+      conversationId: directBindingConversationId,
+    });
+  const dmAccess = await resolveDiscordDmCommandAccess({
+    accountId: params.resolvedAccountId,
+    dmPolicy: params.dmPolicy,
+    configuredAllowFrom: params.preflight.allowFrom ?? [],
+    sender: {
+      id: params.sender.id,
+      name: params.sender.name,
+      tag: params.sender.tag,
+    },
+    allowNameMatching: params.allowNameMatching,
+    useAccessGroups: params.useAccessGroups,
+    cfg: params.preflight.cfg,
+    token: params.preflight.token,
+    rest: params.preflight.client.rest,
+  });
+  const commandAuthorized = dmAccess.commandAuthorized || directBindingRecord != null;
+  if (dmAccess.decision === "allow") {
+    return { commandAuthorized };
+  }
+  if (directBindingRecord) {
+    logVerbose(
+      `discord: allow bound DM conversation ${directBindingConversationId} despite dmPolicy=${params.dmPolicy}`,
+    );
+    return { commandAuthorized };
+  }
+
+  const allowMatchMeta = formatAllowlistMatchMeta(
+    dmAccess.allowMatch.allowed ? dmAccess.allowMatch : undefined,
+  );
+  await handleDiscordDmCommandDecision({
+    dmAccess,
+    accountId: params.resolvedAccountId,
+    sender: {
+      id: params.author.id,
+      tag: formatDiscordUserTag(params.author),
+      name: params.author.username ?? undefined,
+    },
+    onPairingCreated: async (code) => {
+      logVerbose(
+        `discord pairing request sender=${params.author.id} tag=${formatDiscordUserTag(params.author)} (${allowMatchMeta})`,
+      );
+      try {
+        const conversationRuntime = await loadConversationRuntime();
+        const { sendMessageDiscord } = await loadDiscordSendRuntime();
+        await sendMessageDiscord(
+          `user:${params.author.id}`,
+          conversationRuntime.buildPairingReply({
+            channel: "discord",
+            idLine: `Your Discord user id: ${params.author.id}`,
+            code,
+          }),
+          {
+            cfg: params.preflight.cfg,
+            token: params.preflight.token,
+            rest: params.preflight.client.rest,
+            accountId: params.preflight.accountId,
+          },
+        );
+      } catch (err) {
+        logVerbose(`discord pairing reply failed for ${params.author.id}: ${String(err)}`);
+      }
+    },
+    onUnauthorized: async () => {
+      logVerbose(
+        `Blocked unauthorized discord sender ${params.sender.id} (dmPolicy=${params.dmPolicy}, ${allowMatchMeta})`,
+      );
+    },
+  });
+  return null;
+}