@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/dist/channel-access-ewDxhd9q.js

@@ -0,0 +1,62 @@
+//#region extensions/discord/src/monitor/channel-access.ts
+function readDiscordChannelPropertySafe(channel, key) {
+	if (!channel || typeof channel !== "object") return;
+	try {
+		if (!(key in channel)) return;
+		return channel[key];
+	} catch {
+		return;
+	}
+}
+function resolveDiscordChannelStringPropertySafe(channel, key) {
+	const value = readDiscordChannelPropertySafe(channel, key);
+	return typeof value === "string" ? value : void 0;
+}
+function resolveDiscordChannelNumberPropertySafe(channel, key) {
+	const value = readDiscordChannelPropertySafe(channel, key);
+	return typeof value === "number" ? value : void 0;
+}
+const DISCORD_CHANNEL_SNAKE_CASE_ALIASES = {
+	ownerId: "owner_id",
+	parentId: "parent_id"
+};
+function resolveDiscordChannelStringWithAliasSafe(channel, camelKey) {
+	const camelValue = resolveDiscordChannelStringPropertySafe(channel, camelKey);
+	if (camelValue !== void 0) return camelValue;
+	const snakeKey = DISCORD_CHANNEL_SNAKE_CASE_ALIASES[camelKey];
+	if (!snakeKey) return;
+	const directSnakeValue = resolveDiscordChannelStringPropertySafe(channel, snakeKey);
+	if (directSnakeValue !== void 0) return directSnakeValue;
+	return resolveDiscordChannelStringPropertySafe(readDiscordChannelPropertySafe(channel, "rawData"), snakeKey);
+}
+function resolveDiscordChannelNameSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "name");
+}
+function resolveDiscordChannelIdSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "id");
+}
+function resolveDiscordChannelTopicSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "topic");
+}
+function resolveDiscordChannelParentIdSafe(channel) {
+	return resolveDiscordChannelStringWithAliasSafe(channel, "parentId");
+}
+function resolveDiscordChannelOwnerIdSafe(channel) {
+	return resolveDiscordChannelStringWithAliasSafe(channel, "ownerId");
+}
+function resolveDiscordChannelParentSafe(channel) {
+	return readDiscordChannelPropertySafe(channel, "parent");
+}
+function resolveDiscordChannelInfoSafe(channel) {
+	const parent = resolveDiscordChannelParentSafe(channel);
+	return {
+		name: resolveDiscordChannelNameSafe(channel),
+		topic: resolveDiscordChannelTopicSafe(channel),
+		type: resolveDiscordChannelNumberPropertySafe(channel, "type"),
+		parentId: resolveDiscordChannelParentIdSafe(channel),
+		ownerId: resolveDiscordChannelOwnerIdSafe(channel),
+		parentName: resolveDiscordChannelNameSafe(parent)
+	};
+}
+//#endregion
+export { resolveDiscordChannelParentSafe as a, resolveDiscordChannelParentIdSafe as i, resolveDiscordChannelInfoSafe as n, resolveDiscordChannelTopicSafe as o, resolveDiscordChannelNameSafe as r, resolveDiscordChannelIdSafe as t };

package/dist/channel-actions-TNih7k3w.js

