@kodelyth/discord 2026.5.39 → 2026.5.42

package/dist/allow-list-B0s7evD7.js

@@ -0,0 +1,354 @@
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { buildChannelKeyCandidates, resolveChannelEntryMatchWithFallback, resolveChannelMatchConfig } from "klaw/plugin-sdk/channel-targets";
+//#region extensions/discord/src/monitor/format.ts
+function resolveDiscordSystemLocation(params) {
+	const { isDirectMessage, isGroupDm, guild, channelName } = params;
+	if (isDirectMessage) return "DM";
+	if (isGroupDm) return `Group DM #${channelName}`;
+	return guild?.name ? `${guild.name} #${channelName}` : `#${channelName}`;
+}
+function formatDiscordReactionEmoji(emoji) {
+	if (emoji.id && emoji.name) return `<:${emoji.name}:${emoji.id}>`;
+	if (emoji.id) return `emoji:${emoji.id}`;
+	return emoji.name ?? "emoji";
+}
+function formatDiscordUserTag(user) {
+	const discriminator = (user.discriminator ?? "").trim();
+	if (discriminator && discriminator !== "0") return `${user.username}#${discriminator}`;
+	return user.username ?? user.id;
+}
+function resolveTimestampMs(timestamp) {
+	if (!timestamp) return;
+	const parsed = Date.parse(timestamp);
+	return Number.isNaN(parsed) ? void 0 : parsed;
+}
+//#endregion
+//#region extensions/discord/src/monitor/allow-list.ts
+const DISCORD_OWNER_ALLOWLIST_PREFIXES = [
+	"discord:",
+	"user:",
+	"pk:"
+];
+function normalizeDiscordAllowList(raw, prefixes) {
+	if (!raw || raw.length === 0) return null;
+	const ids = /* @__PURE__ */ new Set();
+	const names = /* @__PURE__ */ new Set();
+	const allowAll = raw.some((entry) => (normalizeOptionalString(entry) ?? "") === "*");
+	for (const entry of raw) {
+		const text = normalizeOptionalString(entry) ?? "";
+		if (!text || text === "*") continue;
+		const normalized = normalizeDiscordSlug(text);
+		const maybeId = text.replace(/^<@!?/, "").replace(/>$/, "");
+		if (/^\d+$/.test(maybeId)) {
+			ids.add(maybeId);
+			continue;
+		}
+		const prefix = prefixes.find((entry) => text.startsWith(entry));
+		if (prefix) {
+			const candidate = text.slice(prefix.length);
+			if (candidate) ids.add(candidate);
+			continue;
+		}
+		if (normalized) names.add(normalized);
+	}
+	return {
+		allowAll,
+		ids,
+		names
+	};
+}
+function normalizeDiscordSlug(value) {
+	return normalizeLowercaseStringOrEmpty(value).replace(/^#/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeDiscordDisplaySlug(value) {
+	return normalizeLowercaseStringOrEmpty(value).normalize("NFC").replace(/^#/, "").replace(/[\s_]+/g, "-").replace(/[^\p{L}\p{M}\p{N}-]+/gu, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+}
+function resolveDiscordAllowListNameMatch(list, candidate) {
+	const nameSlug = candidate.name ? normalizeDiscordSlug(candidate.name) : "";
+	if (nameSlug && list.names.has(nameSlug)) return {
+		matchKey: nameSlug,
+		matchSource: "name"
+	};
+	const tagSlug = candidate.tag ? normalizeDiscordSlug(candidate.tag) : "";
+	if (tagSlug && list.names.has(tagSlug)) return {
+		matchKey: tagSlug,
+		matchSource: "tag"
+	};
+	return null;
+}
+function allowListMatches(list, candidate, params) {
+	if (list.allowAll) return true;
+	if (candidate.id && list.ids.has(candidate.id)) return true;
+	if (params?.allowNameMatching === true) {
+		if (resolveDiscordAllowListNameMatch(list, candidate)) return true;
+	}
+	return false;
+}
+function resolveDiscordAllowListMatch(params) {
+	const { allowList, candidate } = params;
+	if (allowList.allowAll) return {
+		allowed: true,
+		matchKey: "*",
+		matchSource: "wildcard"
+	};
+	if (candidate.id && allowList.ids.has(candidate.id)) return {
+		allowed: true,
+		matchKey: candidate.id,
+		matchSource: "id"
+	};
+	if (params.allowNameMatching === true) {
+		const namedMatch = resolveDiscordAllowListNameMatch(allowList, candidate);
+		if (namedMatch) return {
+			allowed: true,
+			...namedMatch
+		};
+	}
+	return { allowed: false };
+}
+function resolveDiscordUserAllowed(params) {
+	const allowList = normalizeDiscordAllowList(params.allowList, [
+		"discord:",
+		"user:",
+		"pk:"
+	]);
+	if (!allowList) return true;
+	return allowListMatches(allowList, {
+		id: params.userId,
+		name: params.userName,
+		tag: params.userTag
+	}, { allowNameMatching: params.allowNameMatching });
+}
+function resolveDiscordRoleAllowed(params) {
+	const allowList = normalizeDiscordAllowList(params.allowList, ["role:"]);
+	if (!allowList) return true;
+	if (allowList.allowAll) return true;
+	return params.memberRoleIds.some((roleId) => allowList.ids.has(roleId));
+}
+function resolveDiscordMemberAllowed(params) {
+	const hasUserRestriction = Array.isArray(params.userAllowList) && params.userAllowList.length > 0;
+	const hasRoleRestriction = Array.isArray(params.roleAllowList) && params.roleAllowList.length > 0;
+	if (!hasUserRestriction && !hasRoleRestriction) return true;
+	const userOk = hasUserRestriction ? resolveDiscordUserAllowed({
+		allowList: params.userAllowList,
+		userId: params.userId,
+		userName: params.userName,
+		userTag: params.userTag,
+		allowNameMatching: params.allowNameMatching
+	}) : false;
+	const roleOk = hasRoleRestriction ? resolveDiscordRoleAllowed({
+		allowList: params.roleAllowList,
+		memberRoleIds: params.memberRoleIds
+	}) : false;
+	return userOk || roleOk;
+}
+function resolveDiscordMemberAccessState(params) {
+	const channelUsers = params.channelConfig?.users ?? params.guildInfo?.users;
+	const channelRoles = params.channelConfig?.roles ?? params.guildInfo?.roles;
+	return {
+		channelUsers,
+		channelRoles,
+		hasAccessRestrictions: Array.isArray(channelUsers) && channelUsers.length > 0 || Array.isArray(channelRoles) && channelRoles.length > 0,
+		memberAllowed: resolveDiscordMemberAllowed({
+			userAllowList: channelUsers,
+			roleAllowList: channelRoles,
+			memberRoleIds: params.memberRoleIds,
+			userId: params.sender.id,
+			userName: params.sender.name,
+			userTag: params.sender.tag,
+			allowNameMatching: params.allowNameMatching
+		})
+	};
+}
+function resolveDiscordOwnerAllowFrom(params) {
+	const rawAllowList = params.channelConfig?.users ?? params.guildInfo?.users;
+	if (!Array.isArray(rawAllowList) || rawAllowList.length === 0) return;
+	const allowList = normalizeDiscordAllowList(rawAllowList, [
+		"discord:",
+		"user:",
+		"pk:"
+	]);
+	if (!allowList) return;
+	const match = resolveDiscordAllowListMatch({
+		allowList,
+		candidate: {
+			id: params.sender.id,
+			name: params.sender.name,
+			tag: params.sender.tag
+		},
+		allowNameMatching: params.allowNameMatching
+	});
+	if (!match.allowed || !match.matchKey || match.matchKey === "*") return;
+	return [match.matchKey];
+}
+function resolveDiscordOwnerAccess(params) {
+	const ownerAllowFrom = params.allowFrom?.filter((entry) => (normalizeOptionalString(entry) ?? "") !== "*");
+	const ownerAllowList = normalizeDiscordAllowList(ownerAllowFrom && ownerAllowFrom.length > 0 ? ownerAllowFrom : void 0, DISCORD_OWNER_ALLOWLIST_PREFIXES);
+	return {
+		ownerAllowList,
+		ownerAllowed: ownerAllowList ? allowListMatches(ownerAllowList, {
+			id: params.sender.id,
+			name: params.sender.name,
+			tag: params.sender.tag
+		}, { allowNameMatching: params.allowNameMatching }) : false
+	};
+}
+function resolveDiscordCommandAuthorized(params) {
+	if (!params.isDirectMessage) return true;
+	const allowList = normalizeDiscordAllowList(params.allowFrom, [
+		"discord:",
+		"user:",
+		"pk:"
+	]);
+	if (!allowList) return true;
+	return allowListMatches(allowList, {
+		id: params.author.id,
+		name: params.author.username,
+		tag: formatDiscordUserTag(params.author)
+	}, { allowNameMatching: params.allowNameMatching });
+}
+function resolveDiscordGuildEntry(params) {
+	const guild = params.guild;
+	const entries = params.guildEntries;
+	const guildId = params.guildId?.trim() || guild?.id;
+	if (!entries) return null;
+	const byId = guildId ? entries[guildId] : void 0;
+	if (byId) return {
+		...byId,
+		id: guildId
+	};
+	if (!guild) return null;
+	const slug = normalizeDiscordSlug(guild.name ?? "");
+	const bySlug = entries[slug];
+	if (bySlug) return {
+		...bySlug,
+		id: guildId ?? guild.id,
+		slug: slug || bySlug.slug
+	};
+	const wildcard = entries["*"];
+	if (wildcard) return {
+		...wildcard,
+		id: guildId ?? guild.id,
+		slug: slug || wildcard.slug
+	};
+	return null;
+}
+function buildDiscordChannelKeys(params) {
+	const allowNameMatch = params.allowNameMatch !== false;
+	return buildChannelKeyCandidates(params.id, allowNameMatch ? params.slug : void 0, allowNameMatch ? params.name : void 0);
+}
+function resolveDiscordChannelEntryMatch(channels, params, parentParams) {
+	return resolveChannelEntryMatchWithFallback({
+		entries: channels,
+		keys: buildDiscordChannelKeys(params),
+		parentKeys: parentParams ? buildDiscordChannelKeys(parentParams) : void 0,
+		wildcardKey: "*"
+	});
+}
+function hasConfiguredDiscordChannels(channels) {
+	return Boolean(channels && Object.keys(channels).length > 0);
+}
+function resolveDiscordChannelConfigEntry(entry) {
+	return {
+		allowed: entry.enabled !== false,
+		requireMention: entry.requireMention,
+		ignoreOtherMentions: entry.ignoreOtherMentions,
+		skills: entry.skills,
+		enabled: entry.enabled,
+		users: entry.users,
+		roles: entry.roles,
+		systemPrompt: entry.systemPrompt,
+		includeThreadStarter: entry.includeThreadStarter,
+		autoThread: entry.autoThread,
+		autoThreadName: entry.autoThreadName,
+		autoArchiveDuration: entry.autoArchiveDuration
+	};
+}
+function resolveDiscordChannelConfig(params) {
+	const { guildInfo, channelId, channelName, channelSlug } = params;
+	const channels = guildInfo?.channels;
+	if (!hasConfiguredDiscordChannels(channels)) return null;
+	return resolveChannelMatchConfig(resolveDiscordChannelEntryMatch(channels, {
+		id: channelId,
+		name: channelName,
+		slug: channelSlug
+	}), resolveDiscordChannelConfigEntry) ?? { allowed: false };
+}
+function resolveDiscordChannelConfigWithFallback(params) {
+	const { guildInfo, channelId, channelName, channelSlug, parentId, parentName, parentSlug, scope } = params;
+	const channels = guildInfo?.channels;
+	if (!hasConfiguredDiscordChannels(channels)) return null;
+	const resolvedParentSlug = parentSlug ?? (parentName ? normalizeDiscordSlug(parentName) : "");
+	return resolveChannelMatchConfig(resolveDiscordChannelEntryMatch(channels, {
+		id: channelId,
+		name: channelName,
+		slug: channelSlug,
+		allowNameMatch: scope !== "thread"
+	}, parentId || parentName || parentSlug ? {
+		id: parentId ?? "",
+		name: parentName,
+		slug: resolvedParentSlug
+	} : void 0), resolveDiscordChannelConfigEntry) ?? { allowed: false };
+}
+function resolveDiscordShouldRequireMention(params) {
+	if (!params.isGuildMessage) return false;
+	if (params.isAutoThreadOwnedByBot ?? isDiscordAutoThreadOwnedByBot(params)) return false;
+	return params.channelConfig?.requireMention ?? params.guildInfo?.requireMention ?? true;
+}
+function isDiscordAutoThreadOwnedByBot(params) {
+	if (!params.isThread) return false;
+	if (!params.channelConfig?.autoThread) return false;
+	const botId = params.botId?.trim();
+	const threadOwnerId = params.threadOwnerId?.trim();
+	return Boolean(botId && threadOwnerId && botId === threadOwnerId);
+}
+function isDiscordGroupAllowedByPolicy(params) {
+	if (params.groupPolicy === "allowlist" && !params.guildAllowlisted) return false;
+	if (params.groupPolicy === "disabled") return false;
+	return params.groupPolicy !== "allowlist" || !params.channelAllowlistConfigured || params.channelAllowed;
+}
+function resolveDiscordChannelPolicyCommandAuthorizer(params) {
+	const channelAllowlistConfigured = Boolean(params.guildInfo?.channels) && Object.keys(params.guildInfo?.channels ?? {}).length > 0;
+	return {
+		configured: params.groupPolicy === "allowlist" && (Boolean(params.guildInfo) || channelAllowlistConfigured),
+		allowed: isDiscordGroupAllowedByPolicy({
+			groupPolicy: params.groupPolicy,
+			guildAllowlisted: Boolean(params.guildInfo),
+			channelAllowlistConfigured,
+			channelAllowed: params.channelConfig?.allowed !== false
+		})
+	};
+}
+function resolveGroupDmAllow(params) {
+	const { channels, channelId, channelName, channelSlug } = params;
+	if (!channels || channels.length === 0) return true;
+	const allowList = new Set(channels.map((entry) => normalizeDiscordSlug(entry)));
+	const candidates = [
+		normalizeDiscordSlug(channelId),
+		channelSlug,
+		channelName ? normalizeDiscordSlug(channelName) : ""
+	].filter(Boolean);
+	return allowList.has("*") || candidates.some((candidate) => allowList.has(candidate));
+}
+function shouldEmitDiscordReactionNotification(params) {
+	const mode = params.mode ?? "own";
+	if (mode === "off") return false;
+	const accessGuildInfo = params.guildInfo ?? (params.allowlist ? { users: params.allowlist } : null);
+	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+		channelConfig: params.channelConfig,
+		guildInfo: accessGuildInfo,
+		memberRoleIds: params.memberRoleIds ?? [],
+		sender: {
+			id: params.userId,
+			name: params.userName,
+			tag: params.userTag
+		},
+		allowNameMatching: params.allowNameMatching
+	});
+	if (mode === "allowlist") return hasAccessRestrictions && memberAllowed;
+	if (hasAccessRestrictions && !memberAllowed) return false;
+	if (mode === "all") return true;
+	if (mode === "own") return Boolean(params.botId && params.messageAuthorId === params.botId);
+	return false;
+}
+//#endregion
+export { resolveTimestampMs as S, resolveGroupDmAllow as _, normalizeDiscordSlug as a, formatDiscordUserTag as b, resolveDiscordChannelConfigWithFallback as c, resolveDiscordGuildEntry as d, resolveDiscordMemberAccessState as f, resolveDiscordShouldRequireMention as g, resolveDiscordOwnerAllowFrom as h, normalizeDiscordDisplaySlug as i, resolveDiscordChannelPolicyCommandAuthorizer as l, resolveDiscordOwnerAccess as m, isDiscordGroupAllowedByPolicy as n, resolveDiscordAllowListMatch as o, resolveDiscordMemberAllowed as p, normalizeDiscordAllowList as r, resolveDiscordChannelConfig as s, allowListMatches as t, resolveDiscordCommandAuthorized as u, shouldEmitDiscordReactionNotification as v, resolveDiscordSystemLocation as x, formatDiscordReactionEmoji as y };

package/dist/api-CXAcv9nZ.js

@@ -0,0 +1,130 @@
+import { resolveFetch } from "klaw/plugin-sdk/fetch-runtime";
+import { resolveRetryConfig, retryAsync } from "klaw/plugin-sdk/retry-runtime";
+//#region extensions/discord/src/error-body.ts
+const DISCORD_RESPONSE_BODY_SUMMARY_MAX_CHARS = 240;
+function summarizeDiscordResponseBody(body, opts = {}) {
+	const summary = body.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/\s+/g, " ").trim();
+	if (!summary) return opts.emptyText;
+	return summary.slice(0, DISCORD_RESPONSE_BODY_SUMMARY_MAX_CHARS);
+}
+function isDiscordHtmlResponseBody(body, contentType) {
+	return /\bhtml\b/i.test(contentType ?? "") || /^\s*<!doctype\s+html\b/i.test(body) || /^\s*<html\b/i.test(body);
+}
+function isDiscordRateLimitResponseBody(body) {
+	const normalized = body.toLowerCase();
+	return normalized.includes("error 1015") || normalized.includes("cloudflare") || normalized.includes("rate limit");
+}
+//#endregion
+//#region extensions/discord/src/api.ts
+const DISCORD_API_BASE = "https://discord.com/api/v10";
+const DISCORD_API_RETRY_DEFAULTS = {
+	attempts: 3,
+	minDelayMs: 500,
+	maxDelayMs: 5 * 6e4,
+	jitter: .1
+};
+const DISCORD_API_429_FALLBACK_RETRY_AFTER_SECONDS = 60;
+function parseDiscordApiErrorPayload(text) {
+	const trimmed = text.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+	try {
+		const payload = JSON.parse(trimmed);
+		if (payload && typeof payload === "object") return payload;
+	} catch {
+		return null;
+	}
+	return null;
+}
+function parseRetryAfterSeconds(text, response) {
+	const payload = parseDiscordApiErrorPayload(text);
+	const retryAfter = payload && typeof payload.retry_after === "number" && Number.isFinite(payload.retry_after) ? payload.retry_after : void 0;
+	if (retryAfter !== void 0) return retryAfter;
+	const header = response.headers.get("Retry-After");
+	if (!header) return;
+	const parsed = Number(header);
+	if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+	const retryAt = Date.parse(header);
+	if (!Number.isFinite(retryAt)) return;
+	return Math.max(0, (retryAt - Date.now()) / 1e3);
+}
+function formatRetryAfterSeconds(value) {
+	if (value === void 0 || !Number.isFinite(value) || value < 0) return;
+	return `${value < 10 ? value.toFixed(1) : Math.round(value).toString()}s`;
+}
+function formatDiscordApiErrorText(text, response) {
+	const trimmed = text.trim();
+	if (!trimmed) return;
+	const payload = parseDiscordApiErrorPayload(trimmed);
+	if (!payload) {
+		if (trimmed.startsWith("{") && trimmed.endsWith("}")) return "unknown error";
+		const summary = summarizeDiscordResponseBody(trimmed);
+		if (isDiscordHtmlResponseBody(trimmed, response.headers.get("content-type"))) {
+			if (!summary) return response.status === 429 ? "rate limited by Discord upstream" : void 0;
+			return response.status === 429 ? `rate limited by Discord upstream: ${summary}` : summary;
+		}
+		return summary;
+	}
+	const message = typeof payload.message === "string" && payload.message.trim() ? payload.message.trim() : "unknown error";
+	const retryAfter = formatRetryAfterSeconds(typeof payload.retry_after === "number" ? payload.retry_after : void 0);
+	return retryAfter ? `${message} (retry after ${retryAfter})` : message;
+}
+var DiscordApiError = class extends Error {
+	constructor(message, status, retryAfter) {
+		super(message);
+		this.status = status;
+		this.retryAfter = retryAfter;
+	}
+};
+function getDiscordApiRetryAfterMs(err, retryConfig) {
+	if (!(err instanceof DiscordApiError) || typeof err.retryAfter !== "number") return;
+	return Math.min(Math.max(0, err.retryAfter * 1e3), retryConfig.maxDelayMs);
+}
+function normalizeDiscordRequestBody(body, headers) {
+	if (body === void 0) return;
+	if (typeof body === "string" || body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams || body instanceof ArrayBuffer) return body;
+	headers.set("Content-Type", headers.get("Content-Type") ?? "application/json");
+	return JSON.stringify(body);
+}
+function resolveDiscordRequestSignal(options) {
+	if (options.signal || typeof options.timeoutMs !== "number") return options.signal;
+	return AbortSignal.timeout(options.timeoutMs);
+}
+async function requestDiscord(path, token, options) {
+	const fetchImpl = resolveFetch(options?.fetcher ?? fetch);
+	if (!fetchImpl) throw new Error("fetch is not available");
+	const retryConfig = resolveRetryConfig(DISCORD_API_RETRY_DEFAULTS, options?.retry);
+	return retryAsync(async () => {
+		const headers = new Headers(options?.headers);
+		headers.set("Authorization", `Bot ${token}`);
+		const body = normalizeDiscordRequestBody(options?.body, headers);
+		const res = await fetchImpl(`${DISCORD_API_BASE}${path}`, {
+			method: options?.method ?? (body === void 0 ? "GET" : "POST"),
+			headers,
+			body,
+			signal: resolveDiscordRequestSignal(options ?? {})
+		});
+		const text = await res.text().catch(() => "");
+		if (!res.ok) {
+			const detail = formatDiscordApiErrorText(text, res);
+			const suffix = detail ? `: ${detail}` : "";
+			const retryAfter = res.status === 429 ? parseRetryAfterSeconds(text, res) ?? DISCORD_API_429_FALLBACK_RETRY_AFTER_SECONDS : void 0;
+			throw new DiscordApiError(`Discord API ${path} failed (${res.status})${suffix}`, res.status, retryAfter);
+		}
+		if (!text.trim()) return;
+		return JSON.parse(text);
+	}, {
+		...retryConfig,
+		label: options?.label ?? path,
+		shouldRetry: (err) => err instanceof DiscordApiError && err.status === 429,
+		retryAfterMs: (err) => getDiscordApiRetryAfterMs(err, retryConfig)
+	});
+}
+async function fetchDiscord(path, token, fetcher = fetch, options) {
+	return await requestDiscord(path, token, {
+		...options,
+		fetcher,
+		method: "GET"
+	});
+}
+//#endregion
+export { summarizeDiscordResponseBody as a, isDiscordRateLimitResponseBody as i, fetchDiscord as n, requestDiscord as r, DiscordApiError as t };

