@openclaw/discord 2026.7.2-beta.7 → 2026.7.33

package/dist/.setup/send.shared-_6GIKg0j.mjs

@@ -0,0 +1,867 @@
+import { C as RequestClient, F as serializePayload, I as Embed, Nt as getGuild, Pt as getGuildMember, T as RateLimitError, _t as getChannel, dt as createChannelMessage, i as resolveDiscordReplyMessageId, ot as createUserDmChannel, st as getCurrentUser, u as chunkDiscordTextWithMode } from "./send.receipt-BWF_jBih.mjs";
+import { a as mergeDiscordAccountConfig, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-CetktX10.mjs";
+import { t as parseAndResolveDiscordTarget } from "./target-resolver-Dpyl0ZFd.mjs";
+import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { ChannelType, MessageFlags, PermissionFlagsBits } from "discord-api-types/v10";
+import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
+import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, readErrorName } from "openclaw/plugin-sdk/error-runtime";
+import { PollLayoutType } from "discord-api-types/payloads/v10";
+import { buildOutboundMediaLoadOptions, extensionForMime, normalizePollDurationHours, normalizePollInput } from "openclaw/plugin-sdk/media-runtime";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
+import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
+import { makeProxyFetch } from "openclaw/plugin-sdk/fetch-runtime";
+import { createSubsystemLogger, danger } from "openclaw/plugin-sdk/runtime-env";
+import { resolveRetryConfig, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
+//#region extensions/discord/src/monitor/gateway-registry.ts
+/**
+* Module-level registry of active Discord GatewayPlugin instances.
+* Bridges the gap between agent tool handlers (which only have REST access)
+* and the gateway WebSocket (needed for operations like updatePresence).
+* Follows the same pattern as presence-cache.ts.
+*/
+const gatewayRegistry = /* @__PURE__ */ new Map();
+const DEFAULT_ACCOUNT_KEY = "\0__default__";
+function resolveAccountKey(accountId) {
+	return accountId ?? DEFAULT_ACCOUNT_KEY;
+}
+/** Register a GatewayPlugin instance for an account. */
+function registerGateway(accountId, gateway) {
+	gatewayRegistry.set(resolveAccountKey(accountId), gateway);
+}
+/** Unregister a GatewayPlugin instance for an account. */
+function unregisterGateway(accountId) {
+	gatewayRegistry.delete(resolveAccountKey(accountId));
+}
+/** Get the GatewayPlugin for an account. Returns undefined if not registered. */
+function getGateway(accountId) {
+	return gatewayRegistry.get(resolveAccountKey(accountId));
+}
+/** Clear all registered gateways (for testing). */
+function clearGateways() {
+	gatewayRegistry.clear();
+}
+//#endregion
+//#region extensions/discord/src/proxy-fetch.ts
+function resolveDiscordProxyUrl(account, cfg) {
+	const accountProxy = account.config.proxy?.trim();
+	if (accountProxy) return accountProxy;
+	const channelProxy = cfg?.channels?.discord?.proxy;
+	if (typeof channelProxy !== "string") return;
+	return channelProxy.trim() || void 0;
+}
+function resolveDiscordProxyFetchByUrl(proxyUrl, runtime) {
+	return withValidatedDiscordProxy(proxyUrl, runtime, (proxy) => makeProxyFetch(proxy));
+}
+function resolveDiscordProxyFetchForAccount(account, cfg, runtime) {
+	return resolveDiscordProxyFetchByUrl(resolveDiscordProxyUrl(account, cfg), runtime);
+}
+function withValidatedDiscordProxy(proxyUrl, runtime, createValue) {
+	const proxy = proxyUrl?.trim();
+	if (!proxy) return;
+	try {
+		validateDiscordProxyUrl(proxy);
+		return createValue(proxy);
+	} catch (err) {
+		runtime?.error?.(danger(`discord: invalid rest proxy: ${String(err)}`));
+		return;
+	}
+}
+function validateDiscordProxyUrl(proxyUrl) {
+	let parsed;
+	try {
+		parsed = new URL(proxyUrl);
+	} catch {
+		throw new Error("Proxy URL must be a valid http or https URL");
+	}
+	if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("Proxy URL must use http or https");
+	if (!parsed.hostname) throw new Error("Proxy URL must include a host");
+	return proxyUrl;
+}
+//#endregion
+//#region extensions/discord/src/proxy-request-client.ts
+const DISCORD_REST_TIMEOUT_MS = 15e3;
+function createDiscordRequestClient(token, options) {
+	if (!options?.fetch) return new RequestClient(token, options);
+	return new RequestClient(token, {
+		runtimeProfile: "persistent",
+		maxQueueSize: 1e3,
+		timeout: DISCORD_REST_TIMEOUT_MS,
+		...options,
+		fetch: options.fetch
+	});
+}
+//#endregion
+//#region extensions/discord/src/retry.ts
+const DISCORD_RETRY_DEFAULTS = {
+	attempts: 3,
+	minDelayMs: 500,
+	maxDelayMs: 3e4,
+	jitter: .1
+};
+const DISCORD_GATEWAY_RECONNECT_EXTRA_ATTEMPTS = 2;
+const DISCORD_RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429]);
+const DISCORD_RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+	"EAI_AGAIN",
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"ENETUNREACH",
+	"ENOTFOUND",
+	"EPIPE",
+	"ETIMEDOUT",
+	"UND_ERR_BODY_TIMEOUT",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"UND_ERR_HEADERS_TIMEOUT",
+	"UND_ERR_SOCKET"
+]);
+const DISCORD_TRANSIENT_MESSAGE_RE = /\b(?:bad gateway|fetch failed|network error|networkerror|service unavailable|socket hang up|temporarily unavailable|timed out|timeout)\b|connection (?:closed|reset|refused)/i;
+const log = createSubsystemLogger("discord/retry");
+function readDiscordErrorStatus(err) {
+	if (!err || typeof err !== "object") return;
+	const raw = "status" in err && err.status !== void 0 ? err.status : "statusCode" in err && err.statusCode !== void 0 ? err.statusCode : void 0;
+	return parseStrictNonNegativeInteger(raw);
+}
+function isRetryableDiscordTransientError(err) {
+	if (err instanceof RateLimitError) return true;
+	for (const candidate of collectErrorGraphCandidates(err, (current) => [current.cause, current.error])) {
+		const status = readDiscordErrorStatus(candidate);
+		if (status !== void 0 && (DISCORD_RETRYABLE_STATUS_CODES.has(status) || status >= 500)) return true;
+		const code = extractErrorCode(candidate);
+		if (code && DISCORD_RETRYABLE_ERROR_CODES.has(code.toUpperCase())) return true;
+		if (readErrorName(candidate) === "AbortError") return true;
+		if ((candidate instanceof Error || candidate !== null && typeof candidate === "object") && DISCORD_TRANSIENT_MESSAGE_RE.test(formatErrorMessage(candidate))) return true;
+	}
+	return false;
+}
+function isRetryableDiscordGatewayTransportError(err) {
+	if (!isRetryableDiscordTransientError(err) || err instanceof RateLimitError) return false;
+	return !collectErrorGraphCandidates(err, (current) => [current.cause, current.error]).some((candidate) => readDiscordErrorStatus(candidate) !== void 0);
+}
+function createDiscordRetryRunner(params) {
+	const retryConfig = resolveRetryConfig(DISCORD_RETRY_DEFAULTS, {
+		...params.configRetry,
+		...params.retry
+	});
+	const attempts = retryConfig.attempts > 1 ? retryConfig.attempts + DISCORD_GATEWAY_RECONNECT_EXTRA_ATTEMPTS : retryConfig.attempts;
+	return (fn, label) => {
+		let observedGatewayDisconnect = false;
+		const runRequest = async () => {
+			observedGatewayDisconnect ||= params.isGatewayDisconnected?.() === true;
+			try {
+				return await fn();
+			} catch (err) {
+				observedGatewayDisconnect ||= params.isGatewayDisconnected?.() === true;
+				throw err;
+			}
+		};
+		return retryAsync(runRequest, {
+			...retryConfig,
+			attempts,
+			label,
+			shouldRetry: (err, attempt) => isRetryableDiscordTransientError(err) && (attempt < retryConfig.attempts || observedGatewayDisconnect && isRetryableDiscordGatewayTransportError(err)),
+			retryAfterMs: (err) => err instanceof RateLimitError ? err.retryAfter * 1e3 : void 0,
+			onRetry: params.verbose ? (info) => {
+				const maxAttempts = observedGatewayDisconnect ? attempts : retryConfig.attempts;
+				const maxRetries = Math.max(1, maxAttempts - 1);
+				log.warn(`discord ${info.label ?? "request"} retry ${info.attempt}/${maxRetries} in ${info.delayMs}ms: ${formatErrorMessage(info.err)}`);
+			} : void 0
+		});
+	};
+}
+//#endregion
+//#region extensions/discord/src/client.ts
+function createDiscordRuntimeAccountContext(params) {
+	return {
+		cfg: params.cfg,
+		accountId: normalizeAccountId(params.accountId)
+	};
+}
+function resolveDiscordClientAccountContext(opts, runtime) {
+	const resolvedCfg = requireRuntimeConfig(opts.cfg, "Discord client");
+	const account = resolveAccountWithoutToken({
+		cfg: resolvedCfg,
+		accountId: opts.accountId
+	});
+	return {
+		cfg: resolvedCfg,
+		account,
+		proxyFetch: resolveDiscordProxyFetchForAccount(account, resolvedCfg, runtime)
+	};
+}
+function resolveToken(params) {
+	const fallback = normalizeDiscordToken(params.fallbackToken, "channels.discord.token");
+	if (!fallback) {
+		if (params.account.tokenStatus === "configured_unavailable") throw new Error(`Discord bot token configured for account "${params.accountId}" is unavailable; resolve SecretRefs against the active runtime snapshot before using this account.`);
+		throw new Error(`Discord bot token missing for account "${params.accountId}" (set discord.accounts.${params.accountId}.token or DISCORD_BOT_TOKEN for default).`);
+	}
+	return fallback;
+}
+function resolveRest(token, account, cfg, rest, proxyFetch, signal, timeoutMs) {
+	if (rest) return rest;
+	const resolvedProxyFetch = proxyFetch ?? resolveDiscordProxyFetchForAccount(account, cfg);
+	return createDiscordRequestClient(token, {
+		...resolvedProxyFetch ? { fetch: resolvedProxyFetch } : {},
+		...signal ? { signal } : {},
+		...timeoutMs !== void 0 ? { timeout: timeoutMs } : {}
+	});
+}
+function resolveAccountWithoutToken(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const merged = mergeDiscordAccountConfig(params.cfg, accountId);
+	const baseEnabled = params.cfg.channels?.discord?.enabled !== false;
+	const accountEnabled = merged.enabled !== false;
+	return {
+		accountId,
+		enabled: baseEnabled && accountEnabled,
+		name: normalizeOptionalString(merged.name),
+		token: "",
+		tokenSource: "none",
+		tokenStatus: "missing",
+		config: merged
+	};
+}
+function createDiscordRestClient(opts) {
+	const explicitToken = normalizeDiscordToken(opts.token, "channels.discord.token");
+	const proxyContext = resolveDiscordClientAccountContext(opts);
+	const resolvedCfg = proxyContext.cfg;
+	const account = explicitToken ? proxyContext.account : resolveDiscordAccount({
+		cfg: resolvedCfg,
+		accountId: opts.accountId
+	});
+	const token = explicitToken ?? resolveToken({
+		account,
+		accountId: account.accountId,
+		fallbackToken: account.token
+	});
+	return {
+		token,
+		rest: resolveRest(token, account, resolvedCfg, opts.rest, proxyContext.proxyFetch, opts.signal, opts.timeoutMs),
+		account
+	};
+}
+function createDiscordClient(opts) {
+	const { token, rest, account } = createDiscordRestClient(opts);
+	return {
+		token,
+		rest,
+		request: createDiscordRetryRunner({
+			retry: opts.retry,
+			configRetry: account.config.retry,
+			verbose: opts.verbose,
+			isGatewayDisconnected: () => {
+				const gateway = getGateway(account.accountId);
+				return gateway !== void 0 && !gateway.isConnected;
+			}
+		})
+	};
+}
+function resolveDiscordRest(opts) {
+	return createDiscordRestClient(opts).rest;
+}
+//#endregion
+//#region extensions/discord/src/recipient-resolution.ts
+async function parseAndResolveRecipient(raw, cfg, accountId, parseOptions = {}) {
+	if (!cfg) throw new Error("Discord recipient resolution requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
+	const resolvedCfg = requireRuntimeConfig(cfg, "Discord recipient resolution");
+	const accountInfo = resolveDiscordAccount({
+		cfg: resolvedCfg,
+		accountId
+	});
+	const resolved = await parseAndResolveDiscordTarget(raw, {
+		cfg: resolvedCfg,
+		accountId: accountInfo.accountId
+	}, parseOptions);
+	return {
+		kind: resolved.kind,
+		id: resolved.id
+	};
+}
+async function parseAndResolveChannelRecipient(raw, cfg, accountId) {
+	return await parseAndResolveRecipient(raw, cfg, accountId, { defaultKind: "channel" });
+}
+//#endregion
+//#region extensions/discord/src/send.permissions.ts
+const PERMISSION_ENTRIES = Object.entries(PermissionFlagsBits).filter(([, value]) => typeof value === "bigint");
+const ALL_PERMISSIONS = PERMISSION_ENTRIES.reduce((acc, [, value]) => acc | value, 0n);
+const ADMINISTRATOR_BIT = PermissionFlagsBits.Administrator;
+function addPermissionBits(base, add) {
+	if (!add) return base;
+	return base | BigInt(add);
+}
+function removePermissionBits(base, deny) {
+	if (!deny) return base;
+	return base & ~BigInt(deny);
+}
+function bitfieldToPermissions(bitfield) {
+	return PERMISSION_ENTRIES.filter(([, value]) => (bitfield & value) === value).map(([name]) => name).toSorted();
+}
+function hasAdministrator(bitfield) {
+	return (bitfield & ADMINISTRATOR_BIT) === ADMINISTRATOR_BIT;
+}
+function hasPermissionBit(bitfield, permission) {
+	return (bitfield & permission) === permission;
+}
+function isThreadChannelType(channelType) {
+	return channelType === ChannelType.GuildNewsThread || channelType === ChannelType.GuildPublicThread || channelType === ChannelType.GuildPrivateThread;
+}
+async function fetchBotUserId(rest) {
+	const me = await getCurrentUser(rest);
+	if (!me?.id) throw new Error("Failed to resolve bot user id");
+	return me.id;
+}
+function resolveMemberGuildPermissionBits(params) {
+	const rolesByIdLocal = new Map((params.guild.roles ?? []).map((role) => [role.id, role]));
+	const everyoneRole = rolesByIdLocal.get(params.guild.id);
+	let permissions = 0n;
+	if (everyoneRole?.permissions) permissions = addPermissionBits(permissions, everyoneRole.permissions);
+	for (const roleId of params.member.roles ?? []) {
+		const role = rolesByIdLocal.get(roleId);
+		if (role?.permissions) permissions = addPermissionBits(permissions, role.permissions);
+	}
+	return permissions;
+}
+function rolesById(guild) {
+	return new Map((guild.roles ?? []).map((role) => [role.id, role]));
+}
+function rolePosition(role) {
+	return typeof role?.position === "number" ? role.position : -1;
+}
+function highestMemberRolePosition(guild, member) {
+	const roles = rolesById(guild);
+	return Math.max(...(member.roles ?? []).map((roleId) => rolePosition(roles.get(roleId))), 0);
+}
+function resolveMemberChannelPermissionBits(params) {
+	let permissions = resolveMemberGuildPermissionBits({
+		guild: params.guild,
+		member: params.member
+	});
+	if (hasAdministrator(permissions)) return ALL_PERMISSIONS;
+	const overwrites = "permission_overwrites" in params.channel ? params.channel.permission_overwrites ?? [] : [];
+	for (const overwrite of overwrites) if (overwrite.id === params.guildId) {
+		permissions = removePermissionBits(permissions, overwrite.deny ?? "0");
+		permissions = addPermissionBits(permissions, overwrite.allow ?? "0");
+	}
+	let roleDeny = 0n;
+	let roleAllow = 0n;
+	for (const overwrite of overwrites) if (params.member.roles?.includes(overwrite.id)) {
+		roleDeny = addPermissionBits(roleDeny, overwrite.deny ?? "0");
+		roleAllow = addPermissionBits(roleAllow, overwrite.allow ?? "0");
+	}
+	permissions = permissions & ~roleDeny;
+	permissions = permissions | roleAllow;
+	for (const overwrite of overwrites) if (overwrite.id === params.userId) {
+		permissions = removePermissionBits(permissions, overwrite.deny ?? "0");
+		permissions = addPermissionBits(permissions, overwrite.allow ?? "0");
+	}
+	return permissions;
+}
+async function resolveChannelPermissionSubject(rest, channel) {
+	const channelType = "type" in channel ? channel.type : void 0;
+	const parentId = "parent_id" in channel ? channel.parent_id : void 0;
+	if (isThreadChannelType(channelType) && parentId) return await getChannel(rest, parentId);
+	return channel;
+}
+/**
+* Fetch guild-level permissions for a user. This does not include channel-specific overwrites.
+*/
+async function fetchMemberGuildPermissionsDiscord(guildId, userId, opts) {
+	const rest = resolveDiscordRest(opts);
+	try {
+		const [guild, member] = await Promise.all([getGuild(rest, guildId), getGuildMember(rest, guildId, userId)]);
+		if (guild.owner_id === userId) return ALL_PERMISSIONS;
+		return resolveMemberGuildPermissionBits({
+			guild,
+			member
+		});
+	} catch {
+		return null;
+	}
+}
+async function canViewDiscordGuildChannel(guildId, channelId, userId, opts) {
+	const rest = resolveDiscordRest(opts);
+	try {
+		const channel = await getChannel(rest, channelId);
+		if (("guild_id" in channel ? channel.guild_id : void 0) !== guildId) return false;
+		const [guild, member] = await Promise.all([getGuild(rest, guildId), getGuildMember(rest, guildId, userId)]);
+		if (guild.owner_id === userId) return true;
+		return hasPermissionBit(resolveMemberChannelPermissionBits({
+			guildId,
+			userId,
+			guild,
+			member,
+			channel
+		}), PermissionFlagsBits.ViewChannel);
+	} catch {
+		return false;
+	}
+}
+/**
+* Returns true when the user has ADMINISTRATOR or any required permission bit
+* after applying channel/category overwrites.
+*/
+async function hasAnyChannelPermissionDiscord(guildId, channelId, userId, requiredPermissions, opts) {
+	const rest = resolveDiscordRest(opts);
+	try {
+		const permissionChannel = await resolveChannelPermissionSubject(rest, await getChannel(rest, channelId));
+		if (("guild_id" in permissionChannel ? permissionChannel.guild_id : void 0) !== guildId) return false;
+		const [guild, member] = await Promise.all([getGuild(rest, guildId), getGuildMember(rest, guildId, userId)]);
+		if (guild.owner_id === userId) return true;
+		const permissions = resolveMemberChannelPermissionBits({
+			guildId,
+			userId,
+			guild,
+			member,
+			channel: permissionChannel
+		});
+		return requiredPermissions.some((permission) => hasPermissionBit(permissions, permission));
+	} catch {
+		return false;
+	}
+}
+async function canManageGuildMemberRoleDiscord(guildId, senderUserId, targetUserId, roleId, opts, requirements) {
+	const rest = resolveDiscordRest(opts);
+	try {
+		const [guild, senderMember, targetMember] = await Promise.all([
+			getGuild(rest, guildId),
+			getGuildMember(rest, guildId, senderUserId),
+			getGuildMember(rest, guildId, targetUserId)
+		]);
+		if (guild.owner_id === senderUserId) return true;
+		if (guild.owner_id === targetUserId) return false;
+		const targetRole = rolesById(guild).get(roleId);
+		const targetRolePosition = rolePosition(targetRole);
+		if (targetRolePosition < 0) return false;
+		const senderPermissions = resolveMemberGuildPermissionBits({
+			guild,
+			member: senderMember
+		});
+		if (requirements?.assignablePermissionCeiling && !hasAdministrator(senderPermissions) && (BigInt(targetRole?.permissions ?? "0") & ~senderPermissions) !== 0n) return false;
+		const senderHighestRolePosition = highestMemberRolePosition(guild, senderMember);
+		if (senderHighestRolePosition <= targetRolePosition) return false;
+		return senderHighestRolePosition > highestMemberRolePosition(guild, targetMember);
+	} catch {
+		return false;
+	}
+}
+async function canManageGuildRoleDiscord(guildId, senderUserId, roleId, opts) {
+	const rest = resolveDiscordRest(opts);
+	try {
+		const [guild, senderMember] = await Promise.all([getGuild(rest, guildId), getGuildMember(rest, guildId, senderUserId)]);
+		const targetRole = rolesById(guild).get(roleId);
+		if (!targetRole) return null;
+		if (guild.owner_id === senderUserId) return true;
+		return highestMemberRolePosition(guild, senderMember) > rolePosition(targetRole);
+	} catch {
+		return false;
+	}
+}
+/**
+* Returns true when the user has ADMINISTRATOR or required permission bits
+* matching the provided predicate.
+*/
+async function hasGuildPermissionsDiscord(guildId, userId, requiredPermissions, check, opts) {
+	const permissions = await fetchMemberGuildPermissionsDiscord(guildId, userId, opts);
+	if (permissions === null) return false;
+	if (hasAdministrator(permissions)) return true;
+	return check(permissions, requiredPermissions);
+}
+/**
+* Returns true when the user has ADMINISTRATOR or any required permission bit.
+*/
+async function hasAnyGuildPermissionDiscord(guildId, userId, requiredPermissions, opts) {
+	return await hasGuildPermissionsDiscord(guildId, userId, requiredPermissions, (permissions, required) => required.some((permission) => hasPermissionBit(permissions, permission)), opts);
+}
+/**
+* Returns true when the user has ADMINISTRATOR or all required permission bits.
+*/
+async function hasAllGuildPermissionsDiscord(guildId, userId, requiredPermissions, opts) {
+	return await hasGuildPermissionsDiscord(guildId, userId, requiredPermissions, (permissions, required) => required.every((permission) => hasPermissionBit(permissions, permission)), opts);
+}
+async function fetchChannelPermissionsDiscord(channelId, opts) {
+	opts.signal?.throwIfAborted();
+	const rest = resolveDiscordRest(opts);
+	const channel = await getChannel(rest, channelId);
+	opts.signal?.throwIfAborted();
+	const channelType = "type" in channel ? channel.type : void 0;
+	const guildId = "guild_id" in channel ? channel.guild_id : void 0;
+	if (!guildId) return {
+		channelId,
+		permissions: [],
+		raw: "0",
+		isDm: true,
+		channelType
+	};
+	const botId = await fetchBotUserId(rest);
+	opts.signal?.throwIfAborted();
+	const [guild, member] = await Promise.all([getGuild(rest, guildId), getGuildMember(rest, guildId, botId)]);
+	opts.signal?.throwIfAborted();
+	const permissions = resolveMemberChannelPermissionBits({
+		guildId,
+		userId: botId,
+		guild,
+		member,
+		channel
+	});
+	return {
+		channelId,
+		guildId,
+		permissions: bitfieldToPermissions(permissions),
+		raw: permissions.toString(),
+		isDm: false,
+		channelType
+	};
+}
+//#endregion
+//#region extensions/discord/src/send.types.ts
+var DiscordSendError = class extends Error {
+	constructor(message, opts) {
+		super(message);
+		this.name = "DiscordSendError";
+		if (opts) Object.assign(this, opts);
+	}
+	toString() {
+		return this.message;
+	}
+};
+const DISCORD_MAX_EMOJI_BYTES = 262144;
+const DISCORD_MAX_STICKER_BYTES = 524288;
+const DISCORD_MAX_EVENT_COVER_BYTES = 8388608;
+//#endregion
+//#region extensions/discord/src/send.message-request.ts
+const SUPPRESS_EMBEDS_FLAG = MessageFlags.SuppressEmbeds;
+const SUPPRESS_NOTIFICATIONS_FLAG = MessageFlags.SuppressNotifications;
+function resolveDiscordSendComponents(params) {
+	if (!params.components || !params.isFirst) return;
+	return typeof params.components === "function" ? params.components(params.text) : params.components;
+}
+function normalizeDiscordEmbeds(embeds) {
+	if (!embeds?.length) return;
+	return embeds.map((embed) => embed instanceof Embed ? embed : new Embed(embed));
+}
+function resolveDiscordSendEmbeds(params) {
+	if (!params.embeds || !params.isFirst) return;
+	return normalizeDiscordEmbeds(params.embeds);
+}
+function buildDiscordMessagePayload(params) {
+	const payload = {};
+	const hasV2 = hasV2Components(params.components);
+	const trimmed = params.text.trim();
+	if (!hasV2 && trimmed) payload.content = params.text;
+	if (params.components?.length) payload.components = params.components;
+	if (!hasV2 && params.embeds?.length) payload.embeds = params.embeds;
+	if (params.allowedMentions) payload.allowed_mentions = params.allowedMentions;
+	if (params.flags !== void 0) payload.flags = params.flags;
+	if (params.files?.length) payload.files = params.files;
+	return payload;
+}
+function resolveDiscordMessageFlags(params) {
+	let flags = 0;
+	if (params.suppressEmbeds) flags |= SUPPRESS_EMBEDS_FLAG;
+	if (params.silent) flags |= SUPPRESS_NOTIFICATIONS_FLAG;
+	return flags || void 0;
+}
+function buildDiscordMessageRequest(params) {
+	const payload = buildDiscordMessagePayload(params);
+	return stripUndefinedFields({
+		...serializePayload(payload),
+		...params.replyTo ? { message_reference: {
+			message_id: params.replyTo,
+			fail_if_not_exists: false
+		} } : {}
+	});
+}
+function stripUndefinedFields(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function hasV2Components(components) {
+	return Boolean(components?.some((component) => "isV2" in component && component.isV2));
+}
+//#endregion
+//#region extensions/discord/src/send.shared.ts
+const DISCORD_TEXT_LIMIT = 2e3;
+const DISCORD_MAX_STICKERS = 3;
+const DISCORD_POLL_MAX_ANSWERS = 10;
+const DISCORD_POLL_MAX_DURATION_HOURS = 768;
+const DISCORD_MISSING_PERMISSIONS = 50013;
+const DISCORD_CANNOT_DM = 50007;
+const DISCORD_UPLOAD_TOO_LARGE = 40005;
+const DISCORD_UPLOAD_TOO_LARGE_STATUS = 413;
+const DISCORD_UPLOAD_TOO_LARGE_NOTICE = "Attachment skipped: Discord rejected the file as too large.";
+function normalizeReactionEmoji(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) throw new Error("emoji required");
+	const customMatch = trimmed.match(/^<a?:([^:>]+):(\d+)>$/);
+	const identifier = customMatch ? `${customMatch[1]}:${customMatch[2]}` : trimmed.replace(/[\uFE0E\uFE0F]/g, "");
+	return encodeURIComponent(identifier);
+}
+function normalizeStickerIds(raw) {
+	const ids = normalizeStringEntries(raw);
+	if (ids.length === 0) throw new Error("At least one sticker id is required");
+	if (ids.length > DISCORD_MAX_STICKERS) throw new Error("Discord supports up to 3 stickers per message");
+	return ids;
+}
+function normalizeEmojiName(raw, label) {
+	const name = raw.trim();
+	if (!name) throw new Error(`${label} is required`);
+	return name;
+}
+function normalizeDiscordPollInput(input) {
+	const poll = normalizePollInput(input, { maxOptions: DISCORD_POLL_MAX_ANSWERS });
+	const duration = normalizePollDurationHours(poll.durationHours, {
+		defaultHours: 24,
+		maxHours: DISCORD_POLL_MAX_DURATION_HOURS
+	});
+	return {
+		question: { text: poll.question },
+		answers: poll.options.map((answer) => ({ poll_media: { text: answer } })),
+		duration,
+		allow_multiselect: poll.maxSelections > 1,
+		layout_type: PollLayoutType.Default
+	};
+}
+function getDiscordErrorCode(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = "code" in err && err.code !== void 0 ? err.code : "rawError" in err && err.rawError && typeof err.rawError === "object" ? err.rawError.code : void 0;
+	if (typeof candidate === "number") return candidate;
+	if (typeof candidate === "string" && /^\d+$/.test(candidate)) return Number(candidate);
+}
+function getDiscordErrorStatus(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = "status" in err && err.status !== void 0 ? err.status : "statusCode" in err && err.statusCode !== void 0 ? err.statusCode : void 0;
+	if (typeof candidate === "number" && Number.isFinite(candidate)) return candidate;
+	if (typeof candidate === "string" && /^\d+$/.test(candidate)) return Number(candidate);
+}
+function isDiscordUploadTooLargeError(err) {
+	return getDiscordErrorCode(err) === DISCORD_UPLOAD_TOO_LARGE || getDiscordErrorStatus(err) === DISCORD_UPLOAD_TOO_LARGE_STATUS;
+}
+function buildDiscordUploadTooLargeFallbackText(text) {
+	return text.trim() ? `${text}\n\n[${DISCORD_UPLOAD_TOO_LARGE_NOTICE}]` : DISCORD_UPLOAD_TOO_LARGE_NOTICE;
+}
+async function buildDiscordSendError(err, ctx) {
+	if (err instanceof DiscordSendError) return err;
+	const code = getDiscordErrorCode(err);
+	if (code === DISCORD_CANNOT_DM) return new DiscordSendError(`discord dm failed: user blocks dms or privacy settings disallow it (code=${code})`, {
+		kind: "dm-blocked",
+		discordCode: code,
+		status: getDiscordErrorStatus(err)
+	});
+	if (code !== DISCORD_MISSING_PERMISSIONS) return err;
+	let missing = [];
+	let probedChannelType;
+	try {
+		const permissions = await fetchChannelPermissionsDiscord(ctx.channelId, {
+			rest: ctx.rest,
+			token: ctx.token,
+			cfg: ctx.cfg
+		});
+		probedChannelType = permissions.channelType;
+		const current = new Set(permissions.permissions);
+		const required = ["ViewChannel", "SendMessages"];
+		if (isThreadChannelType(probedChannelType)) required.push("SendMessagesInThreads");
+		if (ctx.hasMedia) required.push("AttachFiles");
+		missing = required.filter((permission) => !current.has(permission));
+	} catch {}
+	const status = getDiscordErrorStatus(err);
+	const apiDetails = [`code=${code}`, status != null ? `status=${status}` : void 0].filter(Boolean).join(" ");
+	const probedPermissions = ["ViewChannel", "SendMessages"];
+	if (isThreadChannelType(probedChannelType)) probedPermissions.push("SendMessagesInThreads");
+	if (ctx.hasMedia) probedPermissions.push("AttachFiles");
+	const probeSummary = probedPermissions.join("/");
+	return new DiscordSendError(`${missing.length ? `discord missing permissions in channel ${ctx.channelId}: ${missing.join(", ")}` : `discord missing permissions in channel ${ctx.channelId}; permission probe did not identify missing ${probeSummary}`} (${apiDetails}). bot might be blocked by channel/thread overrides, archived thread state, reply target visibility, or app-role position`, {
+		kind: "missing-permissions",
+		channelId: ctx.channelId,
+		missingPermissions: missing,
+		discordCode: code,
+		status
+	});
+}
+async function resolveChannelId(rest, recipient, request) {
+	if (recipient.kind === "channel") return { channelId: recipient.id };
+	const dmChannel = await request(() => createUserDmChannel(rest, recipient.id), "dm-channel");
+	if (!dmChannel?.id) throw new Error("Failed to create Discord DM channel");
+	return {
+		channelId: dmChannel.id,
+		dm: true
+	};
+}
+async function resolveDiscordTargetChannelId(raw, opts) {
+	const recipient = await parseAndResolveRecipient(raw, requireRuntimeConfig(opts.cfg, "Discord target channel resolution"), opts.accountId, { defaultKind: "channel" });
+	const { rest, request } = createDiscordClient(opts);
+	return await resolveChannelId(rest, recipient, request);
+}
+async function resolveDiscordChannelType(rest, channelId) {
+	try {
+		return (await getChannel(rest, channelId))?.type;
+	} catch {
+		return;
+	}
+}
+function buildDiscordTextChunks(text, opts = {}) {
+	if (!text) return [];
+	const chunks = chunkDiscordTextWithMode(text, {
+		maxChars: opts.maxChars ?? DISCORD_TEXT_LIMIT,
+		maxLines: opts.maxLinesPerMessage,
+		chunkMode: opts.chunkMode
+	});
+	return resolveTextChunksWithFallback(text, chunks);
+}
+function toDiscordFileBlob(data) {
+	if (data instanceof Blob) return data;
+	const arrayBuffer = new ArrayBuffer(data.byteLength);
+	new Uint8Array(arrayBuffer).set(data);
+	return new Blob([arrayBuffer]);
+}
+async function sendDiscordText(params) {
+	const { rest, channelId, text, request, reply, maxLinesPerMessage, components, embeds, allowedMentions, chunkMode, silent, suppressEmbeds, maxChars, onResult } = params;
+	if (!text.trim()) throw new Error("Message must be non-empty for Discord sends");
+	const chunks = buildDiscordTextChunks(text, {
+		maxLinesPerMessage,
+		chunkMode,
+		maxChars
+	});
+	const sendChunk = async (chunk, isFirst) => {
+		const chunkReplyTo = resolveDiscordReplyMessageId(reply, isFirst);
+		const chunkComponents = resolveDiscordSendComponents({
+			components,
+			text: chunk,
+			isFirst
+		});
+		const chunkEmbeds = resolveDiscordSendEmbeds({
+			embeds,
+			isFirst
+		});
+		const flags = resolveDiscordMessageFlags({
+			silent,
+			suppressEmbeds: suppressEmbeds && !chunkEmbeds?.length
+		});
+		const body = buildDiscordMessageRequest({
+			text: chunk,
+			components: chunkComponents,
+			embeds: chunkEmbeds,
+			allowedMentions,
+			flags,
+			replyTo: chunkReplyTo
+		});
+		return {
+			result: await request(() => createChannelMessage(rest, channelId, { body }), "text"),
+			replyToId: chunkReplyTo
+		};
+	};
+	if (chunks.length === 1) {
+		const { result, replyToId } = await sendChunk(chunks[0], true);
+		await onResult?.(result, "text", replyToId);
+		return {
+			...result,
+			platformMessageIds: result.id ? [result.id] : []
+		};
+	}
+	const platformMessageIds = [];
+	let last = null;
+	for (const [index, chunk] of chunks.entries()) {
+		const sent = await sendChunk(chunk, index === 0);
+		last = sent.result;
+		await onResult?.(last, "text", sent.replyToId);
+		if (last.id) platformMessageIds.push(last.id);
+	}
+	if (!last) throw new Error("Discord send failed (empty chunk result)");
+	return {
+		...last,
+		platformMessageIds
+	};
+}
+async function sendDiscordMedia(params) {
+	const { rest, channelId, text, mediaUrl, filename, mediaAccess, mediaLocalRoots, mediaReadFile, maxBytes, reply, request, maxLinesPerMessage, components, embeds, allowedMentions, chunkMode, silent, suppressEmbeds, maxChars, onResult } = params;
+	const media = await loadWebMedia(mediaUrl, buildOutboundMediaLoadOptions({
+		maxBytes,
+		mediaAccess,
+		mediaLocalRoots,
+		mediaReadFile
+	}));
+	const resolvedFileName = filename?.trim() || media.fileName || (media.contentType ? `upload${extensionForMime(media.contentType) ?? ""}` : "") || "upload";
+	const chunks = text ? buildDiscordTextChunks(text, {
+		maxLinesPerMessage,
+		chunkMode,
+		maxChars
+	}) : [];
+	const caption = chunks[0] ?? "";
+	const fileData = toDiscordFileBlob(media.buffer);
+	const captionComponents = resolveDiscordSendComponents({
+		components,
+		text: caption,
+		isFirst: true
+	});
+	const captionEmbeds = resolveDiscordSendEmbeds({
+		embeds,
+		isFirst: true
+	});
+	const body = buildDiscordMessageRequest({
+		text: caption,
+		components: captionComponents,
+		embeds: captionEmbeds,
+		allowedMentions,
+		flags: resolveDiscordMessageFlags({
+			silent,
+			suppressEmbeds: suppressEmbeds && !captionEmbeds?.length
+		}),
+		replyTo: resolveDiscordReplyMessageId(reply, true),
+		files: [{
+			data: fileData,
+			name: resolvedFileName
+		}]
+	});
+	let res;
+	try {
+		res = await request(() => createChannelMessage(rest, channelId, { body }), "media");
+	} catch (err) {
+		if (!isDiscordUploadTooLargeError(err)) throw err;
+		return sendDiscordText({
+			rest,
+			channelId,
+			text: buildDiscordUploadTooLargeFallbackText(text),
+			reply,
+			request,
+			maxLinesPerMessage,
+			chunkMode,
+			silent,
+			suppressEmbeds,
+			allowedMentions,
+			maxChars,
+			onResult
+		});
+	}
+	await onResult?.(res, "media", reply?.messageId);
+	const platformMessageIds = res.id ? [res.id] : [];
+	const followupReply = reply?.scope === "all" ? reply : void 0;
+	for (const chunk of chunks.slice(1)) {
+		if (!chunk.trim()) continue;
+		const followup = await sendDiscordText({
+			rest,
+			channelId,
+			text: chunk,
+			reply: followupReply,
+			request,
+			maxLinesPerMessage,
+			chunkMode,
+			silent,
+			suppressEmbeds,
+			allowedMentions,
+			maxChars,
+			onResult
+		});
+		for (const id of followup.platformMessageIds) if (id) platformMessageIds.push(id);
+	}
+	return {
+		...res,
+		platformMessageIds
+	};
+}
+function buildReactionIdentifier(emoji) {
+	if (emoji.id && emoji.name) return `${emoji.name}:${emoji.id}`;
+	return emoji.name ?? "";
+}
+function formatReactionEmoji(emoji) {
+	return buildReactionIdentifier(emoji);
+}
+//#endregion
+export { hasAllGuildPermissionsDiscord as A, DISCORD_REST_TIMEOUT_MS as B, DISCORD_MAX_STICKER_BYTES as C, canViewDiscordGuildChannel as D, canManageGuildRoleDiscord as E, createDiscordClient as F, registerGateway as G, withValidatedDiscordProxy as H, createDiscordRestClient as I, unregisterGateway as K, createDiscordRuntimeAccountContext as L, hasAnyGuildPermissionDiscord as M, isThreadChannelType as N, fetchChannelPermissionsDiscord as O, parseAndResolveChannelRecipient as P, resolveDiscordClientAccountContext as R, DISCORD_MAX_EVENT_COVER_BYTES as S, canManageGuildMemberRoleDiscord as T, clearGateways as U, validateDiscordProxyUrl as V, getGateway as W, resolveDiscordMessageFlags as _, normalizeDiscordPollInput as a, stripUndefinedFields as b, normalizeStickerIds as c, resolveDiscordTargetChannelId as d, sendDiscordMedia as f, buildDiscordMessageRequest as g, SUPPRESS_NOTIFICATIONS_FLAG as h, formatReactionEmoji as i, hasAnyChannelPermissionDiscord as j, fetchMemberGuildPermissionsDiscord as k, resolveChannelId as l, toDiscordFileBlob as m, buildDiscordTextChunks as n, normalizeEmojiName as o, sendDiscordText as p, buildReactionIdentifier as r, normalizeReactionEmoji as s, buildDiscordSendError as t, resolveDiscordChannelType as u, resolveDiscordSendComponents as v, DiscordSendError as w, DISCORD_MAX_EMOJI_BYTES as x, resolveDiscordSendEmbeds as y, resolveDiscordRest as z };