@@ -0,0 +1,140 @@
+import { r as listDiscordAccountIds, t as createDiscordActionGate } from "./accounts-BKnkNaoA.js";
+import { t as inspectDiscordAccount } from "./account-inspect-C2UEUhbG.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import { createUnionActionGate } from "openclaw/plugin-sdk/channel-actions";
+import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
+//#region extensions/discord/src/channel-actions.ts
+let discordChannelActionsRuntimePromise;
+async function loadDiscordChannelActionsRuntime() {
+	discordChannelActionsRuntimePromise ??= import("./channel-actions.runtime-CaPytiY4.js");
+	return await discordChannelActionsRuntimePromise;
+}
+function listDiscoverableDiscordAccounts(cfg) {
+	return listDiscordAccountIds(cfg).map((accountId) => inspectDiscordAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled && account.configured);
+}
+function resolveDiscordActionDiscovery(cfg) {
+	const accounts = listDiscoverableDiscordAccounts(cfg);
+	if (accounts.length === 0) return null;
+	const unionGate = createUnionActionGate(accounts, (account) => createDiscordActionGate({
+		cfg,
+		accountId: account.accountId
+	}));
+	return { isEnabled: (key, defaultValue = true) => unionGate(key, defaultValue) };
+}
+function resolveScopedDiscordActionDiscovery(params) {
+	if (!params.accountId) return resolveDiscordActionDiscovery(params.cfg);
+	const account = inspectDiscordAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (!account.enabled || !account.configured) return null;
+	const gate = createDiscordActionGate({
+		cfg: params.cfg,
+		accountId: account.accountId
+	});
+	return { isEnabled: (key, defaultValue = true) => gate(key, defaultValue) };
+}
+function describeDiscordMessageTool({ cfg, accountId }) {
+	const discovery = resolveScopedDiscordActionDiscovery({
+		cfg,
+		accountId
+	});
+	if (!discovery) return {
+		actions: [],
+		capabilities: [],
+		schema: null
+	};
+	const actions = new Set(["send"]);
+	if (discovery.isEnabled("polls")) actions.add("poll");
+	if (discovery.isEnabled("reactions")) {
+		actions.add("react");
+		actions.add("reactions");
+		actions.add("emoji-list");
+	}
+	if (discovery.isEnabled("messages")) {
+		actions.add("upload-file");
+		actions.add("read");
+		actions.add("edit");
+		actions.add("delete");
+	}
+	if (discovery.isEnabled("pins")) {
+		actions.add("pin");
+		actions.add("unpin");
+		actions.add("list-pins");
+	}
+	if (discovery.isEnabled("permissions")) actions.add("permissions");
+	if (discovery.isEnabled("threads")) {
+		actions.add("thread-create");
+		actions.add("thread-list");
+		actions.add("thread-reply");
+	}
+	if (discovery.isEnabled("search")) actions.add("search");
+	if (discovery.isEnabled("stickers")) actions.add("sticker");
+	if (discovery.isEnabled("memberInfo")) actions.add("member-info");
+	if (discovery.isEnabled("roleInfo")) actions.add("role-info");
+	if (discovery.isEnabled("emojiUploads")) actions.add("emoji-upload");
+	if (discovery.isEnabled("stickerUploads")) actions.add("sticker-upload");
+	if (discovery.isEnabled("roles", false)) {
+		actions.add("role-add");
+		actions.add("role-remove");
+	}
+	if (discovery.isEnabled("channelInfo")) {
+		actions.add("channel-info");
+		actions.add("channel-list");
+	}
+	if (discovery.isEnabled("channels")) {
+		actions.add("channel-create");
+		actions.add("channel-edit");
+		actions.add("channel-delete");
+		actions.add("channel-move");
+		actions.add("category-create");
+		actions.add("category-edit");
+		actions.add("category-delete");
+	}
+	if (discovery.isEnabled("voiceStatus")) actions.add("voice-status");
+	if (discovery.isEnabled("events")) {
+		actions.add("event-list");
+		actions.add("event-create");
+	}
+	if (discovery.isEnabled("moderation", false)) {
+		actions.add("timeout");
+		actions.add("kick");
+		actions.add("ban");
+	}
+	if (discovery.isEnabled("presence", false)) actions.add("set-presence");
+	return {
+		actions: Array.from(actions),
+		capabilities: ["presentation"]
+	};
+}
+const discordMessageActions = {
+	resolveExecutionMode: ({ action }) => action === "read" || action === "search" ? "gateway" : "local",
+	describeMessageTool: describeDiscordMessageTool,
+	extractToolSend: ({ args }) => {
+		const action = normalizeOptionalString(args.action) ?? "";
+		if (action === "sendMessage") return extractToolSend(args, "sendMessage");
+		if (action === "threadReply") {
+			const channelId = normalizeOptionalString(args.channelId) ?? "";
+			return channelId ? { to: `channel:${channelId}` } : null;
+		}
+		return null;
+	},
+	handleAction: async ({ action, params, cfg, accountId, requesterSenderId, toolContext, mediaAccess, mediaLocalRoots, mediaReadFile }) => {
+		return await (await loadDiscordChannelActionsRuntime()).handleDiscordMessageAction({
+			action,
+			params,
+			cfg,
+			accountId,
+			requesterSenderId,
+			toolContext,
+			mediaAccess,
+			mediaLocalRoots,
+			mediaReadFile
+		});
+	}
+};
+//#endregion
+export { discordMessageActions as t };