package/dist/api.js

@@ -0,0 +1,23 @@
+import { Ht as parseDiscordTarget, Ut as resolveDiscordChannelId, a as normalizeDiscordMessagingTarget, i as looksLikeDiscordTargetId, o as normalizeDiscordOutboundTarget } from "./send.receipt-CDn3GBWC.js";
+import { a as mergeDiscordAccountConfig, f as resolveDiscordMaxLinesPerMessage, i as listEnabledDiscordAccounts, l as resolveDiscordAccountConfig, o as resolveDefaultDiscordAccountId, r as listDiscordAccountIds, s as resolveDiscordAccount, t as createDiscordActionGate } from "./accounts-B7OBFePq.js";
+import { t as inspectDiscordAccount } from "./account-inspect-Dqw-enky.js";
+import { _ as parseDiscordComponentCustomId, b as parseDiscordModalCustomIdForInteraction, c as buildDiscordComponentMessage, d as readDiscordComponentSpec, f as resolveDiscordComponentAttachmentName, g as buildDiscordModalCustomId, h as buildDiscordComponentCustomId, l as buildDiscordComponentMessageFlags, m as DISCORD_MODAL_CUSTOM_ID_KEY, n as formatDiscordComponentEventText, o as DiscordFormModal, p as DISCORD_COMPONENT_CUSTOM_ID_KEY, r as buildDiscordInteractiveComponents, s as createDiscordFormModal, u as DISCORD_COMPONENT_ATTACHMENT_PREFIX, v as parseDiscordComponentCustomIdForInteraction, y as parseDiscordModalCustomId } from "./components-luonoe13.js";
+import { n as fetchDiscord, r as requestDiscord, t as DiscordApiError } from "./api-CXAcv9nZ.js";
+import { i as parseDiscordSendTarget, n as resolveDiscordTarget } from "./target-resolver-BrtFQtoK.js";
+import "./targets-DWLLZE2l.js";
+import { a as getDiscordExecApprovalApprovers, c as shouldSuppressLocalDiscordExecApprovalPrompt, o as isDiscordExecApprovalApprover, s as isDiscordExecApprovalClientEnabled } from "./conversation-identity-DXAm0_Mk.js";
+import { i as resolveDiscordGroupToolPolicy, n as collectDiscordStatusIssues, r as resolveDiscordGroupRequireMention, t as discordPlugin } from "./channel-U_aeoFwW.js";
+import { t as normalizeExplicitDiscordSessionKey } from "./session-key-normalization-CP8dPUid.js";
+import { t as discordSetupPlugin } from "./channel.setup-BUSC0apv.js";
+import { n as handleDiscordSubagentEnded, r as handleDiscordSubagentSpawning, t as handleDiscordSubagentDeliveryTarget } from "./subagent-hooks-8bK-mgiU.js";
+import { t as tryHandleDiscordMessageActionGuildAdmin } from "./handle-action.guild-admin-B5BArS2n.js";
+import { n as listDiscordDirectoryGroupsFromConfig, r as listDiscordDirectoryPeersFromConfig } from "./directory-config-CYbuMmPS.js";
+import { t as fetchPluralKitMessageInfo } from "./pluralkit-D1Q2x0w5.js";
+import { a as resolveDiscordPrivilegedIntentsFromFlags, i as probeDiscord, n as fetchDiscordApplicationSummary, r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-D--Ca4JF.js";
+import { t as collectDiscordSecurityAuditFindings } from "./security-audit-CnyIQKz6.js";
+import { a as mergeAbortSignals, i as DISCORD_DEFAULT_LISTENER_TIMEOUT_MS, n as DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, r as DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS, t as DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS } from "./timeouts-CEwuGaWT.js";
+import { resolveOpenProviderRuntimeGroupPolicy as resolveDiscordRuntimeGroupPolicy } from "klaw/plugin-sdk/runtime-group-policy";
+//#region extensions/discord/api.ts
+const handleDiscordMessageAction = async (...args) => (await import("./channel-actions.runtime-CPtpH-yl.js")).handleDiscordMessageAction(...args);
+//#endregion
+export { DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS, DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, DISCORD_COMPONENT_ATTACHMENT_PREFIX, DISCORD_COMPONENT_CUSTOM_ID_KEY, DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS, DISCORD_DEFAULT_LISTENER_TIMEOUT_MS, DISCORD_MODAL_CUSTOM_ID_KEY, DiscordApiError, DiscordFormModal, buildDiscordComponentCustomId, buildDiscordComponentMessage, buildDiscordComponentMessageFlags, buildDiscordInteractiveComponents, buildDiscordModalCustomId, collectDiscordSecurityAuditFindings, collectDiscordStatusIssues, createDiscordActionGate, createDiscordFormModal, discordPlugin, discordSetupPlugin, fetchDiscord, fetchDiscordApplicationId, fetchDiscordApplicationSummary, fetchPluralKitMessageInfo, formatDiscordComponentEventText, getDiscordExecApprovalApprovers, handleDiscordMessageAction, handleDiscordSubagentDeliveryTarget, handleDiscordSubagentEnded, handleDiscordSubagentSpawning, inspectDiscordAccount, isDiscordExecApprovalApprover, isDiscordExecApprovalClientEnabled, listDiscordAccountIds, listDiscordDirectoryGroupsFromConfig, listDiscordDirectoryPeersFromConfig, listEnabledDiscordAccounts, looksLikeDiscordTargetId, mergeAbortSignals, mergeDiscordAccountConfig, normalizeDiscordMessagingTarget, normalizeDiscordOutboundTarget, normalizeExplicitDiscordSessionKey, parseApplicationIdFromToken, parseDiscordComponentCustomId, parseDiscordComponentCustomIdForInteraction as parseDiscordComponentCustomIdForCarbon, parseDiscordComponentCustomIdForInteraction, parseDiscordModalCustomId, parseDiscordModalCustomIdForInteraction as parseDiscordModalCustomIdForCarbon, parseDiscordModalCustomIdForInteraction, parseDiscordSendTarget, parseDiscordTarget, probeDiscord, readDiscordComponentSpec, requestDiscord, resolveDefaultDiscordAccountId, resolveDiscordAccount, resolveDiscordAccountConfig, resolveDiscordChannelId, resolveDiscordComponentAttachmentName, resolveDiscordGroupRequireMention, resolveDiscordGroupToolPolicy, resolveDiscordMaxLinesPerMessage, resolveDiscordPrivilegedIntentsFromFlags, resolveDiscordRuntimeGroupPolicy, resolveDiscordTarget, shouldSuppressLocalDiscordExecApprovalPrompt, tryHandleDiscordMessageActionGuildAdmin };