@openclaw/discord 2026.3.13 → 2026.5.2-beta.1

package/src/inbound-context.contract.test.ts

@@ -0,0 +1,11 @@
+import { expectChannelInboundContextContract } from "openclaw/plugin-sdk/channel-contract-testing";
+import { describe, it } from "vitest";
+import { buildFinalizedDiscordDirectInboundContext } from "./monitor/inbound-context.test-helpers.js";
+
+describe("Discord inbound context contract", () => {
+  it("keeps inbound context finalized", () => {
+    const ctx = buildFinalizedDiscordDirectInboundContext();
+
+    expectChannelInboundContextContract(ctx);
+  });
+});

package/src/interactive-dispatch.ts

@@ -0,0 +1,104 @@
+import type { ChannelStructuredComponents } from "openclaw/plugin-sdk/channel-contract";
+import {
+  createInteractiveConversationBindingHelpers,
+  dispatchPluginInteractiveHandler,
+  type PluginConversationBinding,
+  type PluginConversationBindingRequestParams,
+  type PluginConversationBindingRequestResult,
+  type PluginInteractiveRegistration,
+} from "openclaw/plugin-sdk/plugin-runtime";
+
+export type DiscordInteractiveHandlerContext = {
+  channel: "discord";
+  accountId: string;
+  interactionId: string;
+  conversationId: string;
+  parentConversationId?: string;
+  guildId?: string;
+  senderId?: string;
+  senderUsername?: string;
+  auth: {
+    isAuthorizedSender: boolean;
+  };
+  interaction: {
+    kind: "button" | "select" | "modal";
+    data: string;
+    namespace: string;
+    payload: string;
+    messageId?: string;
+    values?: string[];
+    fields?: Array<{ id: string; name: string; values: string[] }>;
+  };
+  respond: {
+    acknowledge: () => Promise<void>;
+    reply: (params: { text: string; ephemeral?: boolean }) => Promise<void>;
+    followUp: (params: { text: string; ephemeral?: boolean }) => Promise<void>;
+    editMessage: (params: {
+      text?: string;
+      components?: ChannelStructuredComponents;
+    }) => Promise<void>;
+    clearComponents: (params?: { text?: string }) => Promise<void>;
+  };
+  requestConversationBinding: (
+    params?: PluginConversationBindingRequestParams,
+  ) => Promise<PluginConversationBindingRequestResult>;
+  detachConversationBinding: () => Promise<{ removed: boolean }>;
+  getCurrentConversationBinding: () => Promise<PluginConversationBinding | null>;
+};
+
+export type DiscordInteractiveHandlerRegistration = PluginInteractiveRegistration<
+  DiscordInteractiveHandlerContext,
+  "discord"
+>;
+
+type DiscordInteractiveDispatchContext = Omit<
+  DiscordInteractiveHandlerContext,
+  | "interaction"
+  | "respond"
+  | "channel"
+  | "requestConversationBinding"
+  | "detachConversationBinding"
+  | "getCurrentConversationBinding"
+> & {
+  interaction: Omit<
+    DiscordInteractiveHandlerContext["interaction"],
+    "data" | "namespace" | "payload"
+  >;
+};
+
+export async function dispatchDiscordPluginInteractiveHandler(params: {
+  data: string;
+  interactionId: string;
+  ctx: DiscordInteractiveDispatchContext;
+  respond: DiscordInteractiveHandlerContext["respond"];
+  onMatched?: () => Promise<void> | void;
+}) {
+  return await dispatchPluginInteractiveHandler<DiscordInteractiveHandlerRegistration>({
+    channel: "discord",
+    data: params.data,
+    dedupeId: params.interactionId,
+    onMatched: params.onMatched,
+    invoke: ({ registration, namespace, payload }) =>
+      registration.handler({
+        ...params.ctx,
+        channel: "discord",
+        interaction: {
+          ...params.ctx.interaction,
+          data: params.data,
+          namespace,
+          payload,
+        },
+        respond: params.respond,
+        ...createInteractiveConversationBindingHelpers({
+          registration,
+          senderId: params.ctx.senderId,
+          conversation: {
+            channel: "discord",
+            accountId: params.ctx.accountId,
+            conversationId: params.ctx.conversationId,
+            parentConversationId: params.ctx.parentConversationId,
+          },
+        }),
+      }),
+  });
+}

package/src/internal/api.commands.ts