package/dist/channel-actions.runtime-CaPytiY4.js

@@ -0,0 +1,236 @@
+import { s as resolveDiscordChannelId } from "./normalize-B-ktw-T_.js";
+import { t as handleDiscordAction } from "./runtime-n5xZHW55.js";
+import { n as buildDiscordPresentationComponents, t as buildDiscordInteractiveComponents } from "./shared-interactive-KgJjCqnB.js";
+import "./targets-kKlbZ4ai.js";
+import "./action-runtime-api.js";
+import { t as tryHandleDiscordMessageActionGuildAdmin } from "./handle-action.guild-admin-BuqsSVXu.js";
+import { normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/text-runtime";
+import { resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
+import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";
+import { normalizeInteractiveReply, normalizeMessagePresentation } from "openclaw/plugin-sdk/interactive-runtime";
+import { readNumberParam, readStringArrayParam, readStringParam } from "openclaw/plugin-sdk/agent-runtime";
+//#region extensions/discord/src/actions/handle-action.ts
+const providerId = "discord";
+function readCurrentDiscordTarget(toolContext) {
+	const provider = toolContext?.currentChannelProvider?.trim().toLowerCase();
+	if (provider && provider !== providerId) return;
+	return toolContext?.currentChannelId?.trim() || void 0;
+}
+async function handleDiscordMessageAction(ctx) {
+	const { action, params, cfg } = ctx;
+	const accountId = ctx.accountId ?? readStringParam(params, "accountId");
+	const actionOptions = {
+		mediaAccess: ctx.mediaAccess,
+		mediaLocalRoots: ctx.mediaLocalRoots,
+		mediaReadFile: ctx.mediaReadFile
+	};
+	const readTarget = () => {
+		const target = readStringParam(params, "channelId") ?? readStringParam(params, "to") ?? readCurrentDiscordTarget(ctx.toolContext);
+		if (!target) throw new Error("Discord channel target is required (use channel:<id>).");
+		return target;
+	};
+	const resolveChannelId = () => resolveDiscordChannelId(readTarget());
+	const readSendTarget = () => {
+		const target = readStringParam(params, "to") ?? readStringParam(params, "target") ?? readCurrentDiscordTarget(ctx.toolContext);
+		if (!target) throw new Error("Discord channel target is required (use channel:<id>).");
+		return target;
+	};
+	if (action === "send") {
+		const to = readSendTarget();
+		const asVoice = readBooleanParam(params, "asVoice") === true;
+		const rawComponents = params.components ?? buildDiscordPresentationComponents(normalizeMessagePresentation(params.presentation)) ?? buildDiscordInteractiveComponents(normalizeInteractiveReply(params.interactive));
+		const hasComponents = Boolean(rawComponents) && (typeof rawComponents === "function" || typeof rawComponents === "object");
+		const components = hasComponents ? rawComponents : void 0;
+		const mediaUrl = readStringParam(params, "media", { trim: false }) ?? readStringParam(params, "path", { trim: false }) ?? readStringParam(params, "filePath", { trim: false });
+		const content = readStringParam(params, "message", {
+			required: !asVoice && !hasComponents && !mediaUrl,
+			allowEmpty: true
+		});
+		const filename = readStringParam(params, "filename");
+		const replyTo = readStringParam(params, "replyTo");
+		const rawEmbeds = params.embeds;
+		const embeds = Array.isArray(rawEmbeds) ? rawEmbeds : void 0;
+		const silent = readBooleanParam(params, "silent") === true;
+		const sessionKey = readStringParam(params, "__sessionKey");
+		const agentId = readStringParam(params, "__agentId");
+		return await handleDiscordAction({
+			action: "sendMessage",
+			accountId: accountId ?? void 0,
+			to,
+			content: content ?? "",
+			mediaUrl: mediaUrl ?? void 0,
+			filename: filename ?? void 0,
+			replyTo: replyTo ?? void 0,
+			components,
+			embeds,
+			asVoice,
+			silent,
+			__sessionKey: sessionKey ?? void 0,
+			__agentId: agentId ?? void 0
+		}, cfg, actionOptions);
+	}
+	if (action === "upload-file") {
+		const to = readSendTarget();
+		const mediaUrl = readStringParam(params, "filePath", { trim: false }) ?? readStringParam(params, "path", { trim: false }) ?? readStringParam(params, "media", { trim: false });
+		if (!mediaUrl) throw new Error("upload-file requires filePath, path, or media.");
+		const content = readStringParam(params, "message", { allowEmpty: true }) ?? readStringParam(params, "content", { allowEmpty: true });
+		const filename = readStringParam(params, "filename");
+		const replyTo = readStringParam(params, "replyTo");
+		const silent = readBooleanParam(params, "silent") === true;
+		const sessionKey = readStringParam(params, "__sessionKey");
+		const agentId = readStringParam(params, "__agentId");
+		return await handleDiscordAction({
+			action: "sendMessage",
+			accountId: accountId ?? void 0,
+			to,
+			content: content ?? "",
+			mediaUrl,
+			filename: filename ?? void 0,
+			replyTo: replyTo ?? void 0,
+			silent,
+			__sessionKey: sessionKey ?? void 0,
+			__agentId: agentId ?? void 0
+		}, cfg, actionOptions);
+	}
+	if (action === "poll") {
+		const to = readStringParam(params, "to", { required: true });
+		const question = readStringParam(params, "pollQuestion", { required: true });
+		const answers = readStringArrayParam(params, "pollOption", { required: true });
+		const allowMultiselect = readBooleanParam(params, "pollMulti");
+		const durationHours = readNumberParam(params, "pollDurationHours", {
+			integer: true,
+			strict: true
+		});
+		return await handleDiscordAction({
+			action: "poll",
+			accountId: accountId ?? void 0,
+			to,
+			question,
+			answers,
+			allowMultiselect,
+			durationHours: durationHours ?? void 0,
+			content: readStringParam(params, "message")
+		}, cfg, actionOptions);
+	}
+	if (action === "react") {
+		const messageId = normalizeOptionalStringifiedId(resolveReactionMessageId({
+			args: params,
+			toolContext: ctx.toolContext
+		})) ?? "";
+		if (!messageId) throw new Error("messageId required. Provide messageId explicitly or react to the current inbound message.");
+		const emoji = readStringParam(params, "emoji", { allowEmpty: true });
+		const remove = readBooleanParam(params, "remove");
+		return await handleDiscordAction({
+			action: "react",
+			accountId: accountId ?? void 0,
+			channelId: readTarget(),
+			messageId,
+			emoji,
+			remove
+		}, cfg, actionOptions);
+	}
+	if (action === "reactions") {
+		const messageId = readStringParam(params, "messageId", { required: true });
+		const limit = readNumberParam(params, "limit", { integer: true });
+		return await handleDiscordAction({
+			action: "reactions",
+			accountId: accountId ?? void 0,
+			channelId: readTarget(),
+			messageId,
+			limit
+		}, cfg, actionOptions);
+	}
+	if (action === "read") {
+		const limit = readNumberParam(params, "limit", { integer: true });
+		return await handleDiscordAction({
+			action: "readMessages",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			limit,
+			before: readStringParam(params, "before"),
+			after: readStringParam(params, "after"),
+			around: readStringParam(params, "around")
+		}, cfg, actionOptions);
+	}
+	if (action === "edit") {
+		const messageId = readStringParam(params, "messageId", { required: true });
+		const content = readStringParam(params, "message", { required: true });
+		return await handleDiscordAction({
+			action: "editMessage",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			messageId,
+			content
+		}, cfg, actionOptions);
+	}
+	if (action === "delete") {
+		const messageId = readStringParam(params, "messageId", { required: true });
+		return await handleDiscordAction({
+			action: "deleteMessage",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			messageId
+		}, cfg, actionOptions);
+	}
+	if (action === "pin" || action === "unpin" || action === "list-pins") {
+		const messageId = action === "list-pins" ? void 0 : readStringParam(params, "messageId", { required: true });
+		return await handleDiscordAction({
+			action: action === "pin" ? "pinMessage" : action === "unpin" ? "unpinMessage" : "listPins",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			messageId
+		}, cfg, actionOptions);
+	}
+	if (action === "permissions") return await handleDiscordAction({
+		action: "permissions",
+		accountId: accountId ?? void 0,
+		channelId: resolveChannelId()
+	}, cfg, actionOptions);
+	if (action === "thread-create") {
+		const name = readStringParam(params, "threadName", { required: true });
+		const messageId = readStringParam(params, "messageId");
+		const content = readStringParam(params, "message");
+		const autoArchiveMinutes = readNumberParam(params, "autoArchiveMin", { integer: true });
+		const appliedTags = readStringArrayParam(params, "appliedTags");
+		return await handleDiscordAction({
+			action: "threadCreate",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			name,
+			messageId,
+			content,
+			autoArchiveMinutes,
+			appliedTags: appliedTags ?? void 0
+		}, cfg, actionOptions);
+	}
+	if (action === "sticker") {
+		const stickerIds = readStringArrayParam(params, "stickerId", {
+			required: true,
+			label: "sticker-id"
+		}) ?? [];
+		return await handleDiscordAction({
+			action: "sticker",
+			accountId: accountId ?? void 0,
+			to: readStringParam(params, "to", { required: true }),
+			stickerIds,
+			content: readStringParam(params, "message")
+		}, cfg, actionOptions);
+	}
+	if (action === "set-presence") return await handleDiscordAction({
+		action: "setPresence",
+		accountId: accountId ?? void 0,
+		status: readStringParam(params, "status"),
+		activityType: readStringParam(params, "activityType"),
+		activityName: readStringParam(params, "activityName"),
+		activityUrl: readStringParam(params, "activityUrl"),
+		activityState: readStringParam(params, "activityState")
+	}, cfg, actionOptions);
+	const adminResult = await tryHandleDiscordMessageActionGuildAdmin({
+		ctx,
+		resolveChannelId
+	});
+	if (adminResult !== void 0) return adminResult;
+	throw new Error(`Action ${action} is not supported for provider ${providerId}.`);
+}
+//#endregion
+export { handleDiscordMessageAction };

package/dist/channel-api-CTSWMrnD.js

@@ -0,0 +1,21 @@
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "openclaw/plugin-sdk/account-id";
+import { PAIRING_APPROVED_MESSAGE, buildTokenChannelStatusSummary, projectCredentialSnapshotFields, resolveConfiguredFromCredentialStatuses } from "openclaw/plugin-sdk/channel-status";
+//#region extensions/discord/src/channel-api.ts
+const DISCORD_CHANNEL_META = {
+	id: "discord",
+	label: "Discord",
+	selectionLabel: "Discord (Bot API)",
+	detailLabel: "Discord Bot",
+	docsPath: "/channels/discord",
+	docsLabel: "discord",
+	blurb: "very well supported right now.",
+	systemImage: "bubble.left.and.bubble.right",
+	markdownCapable: true,
+	preferSessionLookupForAnnounceTarget: true
+};
+function getChatChannelMeta(id) {
+	if (id !== DISCORD_CHANNEL_META.id) throw new Error(`Unsupported Discord channel meta lookup: ${id}`);
+	return DISCORD_CHANNEL_META;
+}
+//#endregion
+export { projectCredentialSnapshotFields as a, getChatChannelMeta as i, PAIRING_APPROVED_MESSAGE as n, resolveConfiguredFromCredentialStatuses as o, buildTokenChannelStatusSummary as r, DEFAULT_ACCOUNT_ID$1 as t };

package/dist/channel-config-api.js

@@ -0,0 +1,2 @@
+import { t as DiscordChannelConfigSchema } from "./config-schema-DwFkL904.js";
+export { DiscordChannelConfigSchema };

package/dist/channel-plugin-api.js

@@ -0,0 +1,2 @@
+import { t as discordPlugin } from "./channel-B3aTtBj1.js";
+export { discordPlugin };