@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/monitor/agent-components.dispatch.ts

@@ -1,366 +0,0 @@
-import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
-import {
-  formatInboundEnvelope,
-  resolveEnvelopeFormatOptions,
-} from "openclaw/plugin-sdk/channel-inbound";
-import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
-import { runInboundReplyTurn } from "openclaw/plugin-sdk/inbound-reply-dispatch";
-import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
-import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
-import { createNonExitingRuntime, logVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { logError } from "openclaw/plugin-sdk/text-runtime";
-import { resolveDiscordMaxLinesPerMessage } from "../accounts.js";
-import { createDiscordRestClient } from "../client.js";
-import { resolveDiscordConversationIdentity } from "../conversation-identity.js";
-import {
-  resolveAgentComponentRoute,
-  resolveComponentCommandAuthorized,
-  resolvePinnedMainDmOwnerFromAllowlist,
-  type AgentComponentContext,
-  type AgentComponentInteraction,
-  type ComponentInteractionContext,
-  type DiscordChannelContext,
-} from "./agent-components-helpers.js";
-import { readSessionUpdatedAt, resolveStorePath } from "./agent-components.deps.runtime.js";
-import {
-  normalizeDiscordAllowList,
-  resolveDiscordChannelConfigWithFallback,
-  resolveDiscordGuildEntry,
-} from "./allow-list.js";
-import { formatDiscordUserTag } from "./format.js";
-import {
-  buildDiscordGroupSystemPrompt,
-  buildDiscordInboundAccessContext,
-} from "./inbound-context.js";
-import { buildDirectLabel, buildGuildLabel } from "./reply-context.js";
-import { deliverDiscordReply } from "./reply-delivery.js";
-
-let conversationRuntimePromise: Promise<typeof import("./agent-components.runtime.js")> | undefined;
-let replyPipelineRuntimePromise:
-  | Promise<typeof import("openclaw/plugin-sdk/channel-reply-pipeline")>
-  | undefined;
-let typingRuntimePromise: Promise<typeof import("./typing.js")> | undefined;
-
-async function loadConversationRuntime() {
-  conversationRuntimePromise ??= import("./agent-components.runtime.js");
-  return await conversationRuntimePromise;
-}
-
-async function loadReplyPipelineRuntime() {
-  replyPipelineRuntimePromise ??= import("openclaw/plugin-sdk/channel-reply-pipeline");
-  return await replyPipelineRuntimePromise;
-}
-
-async function loadTypingRuntime() {
-  typingRuntimePromise ??= import("./typing.js");
-  return await typingRuntimePromise;
-}
-
-function buildDiscordComponentConversationLabel(params: {
-  interactionCtx: ComponentInteractionContext;
-  interaction: AgentComponentInteraction;
-  channelCtx: DiscordChannelContext;
-}) {
-  if (params.interactionCtx.isDirectMessage) {
-    return buildDirectLabel(params.interactionCtx.user);
-  }
-  if (params.interactionCtx.isGroupDm) {
-    return `Group DM #${params.channelCtx.channelName ?? params.interactionCtx.channelId} channel id:${params.interactionCtx.channelId}`;
-  }
-  return buildGuildLabel({
-    guild: params.interaction.guild ?? undefined,
-    channelName: params.channelCtx.channelName ?? params.interactionCtx.channelId,
-    channelId: params.interactionCtx.channelId,
-  });
-}
-
-function resolveDiscordComponentChatType(interactionCtx: ComponentInteractionContext) {
-  if (interactionCtx.isDirectMessage) {
-    return "direct";
-  }
-  if (interactionCtx.isGroupDm) {
-    return "group";
-  }
-  return "channel";
-}
-
-export function resolveDiscordComponentOriginatingTo(
-  interactionCtx: Pick<ComponentInteractionContext, "isDirectMessage" | "userId" | "channelId">,
-) {
-  return resolveDiscordConversationIdentity({
-    isDirectMessage: interactionCtx.isDirectMessage,
-    userId: interactionCtx.userId,
-    channelId: interactionCtx.channelId,
-  });
-}
-
-export async function dispatchDiscordComponentEvent(params: {
-  ctx: AgentComponentContext;
-  interaction: AgentComponentInteraction;
-  interactionCtx: ComponentInteractionContext;
-  channelCtx: DiscordChannelContext;
-  guildInfo: ReturnType<typeof resolveDiscordGuildEntry>;
-  eventText: string;
-  replyToId?: string;
-  routeOverrides?: { sessionKey?: string; agentId?: string; accountId?: string };
-}): Promise<void> {
-  const { ctx, interaction, interactionCtx, channelCtx, guildInfo, eventText } = params;
-  const runtime = ctx.runtime ?? createNonExitingRuntime();
-  const route = resolveAgentComponentRoute({
-    ctx,
-    rawGuildId: interactionCtx.rawGuildId,
-    memberRoleIds: interactionCtx.memberRoleIds,
-    isDirectMessage: interactionCtx.isDirectMessage,
-    isGroupDm: interactionCtx.isGroupDm,
-    userId: interactionCtx.userId,
-    channelId: interactionCtx.channelId,
-    parentId: channelCtx.parentId,
-  });
-  const sessionKey = params.routeOverrides?.sessionKey ?? route.sessionKey;
-  const agentId = params.routeOverrides?.agentId ?? route.agentId;
-  const accountId = params.routeOverrides?.accountId ?? route.accountId;
-  const fromLabel = buildDiscordComponentConversationLabel({
-    interactionCtx,
-    interaction,
-    channelCtx,
-  });
-  const chatType = resolveDiscordComponentChatType(interactionCtx);
-  const senderName = interactionCtx.user.globalName ?? interactionCtx.user.username;
-  const senderUsername = interactionCtx.user.username;
-  const senderTag = formatDiscordUserTag(interactionCtx.user);
-  const groupChannel =
-    !interactionCtx.isDirectMessage && channelCtx.displayChannelSlug
-      ? `#${channelCtx.displayChannelSlug}`
-      : undefined;
-  const groupSubject = interactionCtx.isDirectMessage ? undefined : groupChannel;
-  const channelConfig = resolveDiscordChannelConfigWithFallback({
-    guildInfo,
-    channelId: interactionCtx.channelId,
-    channelName: channelCtx.channelName,
-    channelSlug: channelCtx.channelSlug,
-    parentId: channelCtx.parentId,
-    parentName: channelCtx.parentName,
-    parentSlug: channelCtx.parentSlug,
-    scope: channelCtx.isThread ? "thread" : "channel",
-  });
-  const allowNameMatching = isDangerousNameMatchingEnabled(ctx.discordConfig);
-  const { ownerAllowFrom } = buildDiscordInboundAccessContext({
-    channelConfig,
-    guildInfo,
-    sender: { id: interactionCtx.user.id, name: interactionCtx.user.username, tag: senderTag },
-    allowNameMatching,
-    isGuild: !interactionCtx.isDirectMessage,
-  });
-  const groupSystemPrompt = buildDiscordGroupSystemPrompt(channelConfig);
-  const pinnedMainDmOwner = interactionCtx.isDirectMessage
-    ? resolvePinnedMainDmOwnerFromAllowlist({
-        dmScope: ctx.cfg.session?.dmScope,
-        allowFrom: channelConfig?.users ?? guildInfo?.users,
-        normalizeEntry: (entry: string) => {
-          const normalized = normalizeDiscordAllowList([entry], ["discord:", "user:", "pk:"]);
-          const candidate = normalized?.ids.values().next().value;
-          return typeof candidate === "string" && /^\d+$/.test(candidate) ? candidate : undefined;
-        },
-      })
-    : null;
-  const commandAuthorized = resolveComponentCommandAuthorized({
-    ctx,
-    interactionCtx,
-    channelConfig,
-    guildInfo,
-    allowNameMatching,
-  });
-  const storePath = resolveStorePath(ctx.cfg.session?.store, { agentId });
-  const envelopeOptions = resolveEnvelopeFormatOptions(ctx.cfg);
-  const previousTimestamp = readSessionUpdatedAt({
-    storePath,
-    sessionKey,
-  });
-  const timestamp = Date.now();
-  const combinedBody = formatInboundEnvelope({
-    channel: "Discord",
-    from: fromLabel,
-    timestamp,
-    body: eventText,
-    chatType,
-    senderLabel: senderName,
-    previousTimestamp,
-    envelope: envelopeOptions,
-  });
-
-  const {
-    createReplyReferencePlanner,
-    dispatchReplyWithBufferedBlockDispatcher,
-    finalizeInboundContext,
-    resolveChunkMode,
-    resolveTextChunkLimit,
-    recordInboundSession,
-  } = await (async () => {
-    const conversationRuntime = await loadConversationRuntime();
-    return {
-      ...conversationRuntime,
-    };
-  })();
-
-  const ctxPayload = finalizeInboundContext({
-    Body: combinedBody,
-    BodyForAgent: eventText,
-    RawBody: eventText,
-    CommandBody: eventText,
-    From: interactionCtx.isDirectMessage
-      ? `discord:${interactionCtx.userId}`
-      : interactionCtx.isGroupDm
-        ? `discord:group:${interactionCtx.channelId}`
-        : `discord:channel:${interactionCtx.channelId}`,
-    To: `channel:${interactionCtx.channelId}`,
-    SessionKey: sessionKey,
-    AccountId: accountId,
-    ChatType: chatType,
-    ConversationLabel: fromLabel,
-    SenderName: senderName,
-    SenderId: interactionCtx.userId,
-    SenderUsername: senderUsername,
-    SenderTag: senderTag,
-    GroupSubject: groupSubject,
-    GroupChannel: groupChannel,
-    MemberRoleIds: interactionCtx.memberRoleIds,
-    GroupSystemPrompt: interactionCtx.isDirectMessage ? undefined : groupSystemPrompt,
-    GroupSpace: guildInfo?.id ?? guildInfo?.slug ?? interactionCtx.rawGuildId ?? undefined,
-    OwnerAllowFrom: ownerAllowFrom,
-    Provider: "discord" as const,
-    Surface: "discord" as const,
-    WasMentioned: true,
-    CommandAuthorized: commandAuthorized,
-    CommandSource: "text" as const,
-    MessageSid: interaction.rawData.id,
-    Timestamp: timestamp,
-    OriginatingChannel: "discord" as const,
-    OriginatingTo:
-      resolveDiscordComponentOriginatingTo(interactionCtx) ?? `channel:${interactionCtx.channelId}`,
-  });
-
-  const deliverTarget = `channel:${interactionCtx.channelId}`;
-  const typingChannelId = interactionCtx.channelId;
-  const { createChannelReplyPipeline } = await loadReplyPipelineRuntime();
-  const { onModelSelected, ...replyPipeline } = createChannelReplyPipeline({
-    cfg: ctx.cfg,
-    agentId,
-    channel: "discord",
-    accountId,
-  });
-  const tableMode = resolveMarkdownTableMode({
-    cfg: ctx.cfg,
-    channel: "discord",
-    accountId,
-  });
-  const textLimit = resolveTextChunkLimit(ctx.cfg, "discord", accountId, {
-    fallbackLimit: 2000,
-  });
-  const token = ctx.token ?? "";
-  const feedbackRest = createDiscordRestClient({
-    cfg: ctx.cfg,
-    token,
-    accountId,
-  }).rest;
-  const mediaLocalRoots = getAgentScopedMediaLocalRoots(ctx.cfg, agentId);
-  const replyToMode =
-    ctx.discordConfig?.replyToMode ?? ctx.cfg.channels?.discord?.replyToMode ?? "off";
-  const replyReference = createReplyReferencePlanner({
-    replyToMode,
-    startId: params.replyToId,
-  });
-
-  await runInboundReplyTurn({
-    channel: "discord",
-    accountId,
-    raw: interaction,
-    adapter: {
-      ingest: () => ({
-        id: interaction.id,
-        rawText: ctxPayload.RawBody ?? "",
-        textForAgent: ctxPayload.BodyForAgent,
-        textForCommands: ctxPayload.CommandBody,
-        raw: interaction,
-      }),
-      resolveTurn: () => ({
-        channel: "discord",
-        accountId,
-        routeSessionKey: sessionKey,
-        storePath,
-        ctxPayload,
-        recordInboundSession,
-        record: {
-          updateLastRoute: interactionCtx.isDirectMessage
-            ? {
-                sessionKey: route.mainSessionKey,
-                channel: "discord",
-                to:
-                  resolveDiscordComponentOriginatingTo(interactionCtx) ??
-                  `user:${interactionCtx.userId}`,
-                accountId,
-                mainDmOwnerPin: pinnedMainDmOwner
-                  ? {
-                      ownerRecipient: pinnedMainDmOwner,
-                      senderRecipient: interactionCtx.userId,
-                      onSkip: ({ ownerRecipient, senderRecipient }) => {
-                        logVerbose(
-                          `discord: skip main-session last route for ${senderRecipient} (pinned owner ${ownerRecipient})`,
-                        );
-                      },
-                    }
-                  : undefined,
-              }
-            : undefined,
-          onRecordError: (err) => {
-            logVerbose(`discord: failed updating component session meta: ${String(err)}`);
-          },
-        },
-        runDispatch: () =>
-          dispatchReplyWithBufferedBlockDispatcher({
-            ctx: ctxPayload,
-            cfg: ctx.cfg,
-            replyOptions: { onModelSelected },
-            dispatcherOptions: {
-              ...replyPipeline,
-              humanDelay: resolveHumanDelayConfig(ctx.cfg, agentId),
-              deliver: async (payload) => {
-                const replyToId = replyReference.use();
-                await deliverDiscordReply({
-                  cfg: ctx.cfg,
-                  replies: [payload],
-                  target: deliverTarget,
-                  token,
-                  accountId,
-                  rest: interaction.client.rest,
-                  runtime,
-                  replyToId,
-                  replyToMode,
-                  textLimit,
-                  maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
-                    cfg: ctx.cfg,
-                    discordConfig: ctx.discordConfig,
-                    accountId,
-                  }),
-                  tableMode,
-                  chunkMode: resolveChunkMode(ctx.cfg, "discord", accountId),
-                  mediaLocalRoots,
-                });
-                replyReference.markSent();
-              },
-              onReplyStart: async () => {
-                try {
-                  const { sendTyping } = await loadTypingRuntime();
-                  await sendTyping({ rest: feedbackRest, channelId: typingChannelId });
-                } catch (err) {
-                  logVerbose(`discord: typing failed for component reply: ${String(err)}`);
-                }
-              },
-              onError: (err) => {
-                logError(`discord component dispatch failed: ${String(err)}`);
-              },
-            },
-          }),
-      }),
-    },
-  });
-}