@@ -0,0 +1,51 @@
+import { Routes, type APIApplicationCommand } from "discord-api-types/v10";
+import type { RequestClient } from "./rest.js";
+
+export async function listApplicationCommands(
+  rest: RequestClient,
+  clientId: string,
+): Promise<APIApplicationCommand[]> {
+  return (await rest.get(Routes.applicationCommands(clientId))) as APIApplicationCommand[];
+}
+
+export async function createApplicationCommand(
+  rest: RequestClient,
+  clientId: string,
+  body: unknown,
+): Promise<unknown> {
+  return await rest.post(Routes.applicationCommands(clientId), { body });
+}
+
+export async function editApplicationCommand(
+  rest: RequestClient,
+  clientId: string,
+  commandId: string,
+  body: unknown,
+): Promise<unknown> {
+  return await rest.patch(Routes.applicationCommand(clientId, commandId), { body });
+}
+
+export async function deleteApplicationCommand(
+  rest: RequestClient,
+  clientId: string,
+  commandId: string,
+): Promise<void> {
+  await rest.delete(Routes.applicationCommand(clientId, commandId));
+}
+
+export async function overwriteApplicationCommands(
+  rest: RequestClient,
+  clientId: string,
+  body: unknown,
+): Promise<void> {
+  await rest.put(Routes.applicationCommands(clientId), { body });
+}
+
+export async function overwriteGuildApplicationCommands(
+  rest: RequestClient,
+  clientId: string,
+  guildId: string,
+  body: unknown,
+): Promise<void> {
+  await rest.put(Routes.applicationGuildCommands(clientId, guildId), { body });
+}

package/src/internal/api.guild.ts

@@ -0,0 +1,164 @@
+import {
+  Routes,
+  type APIChannel,
+  type APIGuild,
+  type APIGuildMember,
+  type APIGuildScheduledEvent,
+  type APIRole,
+  type APIVoiceState,
+  type RESTPostAPIGuildScheduledEventJSONBody,
+} from "discord-api-types/v10";
+import type { RequestClient, RequestData } from "./rest.js";
+
+export async function getGuild(rest: RequestClient, guildId: string): Promise<APIGuild> {
+  return (await rest.get(Routes.guild(guildId))) as APIGuild;
+}
+
+export async function createGuildChannel(
+  rest: RequestClient,
+  guildId: string,
+  data: RequestData,
+): Promise<APIChannel> {
+  return (await rest.post(Routes.guildChannels(guildId), data)) as APIChannel;
+}
+
+export async function moveGuildChannels(
+  rest: RequestClient,
+  guildId: string,
+  data: RequestData,
+): Promise<void> {
+  await rest.patch(Routes.guildChannels(guildId), data);
+}
+
+export async function getGuildMember(
+  rest: RequestClient,
+  guildId: string,
+  userId: string,
+): Promise<APIGuildMember> {
+  return (await rest.get(Routes.guildMember(guildId, userId))) as APIGuildMember;
+}
+
+export async function listGuildRoles(rest: RequestClient, guildId: string): Promise<APIRole[]> {
+  return (await rest.get(Routes.guildRoles(guildId))) as APIRole[];
+}
+
+export async function listGuildChannels(
+  rest: RequestClient,
+  guildId: string,
+): Promise<APIChannel[]> {
+  return (await rest.get(Routes.guildChannels(guildId))) as APIChannel[];
+}
+
+export async function putChannelPermission(
+  rest: RequestClient,
+  channelId: string,
+  targetId: string,
+  data: RequestData,
+): Promise<void> {
+  await rest.put(Routes.channelPermission(channelId, targetId), data);
+}
+
+export async function deleteChannelPermission(
+  rest: RequestClient,
+  channelId: string,
+  targetId: string,
+): Promise<void> {
+  await rest.delete(Routes.channelPermission(channelId, targetId));
+}
+
+export async function listGuildActiveThreads(
+  rest: RequestClient,
+  guildId: string,
+): Promise<unknown> {
+  return await rest.get(Routes.guildActiveThreads(guildId));
+}
+
+export async function getGuildVoiceState(
+  rest: RequestClient,
+  guildId: string,
+  userId: string,
+): Promise<APIVoiceState> {
+  return (await rest.get(Routes.guildVoiceState(guildId, userId))) as APIVoiceState;
+}
+
+export async function listGuildScheduledEvents(
+  rest: RequestClient,
+  guildId: string,
+): Promise<APIGuildScheduledEvent[]> {
+  return (await rest.get(Routes.guildScheduledEvents(guildId))) as APIGuildScheduledEvent[];
+}
+
+export async function createGuildScheduledEvent(
+  rest: RequestClient,
+  guildId: string,
+  body: RESTPostAPIGuildScheduledEventJSONBody,
+): Promise<APIGuildScheduledEvent> {
+  return (await rest.post(Routes.guildScheduledEvents(guildId), {
+    body,
+  })) as APIGuildScheduledEvent;
+}
+
+export async function timeoutGuildMember(
+  rest: RequestClient,
+  guildId: string,
+  userId: string,
+  data: RequestData,
+): Promise<APIGuildMember> {
+  return (await rest.patch(Routes.guildMember(guildId, userId), data)) as APIGuildMember;
+}
+
+export async function addGuildMemberRole(
+  rest: RequestClient,
+  guildId: string,
+  userId: string,
+  roleId: string,
+): Promise<void> {
+  await rest.put(Routes.guildMemberRole(guildId, userId, roleId));
+}
+
+export async function removeGuildMemberRole(
+  rest: RequestClient,
+  guildId: string,
+  userId: string,
+  roleId: string,
+): Promise<void> {
+  await rest.delete(Routes.guildMemberRole(guildId, userId, roleId));
+}
+
+export async function removeGuildMember(
+  rest: RequestClient,
+  guildId: string,
+  userId: string,
+  data?: RequestData,
+): Promise<void> {
+  await rest.delete(Routes.guildMember(guildId, userId), data);
+}
+
+export async function createGuildBan(
+  rest: RequestClient,
+  guildId: string,
+  userId: string,
+  data?: RequestData,
+): Promise<void> {
+  await rest.put(Routes.guildBan(guildId, userId), data);
+}
+
+export async function listGuildEmojis(rest: RequestClient, guildId: string): Promise<unknown> {
+  return await rest.get(Routes.guildEmojis(guildId));
+}
+
+export async function createGuildEmoji(
+  rest: RequestClient,
+  guildId: string,
+  data: RequestData,
+): Promise<unknown> {
+  return await rest.post(Routes.guildEmojis(guildId), data);
+}
+
+export async function createGuildSticker(
+  rest: RequestClient,
+  guildId: string,
+  data: RequestData,
+): Promise<unknown> {
+  return await rest.post(Routes.guildStickers(guildId), data);
+}

