@fased/fased 0.1.41 → 0.1.42

package/dist/plugin-sdk/handle-action-DkfMckah.js

@@ -0,0 +1,1450 @@
+import "./runtime-BUpqjZNM.js";
+import "./subsystem-DBPNbQDQ.js";
+import "./globals-B_jjtAje.js";
+import "./paths-BEmvSyOV.js";
+import "./utils-CYk9EKoq.js";
+import "./config-DKNrb8oT.js";
+import "./agent-scope-BbgPlhtw.js";
+import { t as createDiscordActionGate } from "./accounts-RHZyaB73.js";
+import "./accounts-CuqIKU8X.js";
+import "./logger-BbFvCoKk.js";
+import "./exec-DQ8j4Fm3.js";
+import "./accounts-Bz_2QZSt.js";
+import "./allow-list-yqasgPpz.js";
+import "./redact-CwCz68Mi.js";
+import "./github-copilot-token-Dgug856m.js";
+import "./retry-DycQ4ymF.js";
+import "./paths-B88DQEK8.js";
+import "./ip-BkeyFRJr.js";
+import "./ssrf-D_4q0mKh.js";
+import "./fetch-guard-CxXvFYq5.js";
+import "./chunk-CuJIMshx.js";
+import "./optional-runtime-dependency-Bt_3Yigu.js";
+import "./image-ops-BSQmb-17.js";
+import "./path-alias-guards-BlIJ0AmG.js";
+import "./fs-safe-DztQeyQe.js";
+import "./markdown-tables-DrB-IM8r.js";
+import "./media-D8pWjqEt.js";
+import "./fetch-RV7QDF43.js";
+import { a as jsonResult, c as readReactionParams, d as readStringParam, l as readStringArrayParam, o as parseAvailableTags, s as readNumberParam } from "./common-C90EHP1w.js";
+import "./directory-live-G7AN8y8N.js";
+import { n as resolveDiscordChannelId } from "./targets-BgSHco9b.js";
+import { t as assertMediaNotDataUrl } from "./sandbox-paths-fc-HFGJr.js";
+import { i as withNormalizedTimestamp } from "./date-time-Bbp5JvNw.js";
+import "./render-K7NwXvVu.js";
+import "./tables-DX84FwPB.js";
+import { $ as fetchChannelPermissionsDiscord, A as unpinMessageDiscord, B as listScheduledEventsDiscord, C as editMessageDiscord, D as pinMessageDiscord, E as listThreadsDiscord, F as fetchMemberInfoDiscord, G as uploadStickerDiscord, H as timeoutMemberDiscord, I as fetchRoleInfoDiscord, J as editChannelDiscord, K as createChannelDiscord, L as fetchVoiceStatusDiscord, M as banMemberDiscord, N as createScheduledEventDiscord, O as readMessagesDiscord, P as fetchChannelInfoDiscord, R as kickMemberDiscord, S as deleteMessageDiscord, T as listPinsDiscord, U as listGuildEmojisDiscord, V as removeRoleDiscord, W as uploadEmojiDiscord, X as removeChannelPermissionDiscord, Y as moveChannelDiscord, Z as setChannelPermissionDiscord, _ as sendPollDiscord, a as removeReactionDiscord, et as hasAnyGuildPermissionDiscord, g as sendMessageDiscord, i as removeOwnReactionsDiscord, j as addRoleDiscord, k as searchMessagesDiscord, n as fetchReactionsDiscord, o as sendDiscordComponentMessage, p as readDiscordComponentSpec, q as deleteChannelDiscord, r as reactMessageDiscord, v as sendStickerDiscord, w as fetchMessageDiscord, x as createThreadDiscord, y as sendVoiceMessageDiscord, z as listGuildChannelsDiscord } from "./send-zn5KBXIN.js";
+import "./retry-policy-BTH89onl.js";
+import { i as getPresence, t as getGateway } from "./gateway-registry-C-MTEdvG.js";
+import { PermissionFlagsBits } from "discord-api-types/v10";
+
+//#region src/agents/tools/discord-actions-guild.ts
+function readParentIdParam$1(params) {
+	if (params.clearParent === true) return null;
+	if (params.parentId === null) return null;
+	return readStringParam(params, "parentId");
+}
+async function runRoleMutation(params) {
+	const guildId = readStringParam(params.values, "guildId", { required: true });
+	const userId = readStringParam(params.values, "userId", { required: true });
+	const roleId = readStringParam(params.values, "roleId", { required: true });
+	if (params.accountId) {
+		await params.mutate({
+			guildId,
+			userId,
+			roleId
+		}, { accountId: params.accountId });
+		return;
+	}
+	await params.mutate({
+		guildId,
+		userId,
+		roleId
+	});
+}
+async function handleDiscordGuildAction(action, params, isActionEnabled) {
+	const accountId = readStringParam(params, "accountId");
+	switch (action) {
+		case "memberInfo": {
+			if (!isActionEnabled("memberInfo")) throw new Error("Discord member info is disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			const userId = readStringParam(params, "userId", { required: true });
+			const member = accountId ? await fetchMemberInfoDiscord(guildId, userId, { accountId }) : await fetchMemberInfoDiscord(guildId, userId);
+			const presence = getPresence(accountId, userId);
+			const activities = presence?.activities ?? void 0;
+			const status = presence?.status ?? void 0;
+			return jsonResult({
+				ok: true,
+				member,
+				...presence ? {
+					status,
+					activities
+				} : {}
+			});
+		}
+		case "roleInfo": {
+			if (!isActionEnabled("roleInfo")) throw new Error("Discord role info is disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			return jsonResult({
+				ok: true,
+				roles: accountId ? await fetchRoleInfoDiscord(guildId, { accountId }) : await fetchRoleInfoDiscord(guildId)
+			});
+		}
+		case "emojiList": {
+			if (!isActionEnabled("reactions")) throw new Error("Discord reactions are disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			return jsonResult({
+				ok: true,
+				emojis: accountId ? await listGuildEmojisDiscord(guildId, { accountId }) : await listGuildEmojisDiscord(guildId)
+			});
+		}
+		case "emojiUpload": {
+			if (!isActionEnabled("emojiUploads")) throw new Error("Discord emoji uploads are disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			const name = readStringParam(params, "name", { required: true });
+			const mediaUrl = readStringParam(params, "mediaUrl", { required: true });
+			const roleIds = readStringArrayParam(params, "roleIds");
+			return jsonResult({
+				ok: true,
+				emoji: accountId ? await uploadEmojiDiscord({
+					guildId,
+					name,
+					mediaUrl,
+					roleIds: roleIds?.length ? roleIds : void 0
+				}, { accountId }) : await uploadEmojiDiscord({
+					guildId,
+					name,
+					mediaUrl,
+					roleIds: roleIds?.length ? roleIds : void 0
+				})
+			});
+		}
+		case "stickerUpload": {
+			if (!isActionEnabled("stickerUploads")) throw new Error("Discord sticker uploads are disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			const name = readStringParam(params, "name", { required: true });
+			const description = readStringParam(params, "description", { required: true });
+			const tags = readStringParam(params, "tags", { required: true });
+			const mediaUrl = readStringParam(params, "mediaUrl", { required: true });
+			return jsonResult({
+				ok: true,
+				sticker: accountId ? await uploadStickerDiscord({
+					guildId,
+					name,
+					description,
+					tags,
+					mediaUrl
+				}, { accountId }) : await uploadStickerDiscord({
+					guildId,
+					name,
+					description,
+					tags,
+					mediaUrl
+				})
+			});
+		}
+		case "roleAdd":
+			if (!isActionEnabled("roles", false)) throw new Error("Discord role changes are disabled.");
+			await runRoleMutation({
+				accountId,
+				values: params,
+				mutate: addRoleDiscord
+			});
+			return jsonResult({ ok: true });
+		case "roleRemove":
+			if (!isActionEnabled("roles", false)) throw new Error("Discord role changes are disabled.");
+			await runRoleMutation({
+				accountId,
+				values: params,
+				mutate: removeRoleDiscord
+			});
+			return jsonResult({ ok: true });
+		case "channelInfo": {
+			if (!isActionEnabled("channelInfo")) throw new Error("Discord channel info is disabled.");
+			const channelId = readStringParam(params, "channelId", { required: true });
+			return jsonResult({
+				ok: true,
+				channel: accountId ? await fetchChannelInfoDiscord(channelId, { accountId }) : await fetchChannelInfoDiscord(channelId)
+			});
+		}
+		case "channelList": {
+			if (!isActionEnabled("channelInfo")) throw new Error("Discord channel info is disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			return jsonResult({
+				ok: true,
+				channels: accountId ? await listGuildChannelsDiscord(guildId, { accountId }) : await listGuildChannelsDiscord(guildId)
+			});
+		}
+		case "voiceStatus": {
+			if (!isActionEnabled("voiceStatus")) throw new Error("Discord voice status is disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			const userId = readStringParam(params, "userId", { required: true });
+			return jsonResult({
+				ok: true,
+				voice: accountId ? await fetchVoiceStatusDiscord(guildId, userId, { accountId }) : await fetchVoiceStatusDiscord(guildId, userId)
+			});
+		}
+		case "eventList": {
+			if (!isActionEnabled("events")) throw new Error("Discord events are disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			return jsonResult({
+				ok: true,
+				events: accountId ? await listScheduledEventsDiscord(guildId, { accountId }) : await listScheduledEventsDiscord(guildId)
+			});
+		}
+		case "eventCreate": {
+			if (!isActionEnabled("events")) throw new Error("Discord events are disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			const name = readStringParam(params, "name", { required: true });
+			const startTime = readStringParam(params, "startTime", { required: true });
+			const endTime = readStringParam(params, "endTime");
+			const description = readStringParam(params, "description");
+			const channelId = readStringParam(params, "channelId");
+			const location = readStringParam(params, "location");
+			const entityTypeRaw = readStringParam(params, "entityType");
+			const entityType = entityTypeRaw === "stage" ? 1 : entityTypeRaw === "external" ? 3 : 2;
+			const payload = {
+				name,
+				description,
+				scheduled_start_time: startTime,
+				scheduled_end_time: endTime,
+				entity_type: entityType,
+				channel_id: channelId,
+				entity_metadata: entityType === 3 && location ? { location } : void 0,
+				privacy_level: 2
+			};
+			return jsonResult({
+				ok: true,
+				event: accountId ? await createScheduledEventDiscord(guildId, payload, { accountId }) : await createScheduledEventDiscord(guildId, payload)
+			});
+		}
+		case "channelCreate": {
+			if (!isActionEnabled("channels")) throw new Error("Discord channel management is disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			const name = readStringParam(params, "name", { required: true });
+			const type = readNumberParam(params, "type", { integer: true });
+			const parentId = readParentIdParam$1(params);
+			const topic = readStringParam(params, "topic");
+			const position = readNumberParam(params, "position", { integer: true });
+			const nsfw = params.nsfw;
+			return jsonResult({
+				ok: true,
+				channel: accountId ? await createChannelDiscord({
+					guildId,
+					name,
+					type: type ?? void 0,
+					parentId: parentId ?? void 0,
+					topic: topic ?? void 0,
+					position: position ?? void 0,
+					nsfw
+				}, { accountId }) : await createChannelDiscord({
+					guildId,
+					name,
+					type: type ?? void 0,
+					parentId: parentId ?? void 0,
+					topic: topic ?? void 0,
+					position: position ?? void 0,
+					nsfw
+				})
+			});
+		}
+		case "channelEdit": {
+			if (!isActionEnabled("channels")) throw new Error("Discord channel management is disabled.");
+			const channelId = readStringParam(params, "channelId", { required: true });
+			const name = readStringParam(params, "name");
+			const topic = readStringParam(params, "topic");
+			const position = readNumberParam(params, "position", { integer: true });
+			const parentId = readParentIdParam$1(params);
+			const nsfw = params.nsfw;
+			const rateLimitPerUser = readNumberParam(params, "rateLimitPerUser", { integer: true });
+			const archived = typeof params.archived === "boolean" ? params.archived : void 0;
+			const locked = typeof params.locked === "boolean" ? params.locked : void 0;
+			const autoArchiveDuration = readNumberParam(params, "autoArchiveDuration", { integer: true });
+			const availableTags = parseAvailableTags(params.availableTags);
+			return jsonResult({
+				ok: true,
+				channel: accountId ? await editChannelDiscord({
+					channelId,
+					name: name ?? void 0,
+					topic: topic ?? void 0,
+					position: position ?? void 0,
+					parentId,
+					nsfw,
+					rateLimitPerUser: rateLimitPerUser ?? void 0,
+					archived,
+					locked,
+					autoArchiveDuration: autoArchiveDuration ?? void 0,
+					availableTags
+				}, { accountId }) : await editChannelDiscord({
+					channelId,
+					name: name ?? void 0,
+					topic: topic ?? void 0,
+					position: position ?? void 0,
+					parentId,
+					nsfw,
+					rateLimitPerUser: rateLimitPerUser ?? void 0,
+					archived,
+					locked,
+					autoArchiveDuration: autoArchiveDuration ?? void 0,
+					availableTags
+				})
+			});
+		}
+		case "channelDelete": {
+			if (!isActionEnabled("channels")) throw new Error("Discord channel management is disabled.");
+			const channelId = readStringParam(params, "channelId", { required: true });
+			return jsonResult(accountId ? await deleteChannelDiscord(channelId, { accountId }) : await deleteChannelDiscord(channelId));
+		}
+		case "channelMove": {
+			if (!isActionEnabled("channels")) throw new Error("Discord channel management is disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			const channelId = readStringParam(params, "channelId", { required: true });
+			const parentId = readParentIdParam$1(params);
+			const position = readNumberParam(params, "position", { integer: true });
+			if (accountId) await moveChannelDiscord({
+				guildId,
+				channelId,
+				parentId,
+				position: position ?? void 0
+			}, { accountId });
+			else await moveChannelDiscord({
+				guildId,
+				channelId,
+				parentId,
+				position: position ?? void 0
+			});
+			return jsonResult({ ok: true });
+		}
+		case "categoryCreate": {
+			if (!isActionEnabled("channels")) throw new Error("Discord channel management is disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			const name = readStringParam(params, "name", { required: true });
+			const position = readNumberParam(params, "position", { integer: true });
+			return jsonResult({
+				ok: true,
+				category: accountId ? await createChannelDiscord({
+					guildId,
+					name,
+					type: 4,
+					position: position ?? void 0
+				}, { accountId }) : await createChannelDiscord({
+					guildId,
+					name,
+					type: 4,
+					position: position ?? void 0
+				})
+			});
+		}
+		case "categoryEdit": {
+			if (!isActionEnabled("channels")) throw new Error("Discord channel management is disabled.");
+			const categoryId = readStringParam(params, "categoryId", { required: true });
+			const name = readStringParam(params, "name");
+			const position = readNumberParam(params, "position", { integer: true });
+			return jsonResult({
+				ok: true,
+				category: accountId ? await editChannelDiscord({
+					channelId: categoryId,
+					name: name ?? void 0,
+					position: position ?? void 0
+				}, { accountId }) : await editChannelDiscord({
+					channelId: categoryId,
+					name: name ?? void 0,
+					position: position ?? void 0
+				})
+			});
+		}
+		case "categoryDelete": {
+			if (!isActionEnabled("channels")) throw new Error("Discord channel management is disabled.");
+			const categoryId = readStringParam(params, "categoryId", { required: true });
+			return jsonResult(accountId ? await deleteChannelDiscord(categoryId, { accountId }) : await deleteChannelDiscord(categoryId));
+		}
+		case "channelPermissionSet": {
+			if (!isActionEnabled("channels")) throw new Error("Discord channel management is disabled.");
+			const channelId = readStringParam(params, "channelId", { required: true });
+			const targetId = readStringParam(params, "targetId", { required: true });
+			const targetType = readStringParam(params, "targetType", { required: true }) === "member" ? 1 : 0;
+			const allow = readStringParam(params, "allow");
+			const deny = readStringParam(params, "deny");
+			if (accountId) await setChannelPermissionDiscord({
+				channelId,
+				targetId,
+				targetType,
+				allow: allow ?? void 0,
+				deny: deny ?? void 0
+			}, { accountId });
+			else await setChannelPermissionDiscord({
+				channelId,
+				targetId,
+				targetType,
+				allow: allow ?? void 0,
+				deny: deny ?? void 0
+			});
+			return jsonResult({ ok: true });
+		}
+		case "channelPermissionRemove": {
+			if (!isActionEnabled("channels")) throw new Error("Discord channel management is disabled.");
+			const channelId = readStringParam(params, "channelId", { required: true });
+			const targetId = readStringParam(params, "targetId", { required: true });
+			if (accountId) await removeChannelPermissionDiscord(channelId, targetId, { accountId });
+			else await removeChannelPermissionDiscord(channelId, targetId);
+			return jsonResult({ ok: true });
+		}
+		default: throw new Error(`Unknown action: ${action}`);
+	}
+}
+
+//#endregion
+//#region src/agents/tools/discord-actions-messaging.ts
+function parseDiscordMessageLink(link) {
+	const match = link.trim().match(/^(?:https?:\/\/)?(?:ptb\.|canary\.)?discord(?:app)?\.com\/channels\/(\d+)\/(\d+)\/(\d+)(?:\/?|\?.*)$/i);
+	if (!match) throw new Error("Invalid Discord message link. Expected https://discord.com/channels/<guildId>/<channelId>/<messageId>.");
+	return {
+		guildId: match[1],
+		channelId: match[2],
+		messageId: match[3]
+	};
+}
+async function handleDiscordMessagingAction(action, params, isActionEnabled, options) {
+	const resolveChannelId = () => resolveDiscordChannelId(readStringParam(params, "channelId", { required: true }));
+	const accountId = readStringParam(params, "accountId");
+	const normalizeMessage = (message) => {
+		if (!message || typeof message !== "object") return message;
+		return withNormalizedTimestamp(message, message.timestamp);
+	};
+	switch (action) {
+		case "react": {
+			if (!isActionEnabled("reactions")) throw new Error("Discord reactions are disabled.");
+			const channelId = resolveChannelId();
+			const messageId = readStringParam(params, "messageId", { required: true });
+			const { emoji, remove, isEmpty } = readReactionParams(params, { removeErrorMessage: "Emoji is required to remove a Discord reaction." });
+			if (remove) {
+				if (accountId) await removeReactionDiscord(channelId, messageId, emoji, { accountId });
+				else await removeReactionDiscord(channelId, messageId, emoji);
+				return jsonResult({
+					ok: true,
+					removed: emoji
+				});
+			}
+			if (isEmpty) return jsonResult({
+				ok: true,
+				removed: (accountId ? await removeOwnReactionsDiscord(channelId, messageId, { accountId }) : await removeOwnReactionsDiscord(channelId, messageId)).removed
+			});
+			if (accountId) await reactMessageDiscord(channelId, messageId, emoji, { accountId });
+			else await reactMessageDiscord(channelId, messageId, emoji);
+			return jsonResult({
+				ok: true,
+				added: emoji
+			});
+		}
+		case "reactions": {
+			if (!isActionEnabled("reactions")) throw new Error("Discord reactions are disabled.");
+			const channelId = resolveChannelId();
+			const messageId = readStringParam(params, "messageId", { required: true });
+			const limitRaw = params.limit;
+			const limit = typeof limitRaw === "number" && Number.isFinite(limitRaw) ? limitRaw : void 0;
+			return jsonResult({
+				ok: true,
+				reactions: await fetchReactionsDiscord(channelId, messageId, {
+					...accountId ? { accountId } : {},
+					limit
+				})
+			});
+		}
+		case "sticker": {
+			if (!isActionEnabled("stickers")) throw new Error("Discord stickers are disabled.");
+			const to = readStringParam(params, "to", { required: true });
+			const content = readStringParam(params, "content");
+			await sendStickerDiscord(to, readStringArrayParam(params, "stickerIds", {
+				required: true,
+				label: "stickerIds"
+			}), {
+				...accountId ? { accountId } : {},
+				content
+			});
+			return jsonResult({ ok: true });
+		}
+		case "poll": {
+			if (!isActionEnabled("polls")) throw new Error("Discord polls are disabled.");
+			const to = readStringParam(params, "to", { required: true });
+			const content = readStringParam(params, "content");
+			const question = readStringParam(params, "question", { required: true });
+			const answers = readStringArrayParam(params, "answers", {
+				required: true,
+				label: "answers"
+			});
+			const allowMultiselectRaw = params.allowMultiselect;
+			const allowMultiselect = typeof allowMultiselectRaw === "boolean" ? allowMultiselectRaw : void 0;
+			const durationRaw = params.durationHours;
+			const durationHours = typeof durationRaw === "number" && Number.isFinite(durationRaw) ? durationRaw : void 0;
+			await sendPollDiscord(to, {
+				question,
+				options: answers,
+				maxSelections: allowMultiselect ? Math.max(2, answers.length) : 1,
+				durationHours
+			}, {
+				...accountId ? { accountId } : {},
+				content
+			});
+			return jsonResult({ ok: true });
+		}
+		case "permissions": {
+			if (!isActionEnabled("permissions")) throw new Error("Discord permissions are disabled.");
+			const channelId = resolveChannelId();
+			return jsonResult({
+				ok: true,
+				permissions: accountId ? await fetchChannelPermissionsDiscord(channelId, { accountId }) : await fetchChannelPermissionsDiscord(channelId)
+			});
+		}
+		case "fetchMessage": {
+			if (!isActionEnabled("messages")) throw new Error("Discord message reads are disabled.");
+			const messageLink = readStringParam(params, "messageLink");
+			let guildId = readStringParam(params, "guildId");
+			let channelId = readStringParam(params, "channelId");
+			let messageId = readStringParam(params, "messageId");
+			if (messageLink) {
+				const parsed = parseDiscordMessageLink(messageLink);
+				guildId = parsed.guildId;
+				channelId = parsed.channelId;
+				messageId = parsed.messageId;
+			}
+			if (!guildId || !channelId || !messageId) throw new Error("Discord message fetch requires guildId, channelId, and messageId (or a valid messageLink).");
+			return jsonResult({
+				ok: true,
+				message: normalizeMessage(accountId ? await fetchMessageDiscord(channelId, messageId, { accountId }) : await fetchMessageDiscord(channelId, messageId)),
+				guildId,
+				channelId,
+				messageId
+			});
+		}
+		case "readMessages": {
+			if (!isActionEnabled("messages")) throw new Error("Discord message reads are disabled.");
+			const channelId = resolveChannelId();
+			const query = {
+				limit: typeof params.limit === "number" && Number.isFinite(params.limit) ? params.limit : void 0,
+				before: readStringParam(params, "before"),
+				after: readStringParam(params, "after"),
+				around: readStringParam(params, "around")
+			};
+			return jsonResult({
+				ok: true,
+				messages: (accountId ? await readMessagesDiscord(channelId, query, { accountId }) : await readMessagesDiscord(channelId, query)).map((message) => normalizeMessage(message))
+			});
+		}
+		case "sendMessage": {
+			if (!isActionEnabled("messages")) throw new Error("Discord message sends are disabled.");
+			const to = readStringParam(params, "to", { required: true });
+			const asVoice = params.asVoice === true;
+			const silent = params.silent === true;
+			const rawComponents = params.components;
+			const componentSpec = rawComponents && typeof rawComponents === "object" && !Array.isArray(rawComponents) ? readDiscordComponentSpec(rawComponents) : null;
+			const components = Array.isArray(rawComponents) || typeof rawComponents === "function" ? rawComponents : void 0;
+			const content = readStringParam(params, "content", {
+				required: !asVoice && !componentSpec && !components,
+				allowEmpty: true
+			});
+			const mediaUrl = readStringParam(params, "mediaUrl", { trim: false }) ?? readStringParam(params, "path", { trim: false }) ?? readStringParam(params, "filePath", { trim: false });
+			const filename = readStringParam(params, "filename");
+			const replyTo = readStringParam(params, "replyTo");
+			const rawEmbeds = params.embeds;
+			const embeds = Array.isArray(rawEmbeds) ? rawEmbeds : void 0;
+			const sessionKey = readStringParam(params, "__sessionKey");
+			const agentId = readStringParam(params, "__agentId");
+			if (componentSpec) {
+				if (asVoice) throw new Error("Discord components cannot be sent as voice messages.");
+				if (embeds?.length) throw new Error("Discord components cannot include embeds.");
+				const normalizedContent = content?.trim() ? content : void 0;
+				return jsonResult({
+					ok: true,
+					result: await sendDiscordComponentMessage(to, componentSpec.text ? componentSpec : {
+						...componentSpec,
+						text: normalizedContent
+					}, {
+						...accountId ? { accountId } : {},
+						silent,
+						replyTo: replyTo ?? void 0,
+						sessionKey: sessionKey ?? void 0,
+						agentId: agentId ?? void 0,
+						mediaUrl: mediaUrl ?? void 0,
+						filename: filename ?? void 0
+					}),
+					components: true
+				});
+			}
+			if (asVoice) {
+				if (!mediaUrl) throw new Error("Voice messages require a media file reference (mediaUrl, path, or filePath).");
+				if (content && content.trim()) throw new Error("Voice messages cannot include text content (Discord limitation). Remove the content parameter.");
+				assertMediaNotDataUrl(mediaUrl);
+				return jsonResult({
+					ok: true,
+					result: await sendVoiceMessageDiscord(to, mediaUrl, {
+						...accountId ? { accountId } : {},
+						replyTo,
+						silent
+					}),
+					voiceMessage: true
+				});
+			}
+			return jsonResult({
+				ok: true,
+				result: await sendMessageDiscord(to, content ?? "", {
+					...accountId ? { accountId } : {},
+					mediaUrl,
+					mediaLocalRoots: options?.mediaLocalRoots,
+					replyTo,
+					components,
+					embeds,
+					silent
+				})
+			});
+		}
+		case "editMessage": {
+			if (!isActionEnabled("messages")) throw new Error("Discord message edits are disabled.");
+			const channelId = resolveChannelId();
+			const messageId = readStringParam(params, "messageId", { required: true });
+			const content = readStringParam(params, "content", { required: true });
+			return jsonResult({
+				ok: true,
+				message: accountId ? await editMessageDiscord(channelId, messageId, { content }, { accountId }) : await editMessageDiscord(channelId, messageId, { content })
+			});
+		}
+		case "deleteMessage": {
+			if (!isActionEnabled("messages")) throw new Error("Discord message deletes are disabled.");
+			const channelId = resolveChannelId();
+			const messageId = readStringParam(params, "messageId", { required: true });
+			if (accountId) await deleteMessageDiscord(channelId, messageId, { accountId });
+			else await deleteMessageDiscord(channelId, messageId);
+			return jsonResult({ ok: true });
+		}
+		case "threadCreate": {
+			if (!isActionEnabled("threads")) throw new Error("Discord threads are disabled.");
+			const channelId = resolveChannelId();
+			const name = readStringParam(params, "name", { required: true });
+			const messageId = readStringParam(params, "messageId");
+			const content = readStringParam(params, "content");
+			const autoArchiveMinutesRaw = params.autoArchiveMinutes;
+			const autoArchiveMinutes = typeof autoArchiveMinutesRaw === "number" && Number.isFinite(autoArchiveMinutesRaw) ? autoArchiveMinutesRaw : void 0;
+			return jsonResult({
+				ok: true,
+				thread: accountId ? await createThreadDiscord(channelId, {
+					name,
+					messageId,
+					autoArchiveMinutes,
+					content
+				}, { accountId }) : await createThreadDiscord(channelId, {
+					name,
+					messageId,
+					autoArchiveMinutes,
+					content
+				})
+			});
+		}
+		case "threadList": {
+			if (!isActionEnabled("threads")) throw new Error("Discord threads are disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			const channelId = readStringParam(params, "channelId");
+			const includeArchived = typeof params.includeArchived === "boolean" ? params.includeArchived : void 0;
+			const before = readStringParam(params, "before");
+			const limit = typeof params.limit === "number" && Number.isFinite(params.limit) ? params.limit : void 0;
+			return jsonResult({
+				ok: true,
+				threads: accountId ? await listThreadsDiscord({
+					guildId,
+					channelId,
+					includeArchived,
+					before,
+					limit
+				}, { accountId }) : await listThreadsDiscord({
+					guildId,
+					channelId,
+					includeArchived,
+					before,
+					limit
+				})
+			});
+		}
+		case "threadReply": {
+			if (!isActionEnabled("threads")) throw new Error("Discord threads are disabled.");
+			const channelId = resolveChannelId();
+			const content = readStringParam(params, "content", { required: true });
+			const mediaUrl = readStringParam(params, "mediaUrl");
+			const replyTo = readStringParam(params, "replyTo");
+			return jsonResult({
+				ok: true,
+				result: await sendMessageDiscord(`channel:${channelId}`, content, {
+					...accountId ? { accountId } : {},
+					mediaUrl,
+					mediaLocalRoots: options?.mediaLocalRoots,
+					replyTo
+				})
+			});
+		}
+		case "pinMessage": {
+			if (!isActionEnabled("pins")) throw new Error("Discord pins are disabled.");
+			const channelId = resolveChannelId();
+			const messageId = readStringParam(params, "messageId", { required: true });
+			if (accountId) await pinMessageDiscord(channelId, messageId, { accountId });
+			else await pinMessageDiscord(channelId, messageId);
+			return jsonResult({ ok: true });
+		}
+		case "unpinMessage": {
+			if (!isActionEnabled("pins")) throw new Error("Discord pins are disabled.");
+			const channelId = resolveChannelId();
+			const messageId = readStringParam(params, "messageId", { required: true });
+			if (accountId) await unpinMessageDiscord(channelId, messageId, { accountId });
+			else await unpinMessageDiscord(channelId, messageId);
+			return jsonResult({ ok: true });
+		}
+		case "listPins": {
+			if (!isActionEnabled("pins")) throw new Error("Discord pins are disabled.");
+			const channelId = resolveChannelId();
+			return jsonResult({
+				ok: true,
+				pins: (accountId ? await listPinsDiscord(channelId, { accountId }) : await listPinsDiscord(channelId)).map((pin) => normalizeMessage(pin))
+			});
+		}
+		case "searchMessages": {
+			if (!isActionEnabled("search")) throw new Error("Discord search is disabled.");
+			const guildId = readStringParam(params, "guildId", { required: true });
+			const content = readStringParam(params, "content", { required: true });
+			const channelId = readStringParam(params, "channelId");
+			const channelIds = readStringArrayParam(params, "channelIds");
+			const authorId = readStringParam(params, "authorId");
+			const authorIds = readStringArrayParam(params, "authorIds");
+			const limit = typeof params.limit === "number" && Number.isFinite(params.limit) ? params.limit : void 0;
+			const channelIdList = [...channelIds ?? [], ...channelId ? [channelId] : []];
+			const authorIdList = [...authorIds ?? [], ...authorId ? [authorId] : []];
+			const results = accountId ? await searchMessagesDiscord({
+				guildId,
+				content,
+				channelIds: channelIdList.length ? channelIdList : void 0,
+				authorIds: authorIdList.length ? authorIdList : void 0,
+				limit
+			}, { accountId }) : await searchMessagesDiscord({
+				guildId,
+				content,
+				channelIds: channelIdList.length ? channelIdList : void 0,
+				authorIds: authorIdList.length ? authorIdList : void 0,
+				limit
+			});
+			if (!results || typeof results !== "object") return jsonResult({
+				ok: true,
+				results
+			});
+			const resultsRecord = results;
+			const messages = resultsRecord.messages;
+			const normalizedMessages = Array.isArray(messages) ? messages.map((group) => Array.isArray(group) ? group.map((msg) => normalizeMessage(msg)) : group) : messages;
+			return jsonResult({
+				ok: true,
+				results: {
+					...resultsRecord,
+					messages: normalizedMessages
+				}
+			});
+		}
+		default: throw new Error(`Unknown action: ${action}`);
+	}
+}
+
+//#endregion
+//#region src/agents/tools/discord-actions-moderation-shared.ts
+const moderationPermissions = {
+	timeout: PermissionFlagsBits.ModerateMembers,
+	kick: PermissionFlagsBits.KickMembers,
+	ban: PermissionFlagsBits.BanMembers
+};
+function isDiscordModerationAction(action) {
+	return action === "timeout" || action === "kick" || action === "ban";
+}
+function requiredGuildPermissionForModerationAction(action) {
+	return moderationPermissions[action];
+}
+function readDiscordModerationCommand(action, params) {
+	if (!isDiscordModerationAction(action)) throw new Error(`Unsupported Discord moderation action: ${action}`);
+	return {
+		action,
+		guildId: readStringParam(params, "guildId", { required: true }),
+		userId: readStringParam(params, "userId", { required: true }),
+		durationMinutes: readNumberParam(params, "durationMinutes", { integer: true }),
+		until: readStringParam(params, "until"),
+		reason: readStringParam(params, "reason"),
+		deleteMessageDays: readNumberParam(params, "deleteMessageDays", { integer: true })
+	};
+}
+
+//#endregion
+//#region src/agents/tools/discord-actions-moderation.ts
+async function verifySenderModerationPermission(params) {
+	if (!params.senderUserId) return;
+	if (!await hasAnyGuildPermissionDiscord(params.guildId, params.senderUserId, [params.requiredPermission], params.accountId ? { accountId: params.accountId } : void 0)) throw new Error("Sender does not have required permissions for this moderation action.");
+}
+async function handleDiscordModerationAction(action, params, isActionEnabled) {
+	if (!isDiscordModerationAction(action)) throw new Error(`Unknown action: ${action}`);
+	if (!isActionEnabled("moderation", false)) throw new Error("Discord moderation is disabled.");
+	const command = readDiscordModerationCommand(action, params);
+	const accountId = readStringParam(params, "accountId");
+	const senderUserId = readStringParam(params, "senderUserId");
+	await verifySenderModerationPermission({
+		guildId: command.guildId,
+		senderUserId,
+		requiredPermission: requiredGuildPermissionForModerationAction(command.action),
+		accountId
+	});
+	switch (command.action) {
+		case "timeout": return jsonResult({
+			ok: true,
+			member: accountId ? await timeoutMemberDiscord({
+				guildId: command.guildId,
+				userId: command.userId,
+				durationMinutes: command.durationMinutes,
+				until: command.until,
+				reason: command.reason
+			}, { accountId }) : await timeoutMemberDiscord({
+				guildId: command.guildId,
+				userId: command.userId,
+				durationMinutes: command.durationMinutes,
+				until: command.until,
+				reason: command.reason
+			})
+		});
+		case "kick":
+			if (accountId) await kickMemberDiscord({
+				guildId: command.guildId,
+				userId: command.userId,
+				reason: command.reason
+			}, { accountId });
+			else await kickMemberDiscord({
+				guildId: command.guildId,
+				userId: command.userId,
+				reason: command.reason
+			});
+			return jsonResult({ ok: true });
+		case "ban":
+			if (accountId) await banMemberDiscord({
+				guildId: command.guildId,
+				userId: command.userId,
+				reason: command.reason,
+				deleteMessageDays: command.deleteMessageDays
+			}, { accountId });
+			else await banMemberDiscord({
+				guildId: command.guildId,
+				userId: command.userId,
+				reason: command.reason,
+				deleteMessageDays: command.deleteMessageDays
+			});
+			return jsonResult({ ok: true });
+	}
+}
+
+//#endregion
+//#region src/agents/tools/discord-actions-presence.ts
+const ACTIVITY_TYPE_MAP = {
+	playing: 0,
+	streaming: 1,
+	listening: 2,
+	watching: 3,
+	custom: 4,
+	competing: 5
+};
+const VALID_STATUSES = new Set([
+	"online",
+	"dnd",
+	"idle",
+	"invisible"
+]);
+async function handleDiscordPresenceAction(action, params, isActionEnabled) {
+	if (action !== "setPresence") throw new Error(`Unknown presence action: ${action}`);
+	if (!isActionEnabled("presence", false)) throw new Error("Discord presence changes are disabled.");
+	const accountId = readStringParam(params, "accountId");
+	const gateway = getGateway(accountId);
+	if (!gateway) throw new Error(`Discord gateway not available${accountId ? ` for account "${accountId}"` : ""}. The bot may not be connected.`);
+	if (!gateway.isConnected) throw new Error(`Discord gateway is not connected${accountId ? ` for account "${accountId}"` : ""}.`);
+	const statusRaw = readStringParam(params, "status") ?? "online";
+	if (!VALID_STATUSES.has(statusRaw)) throw new Error(`Invalid status "${statusRaw}". Must be one of: ${[...VALID_STATUSES].join(", ")}`);
+	const status = statusRaw;
+	const activityTypeRaw = readStringParam(params, "activityType");
+	const activityName = readStringParam(params, "activityName");
+	const activities = [];
+	if (activityTypeRaw || activityName) {
+		if (!activityTypeRaw) throw new Error(`activityType is required when activityName is provided. Valid types: ${Object.keys(ACTIVITY_TYPE_MAP).join(", ")}`);
+		const typeNum = ACTIVITY_TYPE_MAP[activityTypeRaw.toLowerCase()];
+		if (typeNum === void 0) throw new Error(`Invalid activityType "${activityTypeRaw}". Must be one of: ${Object.keys(ACTIVITY_TYPE_MAP).join(", ")}`);
+		const activity = {
+			name: activityName ?? "",
+			type: typeNum
+		};
+		if (typeNum === 1) {
+			const url = readStringParam(params, "activityUrl");
+			if (url) activity.url = url;
+		}
+		const state = readStringParam(params, "activityState");
+		if (state) activity.state = state;
+		activities.push(activity);
+	}
+	const presenceData = {
+		since: null,
+		activities,
+		status,
+		afk: false
+	};
+	gateway.updatePresence(presenceData);
+	return jsonResult({
+		ok: true,
+		status,
+		activities: activities.map((a) => ({
+			type: a.type,
+			name: a.name,
+			...a.url ? { url: a.url } : {},
+			...a.state ? { state: a.state } : {}
+		}))
+	});
+}
+
+//#endregion
+//#region src/agents/tools/discord-actions.ts
+const messagingActions = new Set([
+	"react",
+	"reactions",
+	"sticker",
+	"poll",
+	"permissions",
+	"fetchMessage",
+	"readMessages",
+	"sendMessage",
+	"editMessage",
+	"deleteMessage",
+	"threadCreate",
+	"threadList",
+	"threadReply",
+	"pinMessage",
+	"unpinMessage",
+	"listPins",
+	"searchMessages"
+]);
+const guildActions = new Set([
+	"memberInfo",
+	"roleInfo",
+	"emojiList",
+	"emojiUpload",
+	"stickerUpload",
+	"roleAdd",
+	"roleRemove",
+	"channelInfo",
+	"channelList",
+	"voiceStatus",
+	"eventList",
+	"eventCreate",
+	"channelCreate",
+	"channelEdit",
+	"channelDelete",
+	"channelMove",
+	"categoryCreate",
+	"categoryEdit",
+	"categoryDelete",
+	"channelPermissionSet",
+	"channelPermissionRemove"
+]);
+const moderationActions = new Set([
+	"timeout",
+	"kick",
+	"ban"
+]);
+const presenceActions = new Set(["setPresence"]);
+async function handleDiscordAction(params, cfg, options) {
+	const action = readStringParam(params, "action", { required: true });
+	const isActionEnabled = createDiscordActionGate({
+		cfg,
+		accountId: readStringParam(params, "accountId")
+	});
+	if (messagingActions.has(action)) return await handleDiscordMessagingAction(action, params, isActionEnabled, options);
+	if (guildActions.has(action)) return await handleDiscordGuildAction(action, params, isActionEnabled);
+	if (moderationActions.has(action)) return await handleDiscordModerationAction(action, params, isActionEnabled);
+	if (presenceActions.has(action)) return await handleDiscordPresenceAction(action, params, isActionEnabled);
+	throw new Error(`Unknown action: ${action}`);
+}
+
+//#endregion
+//#region src/channels/plugins/actions/discord/handle-action.guild-admin.ts
+async function tryHandleDiscordMessageActionGuildAdmin(params) {
+	const { ctx, resolveChannelId, readParentIdParam } = params;
+	const { action, params: actionParams, cfg } = ctx;
+	const accountId = ctx.accountId ?? readStringParam(actionParams, "accountId");
+	if (action === "member-info") {
+		const userId = readStringParam(actionParams, "userId", { required: true });
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "memberInfo",
+			accountId: accountId ?? void 0,
+			guildId,
+			userId
+		}, cfg);
+	}
+	if (action === "role-info") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "roleInfo",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg);
+	}
+	if (action === "emoji-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "emojiList",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg);
+	}
+	if (action === "emoji-upload") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "emojiName", { required: true });
+		const mediaUrl = readStringParam(actionParams, "media", {
+			required: true,
+			trim: false
+		});
+		const roleIds = readStringArrayParam(actionParams, "roleIds");
+		return await handleDiscordAction({
+			action: "emojiUpload",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			mediaUrl,
+			roleIds
+		}, cfg);
+	}
+	if (action === "sticker-upload") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "stickerName", { required: true });
+		const description = readStringParam(actionParams, "stickerDesc", { required: true });
+		const tags = readStringParam(actionParams, "stickerTags", { required: true });
+		const mediaUrl = readStringParam(actionParams, "media", {
+			required: true,
+			trim: false
+		});
+		return await handleDiscordAction({
+			action: "stickerUpload",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			description,
+			tags,
+			mediaUrl
+		}, cfg);
+	}
+	if (action === "role-add" || action === "role-remove") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const userId = readStringParam(actionParams, "userId", { required: true });
+		const roleId = readStringParam(actionParams, "roleId", { required: true });
+		return await handleDiscordAction({
+			action: action === "role-add" ? "roleAdd" : "roleRemove",
+			accountId: accountId ?? void 0,
+			guildId,
+			userId,
+			roleId
+		}, cfg);
+	}
+	if (action === "channel-info") {
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		return await handleDiscordAction({
+			action: "channelInfo",
+			accountId: accountId ?? void 0,
+			channelId
+		}, cfg);
+	}
+	if (action === "channel-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "channelList",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg);
+	}
+	if (action === "channel-create") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "name", { required: true });
+		const type = readNumberParam(actionParams, "type", { integer: true });
+		const parentId = readParentIdParam(actionParams);
+		const topic = readStringParam(actionParams, "topic");
+		const position = readNumberParam(actionParams, "position", { integer: true });
+		const nsfw = typeof actionParams.nsfw === "boolean" ? actionParams.nsfw : void 0;
+		return await handleDiscordAction({
+			action: "channelCreate",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			type: type ?? void 0,
+			parentId: parentId ?? void 0,
+			topic: topic ?? void 0,
+			position: position ?? void 0,
+			nsfw
+		}, cfg);
+	}
+	if (action === "channel-edit") {
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		const name = readStringParam(actionParams, "name");
+		const topic = readStringParam(actionParams, "topic");
+		const position = readNumberParam(actionParams, "position", { integer: true });
+		const parentId = readParentIdParam(actionParams);
+		const nsfw = typeof actionParams.nsfw === "boolean" ? actionParams.nsfw : void 0;
+		const rateLimitPerUser = readNumberParam(actionParams, "rateLimitPerUser", { integer: true });
+		const archived = typeof actionParams.archived === "boolean" ? actionParams.archived : void 0;
+		const locked = typeof actionParams.locked === "boolean" ? actionParams.locked : void 0;
+		const autoArchiveDuration = readNumberParam(actionParams, "autoArchiveDuration", { integer: true });
+		const availableTags = parseAvailableTags(actionParams.availableTags);
+		return await handleDiscordAction({
+			action: "channelEdit",
+			accountId: accountId ?? void 0,
+			channelId,
+			name: name ?? void 0,
+			topic: topic ?? void 0,
+			position: position ?? void 0,
+			parentId: parentId === void 0 ? void 0 : parentId,
+			nsfw,
+			rateLimitPerUser: rateLimitPerUser ?? void 0,
+			archived,
+			locked,
+			autoArchiveDuration: autoArchiveDuration ?? void 0,
+			availableTags
+		}, cfg);
+	}
+	if (action === "channel-delete") {
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		return await handleDiscordAction({
+			action: "channelDelete",
+			accountId: accountId ?? void 0,
+			channelId
+		}, cfg);
+	}
+	if (action === "channel-move") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const channelId = readStringParam(actionParams, "channelId", { required: true });
+		const parentId = readParentIdParam(actionParams);
+		const position = readNumberParam(actionParams, "position", { integer: true });
+		return await handleDiscordAction({
+			action: "channelMove",
+			accountId: accountId ?? void 0,
+			guildId,
+			channelId,
+			parentId: parentId === void 0 ? void 0 : parentId,
+			position: position ?? void 0
+		}, cfg);
+	}
+	if (action === "category-create") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "name", { required: true });
+		const position = readNumberParam(actionParams, "position", { integer: true });
+		return await handleDiscordAction({
+			action: "categoryCreate",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			position: position ?? void 0
+		}, cfg);
+	}
+	if (action === "category-edit") {
+		const categoryId = readStringParam(actionParams, "categoryId", { required: true });
+		const name = readStringParam(actionParams, "name");
+		const position = readNumberParam(actionParams, "position", { integer: true });
+		return await handleDiscordAction({
+			action: "categoryEdit",
+			accountId: accountId ?? void 0,
+			categoryId,
+			name: name ?? void 0,
+			position: position ?? void 0
+		}, cfg);
+	}
+	if (action === "category-delete") {
+		const categoryId = readStringParam(actionParams, "categoryId", { required: true });
+		return await handleDiscordAction({
+			action: "categoryDelete",
+			accountId: accountId ?? void 0,
+			categoryId
+		}, cfg);
+	}
+	if (action === "voice-status") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const userId = readStringParam(actionParams, "userId", { required: true });
+		return await handleDiscordAction({
+			action: "voiceStatus",
+			accountId: accountId ?? void 0,
+			guildId,
+			userId
+		}, cfg);
+	}
+	if (action === "event-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		return await handleDiscordAction({
+			action: "eventList",
+			accountId: accountId ?? void 0,
+			guildId
+		}, cfg);
+	}
+	if (action === "event-create") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const name = readStringParam(actionParams, "eventName", { required: true });
+		const startTime = readStringParam(actionParams, "startTime", { required: true });
+		const endTime = readStringParam(actionParams, "endTime");
+		const description = readStringParam(actionParams, "desc");
+		const channelId = readStringParam(actionParams, "channelId");
+		const location = readStringParam(actionParams, "location");
+		const entityType = readStringParam(actionParams, "eventType");
+		return await handleDiscordAction({
+			action: "eventCreate",
+			accountId: accountId ?? void 0,
+			guildId,
+			name,
+			startTime,
+			endTime,
+			description,
+			channelId,
+			location,
+			entityType
+		}, cfg);
+	}
+	if (isDiscordModerationAction(action)) {
+		const moderation = readDiscordModerationCommand(action, {
+			...actionParams,
+			durationMinutes: readNumberParam(actionParams, "durationMin", { integer: true }),
+			deleteMessageDays: readNumberParam(actionParams, "deleteDays", { integer: true })
+		});
+		const senderUserId = ctx.requesterSenderId?.trim() || void 0;
+		return await handleDiscordAction({
+			action: moderation.action,
+			accountId: accountId ?? void 0,
+			guildId: moderation.guildId,
+			userId: moderation.userId,
+			durationMinutes: moderation.durationMinutes,
+			until: moderation.until,
+			reason: moderation.reason,
+			deleteMessageDays: moderation.deleteMessageDays,
+			senderUserId
+		}, cfg);
+	}
+	if (action === "thread-list") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const channelId = readStringParam(actionParams, "channelId");
+		const includeArchived = typeof actionParams.includeArchived === "boolean" ? actionParams.includeArchived : void 0;
+		const before = readStringParam(actionParams, "before");
+		const limit = readNumberParam(actionParams, "limit", { integer: true });
+		return await handleDiscordAction({
+			action: "threadList",
+			accountId: accountId ?? void 0,
+			guildId,
+			channelId,
+			includeArchived,
+			before,
+			limit
+		}, cfg);
+	}
+	if (action === "thread-reply") {
+		const content = readStringParam(actionParams, "message", { required: true });
+		const mediaUrl = readStringParam(actionParams, "media", { trim: false });
+		const replyTo = readStringParam(actionParams, "replyTo");
+		const channelId = readStringParam(actionParams, "threadId") ?? resolveChannelId();
+		return await handleDiscordAction({
+			action: "threadReply",
+			accountId: accountId ?? void 0,
+			channelId,
+			content,
+			mediaUrl: mediaUrl ?? void 0,
+			replyTo: replyTo ?? void 0
+		}, cfg);
+	}
+	if (action === "search") {
+		const guildId = readStringParam(actionParams, "guildId", { required: true });
+		const query = readStringParam(actionParams, "query", { required: true });
+		return await handleDiscordAction({
+			action: "searchMessages",
+			accountId: accountId ?? void 0,
+			guildId,
+			content: query,
+			channelId: readStringParam(actionParams, "channelId"),
+			channelIds: readStringArrayParam(actionParams, "channelIds"),
+			authorId: readStringParam(actionParams, "authorId"),
+			authorIds: readStringArrayParam(actionParams, "authorIds"),
+			limit: readNumberParam(actionParams, "limit", { integer: true })
+		}, cfg);
+	}
+}
+
+//#endregion
+//#region src/channels/plugins/actions/discord/handle-action.ts
+const providerId = "discord";
+function readParentIdParam(params) {
+	if (params.clearParent === true) return null;
+	if (params.parentId === null) return null;
+	return readStringParam(params, "parentId");
+}
+async function handleDiscordMessageAction(ctx) {
+	const { action, params, cfg } = ctx;
+	const accountId = ctx.accountId ?? readStringParam(params, "accountId");
+	const actionOptions = { mediaLocalRoots: ctx.mediaLocalRoots };
+	const resolveChannelId = () => resolveDiscordChannelId(readStringParam(params, "channelId") ?? readStringParam(params, "to", { required: true }));
+	if (action === "send") {
+		const to = readStringParam(params, "to", { required: true });
+		const asVoice = params.asVoice === true;
+		const rawComponents = params.components;
+		const hasComponents = Boolean(rawComponents) && (typeof rawComponents === "function" || typeof rawComponents === "object");
+		const components = hasComponents ? rawComponents : void 0;
+		const content = readStringParam(params, "message", {
+			required: !asVoice && !hasComponents,
+			allowEmpty: true
+		});
+		const mediaUrl = readStringParam(params, "media", { trim: false }) ?? readStringParam(params, "path", { trim: false }) ?? readStringParam(params, "filePath", { trim: false });
+		const filename = readStringParam(params, "filename");
+		const replyTo = readStringParam(params, "replyTo");
+		const rawEmbeds = params.embeds;
+		const embeds = Array.isArray(rawEmbeds) ? rawEmbeds : void 0;
+		const silent = params.silent === true;
+		const sessionKey = readStringParam(params, "__sessionKey");
+		const agentId = readStringParam(params, "__agentId");
+		return await handleDiscordAction({
+			action: "sendMessage",
+			accountId: accountId ?? void 0,
+			to,
+			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 === "poll") {
+		const to = readStringParam(params, "to", { required: true });
+		const question = readStringParam(params, "pollQuestion", { required: true });
+		const answers = readStringArrayParam(params, "pollOption", { required: true }) ?? [];
+		const allowMultiselect = typeof params.pollMulti === "boolean" ? params.pollMulti : void 0;
+		const durationHours = readNumberParam(params, "pollDurationHours", { integer: 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 = readStringParam(params, "messageId", { required: true });
+		const emoji = readStringParam(params, "emoji", { allowEmpty: true });
+		const remove = typeof params.remove === "boolean" ? params.remove : void 0;
+		return await handleDiscordAction({
+			action: "react",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			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: resolveChannelId(),
+			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 });
+		return await handleDiscordAction({
+			action: "threadCreate",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			name,
+			messageId,
+			content,
+			autoArchiveMinutes
+		}, 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,
+		readParentIdParam
+	});
+	if (adminResult !== void 0) return adminResult;
+	throw new Error(`Action ${String(action)} is not supported for provider ${providerId}.`);
+}
+
+//#endregion
+export { handleDiscordMessageAction };