package/src/monitor/agent-components.handlers.ts

@@ -1,303 +0,0 @@
-import { logError } from "openclaw/plugin-sdk/text-runtime";
-import {
-  resolveDiscordComponentEntryWithPersistence,
-  resolveDiscordModalEntryWithPersistence,
-} from "../components-registry.js";
-import type { ButtonInteraction, ComponentData } from "../internal/discord.js";
-import {
-  type AgentComponentContext,
-  type AgentComponentMessageInteraction,
-  ensureComponentUserAllowed,
-  mapSelectValues,
-  parseDiscordComponentData,
-  resolveAuthorizedComponentInteraction,
-  resolveInteractionCustomId,
-} from "./agent-components-helpers.js";
-import { dispatchDiscordComponentEvent } from "./agent-components.dispatch.js";
-import { dispatchPluginDiscordInteractiveEvent } from "./agent-components.plugin-interactive.js";
-import type { DiscordComponentControlHandlers } from "./agent-components.wildcard-controls.js";
-
-let componentsRuntimePromise: Promise<typeof import("../components.js")> | undefined;
-
-async function loadComponentsRuntime() {
-  componentsRuntimePromise ??= import("../components.js");
-  return await componentsRuntimePromise;
-}
-
-async function handleDiscordComponentEvent(params: {
-  ctx: AgentComponentContext;
-  interaction: AgentComponentMessageInteraction;
-  data: ComponentData;
-  componentLabel: string;
-  values?: string[];
-  label: string;
-}): Promise<void> {
-  const parsed = parseDiscordComponentData(
-    params.data,
-    resolveInteractionCustomId(params.interaction),
-  );
-  if (!parsed) {
-    logError(`${params.label}: failed to parse component data`);
-    try {
-      await params.interaction.reply({
-        content: "This component is no longer valid.",
-        ephemeral: true,
-      });
-    } catch {
-      // Interaction may have expired
-    }
-    return;
-  }
-
-  const entry = await resolveDiscordComponentEntryWithPersistence({
-    id: parsed.componentId,
-    consume: false,
-  });
-  if (!entry) {
-    try {
-      await params.interaction.reply({
-        content: "This component has expired.",
-        ephemeral: true,
-      });
-    } catch {
-      // Interaction may have expired
-    }
-    return;
-  }
-
-  const unauthorizedReply = `You are not authorized to use this ${params.componentLabel}.`;
-  const authorized = await resolveAuthorizedComponentInteraction({
-    ctx: params.ctx,
-    interaction: params.interaction,
-    label: params.label,
-    componentLabel: params.componentLabel,
-    unauthorizedReply,
-    defer: false,
-  });
-  if (!authorized) {
-    return;
-  }
-  const {
-    interactionCtx,
-    channelCtx,
-    guildInfo,
-    allowNameMatching,
-    commandAuthorized,
-    user,
-    replyOpts,
-  } = authorized;
-
-  const componentAllowed = await ensureComponentUserAllowed({
-    entry,
-    interaction: params.interaction,
-    user,
-    replyOpts,
-    componentLabel: params.componentLabel,
-    unauthorizedReply,
-    allowNameMatching,
-  });
-  if (!componentAllowed) {
-    return;
-  }
-  const consumed = await resolveDiscordComponentEntryWithPersistence({
-    id: parsed.componentId,
-    consume: !entry.reusable,
-  });
-  if (!consumed) {
-    try {
-      await params.interaction.reply({
-        content: "This component has expired.",
-        ephemeral: true,
-      });
-    } catch {
-      // Interaction may have expired
-    }
-    return;
-  }
-
-  if (consumed.kind === "modal-trigger") {
-    try {
-      await params.interaction.reply({
-        content: "This form is no longer available.",
-        ephemeral: true,
-      });
-    } catch {
-      // Interaction may have expired
-    }
-    return;
-  }
-
-  const values = params.values ? mapSelectValues(consumed, params.values) : undefined;
-  if (consumed.callbackData) {
-    const pluginDispatch = await dispatchPluginDiscordInteractiveEvent({
-      ctx: params.ctx,
-      interaction: params.interaction,
-      interactionCtx,
-      channelCtx,
-      isAuthorizedSender: commandAuthorized,
-      data: consumed.callbackData,
-      kind: consumed.kind === "select" ? "select" : "button",
-      values,
-      messageId: consumed.messageId ?? params.interaction.message?.id,
-    });
-    if (pluginDispatch === "handled") {
-      return;
-    }
-  }
-  // Preserve explicit callback payloads for button fallbacks so Discord
-  // behaves like Telegram when buttons carry synthetic command text. Select
-  // fallbacks still need their chosen values in the synthesized event text.
-  const eventText =
-    (consumed.kind === "button" ? consumed.callbackData?.trim() : undefined) ||
-    (await loadComponentsRuntime()).formatDiscordComponentEventText({
-      kind: consumed.kind === "select" ? "select" : "button",
-      label: consumed.label,
-      values,
-    });
-
-  try {
-    await params.interaction.reply({ content: "✓", ...replyOpts });
-  } catch (err) {
-    logError(`${params.label}: failed to acknowledge interaction: ${String(err)}`);
-  }
-
-  await dispatchDiscordComponentEvent({
-    ctx: params.ctx,
-    interaction: params.interaction,
-    interactionCtx,
-    channelCtx,
-    guildInfo,
-    eventText,
-    replyToId: consumed.messageId ?? params.interaction.message?.id,
-    routeOverrides: {
-      sessionKey: consumed.sessionKey,
-      agentId: consumed.agentId,
-      accountId: consumed.accountId,
-    },
-  });
-}
-
-async function handleDiscordModalTrigger(params: {
-  ctx: AgentComponentContext;
-  interaction: ButtonInteraction;
-  data: ComponentData;
-  label: string;
-}): Promise<void> {
-  const parsed = parseDiscordComponentData(
-    params.data,
-    resolveInteractionCustomId(params.interaction),
-  );
-  if (!parsed) {
-    logError(`${params.label}: failed to parse modal trigger data`);
-    try {
-      await params.interaction.reply({
-        content: "This button is no longer valid.",
-        ephemeral: true,
-      });
-    } catch {
-      // Interaction may have expired
-    }
-    return;
-  }
-  const entry = await resolveDiscordComponentEntryWithPersistence({
-    id: parsed.componentId,
-    consume: false,
-  });
-  if (!entry || entry.kind !== "modal-trigger") {
-    try {
-      await params.interaction.reply({
-        content: "This button has expired.",
-        ephemeral: true,
-      });
-    } catch {
-      // Interaction may have expired
-    }
-    return;
-  }
-
-  const modalId = entry.modalId ?? parsed.modalId;
-  if (!modalId) {
-    try {
-      await params.interaction.reply({
-        content: "This form is no longer available.",
-        ephemeral: true,
-      });
-    } catch {
-      // Interaction may have expired
-    }
-    return;
-  }
-
-  const unauthorizedReply = "You are not authorized to use this form.";
-  const authorized = await resolveAuthorizedComponentInteraction({
-    ctx: params.ctx,
-    interaction: params.interaction,
-    label: params.label,
-    componentLabel: "form",
-    unauthorizedReply,
-    defer: false,
-  });
-  if (!authorized) {
-    return;
-  }
-  const { user, replyOpts, allowNameMatching } = authorized;
-
-  const componentAllowed = await ensureComponentUserAllowed({
-    entry,
-    interaction: params.interaction,
-    user,
-    replyOpts,
-    componentLabel: "form",
-    unauthorizedReply,
-    allowNameMatching,
-  });
-  if (!componentAllowed) {
-    return;
-  }
-
-  const consumed = await resolveDiscordComponentEntryWithPersistence({
-    id: parsed.componentId,
-    consume: !entry.reusable,
-  });
-  if (!consumed) {
-    try {
-      await params.interaction.reply({
-        content: "This form has expired.",
-        ephemeral: true,
-      });
-    } catch {
-      // Interaction may have expired
-    }
-    return;
-  }
-
-  const resolvedModalId = consumed.modalId ?? modalId;
-  const modalEntry = await resolveDiscordModalEntryWithPersistence({
-    id: resolvedModalId,
-    consume: false,
-  });
-  if (!modalEntry) {
-    try {
-      await params.interaction.reply({
-        content: "This form has expired.",
-        ephemeral: true,
-      });
-    } catch {
-      // Interaction may have expired
-    }
-    return;
-  }
-
-  try {
-    await params.interaction.showModal(
-      (await loadComponentsRuntime()).createDiscordFormModal(modalEntry),
-    );
-  } catch (err) {
-    logError(`${params.label}: failed to show modal: ${String(err)}`);
-  }
-}
-
-export const discordComponentControlHandlers: DiscordComponentControlHandlers = {
-  handleComponentEvent: handleDiscordComponentEvent,
-  handleModalTrigger: handleDiscordModalTrigger,
-};