package/src/internal/api.interactions.ts

@@ -0,0 +1,53 @@
+import { Routes } from "discord-api-types/v10";
+import type { RequestQuery } from "./rest-scheduler.js";
+import type { RequestClient, RequestData } from "./rest.js";
+
+export async function createInteractionCallback(
+  rest: RequestClient,
+  interactionId: string,
+  token: string,
+  body: unknown,
+): Promise<unknown> {
+  return await rest.post(Routes.interactionCallback(interactionId, token), { body });
+}
+
+export async function editWebhookMessage(
+  rest: RequestClient,
+  applicationId: string,
+  token: string,
+  messageId: string,
+  data: RequestData,
+  query?: RequestQuery,
+): Promise<unknown> {
+  return query
+    ? await rest.patch(Routes.webhookMessage(applicationId, token, messageId), data, query)
+    : await rest.patch(Routes.webhookMessage(applicationId, token, messageId), data);
+}
+
+export async function deleteWebhookMessage(
+  rest: RequestClient,
+  applicationId: string,
+  token: string,
+  messageId: string,
+): Promise<unknown> {
+  return await rest.delete(Routes.webhookMessage(applicationId, token, messageId));
+}
+
+export async function getWebhookMessage(
+  rest: RequestClient,
+  applicationId: string,
+  token: string,
+  messageId: string,
+): Promise<unknown> {
+  return await rest.get(Routes.webhookMessage(applicationId, token, messageId));
+}
+
+export async function createWebhookMessage(
+  rest: RequestClient,
+  applicationId: string,
+  token: string,
+  data: RequestData,
+  query?: RequestQuery,
+): Promise<unknown> {
+  return await rest.post(Routes.webhook(applicationId, token), data, query);
+}

package/src/internal/api.messages.ts

@@ -0,0 +1,113 @@
+import { Routes, type APIChannel, type APIMessage } from "discord-api-types/v10";
+import type { RequestQuery } from "./rest-scheduler.js";
+import type { RequestClient, RequestData } from "./rest.js";
+
+export async function getChannel(rest: RequestClient, channelId: string): Promise<APIChannel> {
+  return (await rest.get(Routes.channel(channelId))) as APIChannel;
+}
+
+export async function editChannel(
+  rest: RequestClient,
+  channelId: string,
+  data: RequestData,
+): Promise<APIChannel> {
+  return (await rest.patch(Routes.channel(channelId), data)) as APIChannel;
+}
+
+export async function deleteChannel(rest: RequestClient, channelId: string): Promise<void> {
+  await rest.delete(Routes.channel(channelId));
+}
+
+export async function listChannelMessages(
+  rest: RequestClient,
+  channelId: string,
+  query?: RequestQuery,
+): Promise<APIMessage[]> {
+  return (await rest.get(Routes.channelMessages(channelId), query)) as APIMessage[];
+}
+
+export async function getChannelMessage(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+): Promise<APIMessage> {
+  return (await rest.get(Routes.channelMessage(channelId, messageId))) as APIMessage;
+}
+
+export async function createChannelMessage<T extends object = APIMessage>(
+  rest: RequestClient,
+  channelId: string,
+  data: RequestData,
+): Promise<T> {
+  return (await rest.post(Routes.channelMessages(channelId), data)) as T;
+}
+
+export async function editChannelMessage(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+  data: RequestData,
+): Promise<APIMessage> {
+  return (await rest.patch(Routes.channelMessage(channelId, messageId), data)) as APIMessage;
+}
+
+export async function deleteChannelMessage(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+): Promise<void> {
+  await rest.delete(Routes.channelMessage(channelId, messageId));
+}
+
+export async function pinChannelMessage(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+): Promise<void> {
+  await rest.put(Routes.channelPin(channelId, messageId));
+}
+
+export async function unpinChannelMessage(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+): Promise<void> {
+  await rest.delete(Routes.channelPin(channelId, messageId));
+}
+
+export async function listChannelPins(
+  rest: RequestClient,
+  channelId: string,
+): Promise<APIMessage[]> {
+  return (await rest.get(Routes.channelPins(channelId))) as APIMessage[];
+}
+
+export async function sendChannelTyping(rest: RequestClient, channelId: string): Promise<void> {
+  await rest.post(Routes.channelTyping(channelId));
+}
+
+export async function createThread<T extends object = APIChannel>(
+  rest: RequestClient,
+  channelId: string,
+  data: RequestData,
+  messageId?: string,
+): Promise<T> {
+  const route = messageId ? Routes.threads(channelId, messageId) : Routes.threads(channelId);
+  return (await rest.post(route, data)) as T;
+}
+
+export async function listChannelArchivedThreads(
+  rest: RequestClient,
+  channelId: string,
+  query?: RequestQuery,
+): Promise<unknown> {
+  return await rest.get(Routes.channelThreads(channelId, "public"), query);
+}
+
+export async function searchGuildMessages(
+  rest: RequestClient,
+  guildId: string,
+  params: URLSearchParams,
+): Promise<unknown> {
+  return await rest.get(`/guilds/${guildId}/messages/search?${params.toString()}`);
+}

package/src/internal/api.reactions.ts

@@ -0,0 +1,38 @@
+import { Routes } from "discord-api-types/v10";
+import type { RequestQuery } from "./rest-scheduler.js";
+import type { RequestClient } from "./rest.js";
+
+export async function createOwnMessageReaction(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+  encodedEmoji: string,
+): Promise<void> {
+  await rest.put(Routes.channelMessageOwnReaction(channelId, messageId, encodedEmoji));
+}
+
+export async function deleteOwnMessageReaction(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+  encodedEmoji: string,
+): Promise<void> {
+  await rest.delete(Routes.channelMessageOwnReaction(channelId, messageId, encodedEmoji));
+}
+
+export async function listMessageReactionUsers(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+  encodedEmoji: string,
+  query?: RequestQuery,
+): Promise<Array<{ id: string; username?: string; discriminator?: string }>> {
+  return (await rest.get(
+    Routes.channelMessageReaction(channelId, messageId, encodedEmoji),
+    query,
+  )) as Array<{
+    id: string;
+    username?: string;
+    discriminator?: string;
+  }>;
+}