@openclaw/discord 2026.10.1 → 2026.10.5-beta.1

package/dist/.setup/account-inspect-8cCu6uPG.mjs

@@ -0,0 +1,31 @@
+import { i as listDiscordAccountIds, n as inspectDiscordAccountConfig, v as resolveDiscordAccountAvailability } from "./accounts-ljrzXBJi.mjs";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
+//#region extensions/discord/src/account-inspect.ts
+function inspectDiscordAccountPrimary(params) {
+	return inspectDiscordAccountConfig(params, {
+		includeName: true,
+		resolveFallbackToken: (accountId) => {
+			const envToken = accountId === DEFAULT_ACCOUNT_ID ? normalizeSecretInputString(params.envToken ?? process.env.DISCORD_BOT_TOKEN) : void 0;
+			return {
+				token: envToken?.replace(/^Bot\s+/i, "") ?? "",
+				source: envToken ? "env" : "none"
+			};
+		}
+	});
+}
+function inspectDiscordAccount(params) {
+	const account = inspectDiscordAccountPrimary(params);
+	return {
+		...account,
+		...resolveDiscordAccountAvailability({
+			account,
+			resolveAccounts: () => listDiscordAccountIds(params.cfg).map((accountId) => inspectDiscordAccountPrimary({
+				...params,
+				accountId
+			}))
+		})
+	};
+}
+//#endregion
+export { inspectDiscordAccount as t };

package/dist/.setup/{accounts-HE9-mj1L.mjs → accounts-ljrzXBJi.mjs}

@@ -1,23 +1,18 @@
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { hasConfiguredSecretInput, normalizeResolvedSecretInputString, normalizeSecretInputString, resolveSecretInputString } from "openclaw/plugin-sdk/secret-input";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createAccountActionGate, createAccountListHelpers } from "openclaw/plugin-sdk/account-helpers";
 import { mapAllowFromEntries, normalizeChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-helpers";
 import { resolveConfiguredFromCredentialStatuses } from "openclaw/plugin-sdk/channel-status";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId as normalizeAccountId$1, resolveAccountEntry } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getRuntimeConfigSnapshot, getRuntimeConfigSourceSnapshot, selectApplicableRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
 //#region extensions/discord/src/account-token-inspect.ts
 function inspectDiscordConfiguredToken(value) {
 	const normalized = normalizeSecretInputString(value);
-	if (normalized) return {
-		token: normalized.replace(/^Bot\s+/i, ""),
+	if (normalized || hasConfiguredSecretInput(value)) return {
+		token: normalized ? normalized.replace(/^Bot\s+/i, "") : "",
 		tokenSource: "config",
-		tokenStatus: "available"
-	};
-	if (hasConfiguredSecretInput(value)) return {
-		token: "",
-		tokenSource: "config",
-		tokenStatus: "configured_unavailable"
+		tokenStatus: normalized ? "available" : "configured_unavailable"
 	};
 	return null;
 }
@@ -106,8 +101,7 @@ function normalizeDiscordToken(raw, path) {
 		value: raw,
 		path
 	});
-	if (!trimmed) return;
-	return stripDiscordBotPrefix(trimmed);
+	return trimmed ? stripDiscordBotPrefix(trimmed) : void 0;
 }
 function resolveDiscordTokenValue(params) {
 	const resolved = resolveSecretInputString({
@@ -116,12 +110,19 @@ function resolveDiscordTokenValue(params) {
 		defaults: params.cfg.secrets?.defaults,
 		mode: "inspect"
 	});
-	if (resolved.status === "available") return {
-		status: "available",
-		value: stripDiscordBotPrefix(resolved.value)
+	if (resolved.status === "available") {
+		const token = stripDiscordBotPrefix(resolved.value);
+		return token ? {
+			token,
+			source: "config",
+			tokenStatus: "available"
+		} : void 0;
+	}
+	if (resolved.status === "configured_unavailable") return {
+		token: "",
+		source: "config",
+		tokenStatus: "configured_unavailable"
 	};
-	if (resolved.status === "configured_unavailable") return { status: "configured_unavailable" };
-	return { status: "missing" };
 }
 function resolveDiscordToken(cfg, opts = {}) {
 	const selectedCfg = selectDiscordRuntimeConfig(cfg);
@@ -134,16 +135,7 @@ function resolveDiscordToken(cfg, opts = {}) {
 		value: accountCfg?.token,
 		path: `channels.discord.accounts.${accountId}.token`
 	});
-	if (accountToken.status === "available" && accountToken.value) return {
-		token: accountToken.value,
-		source: "config",
-		tokenStatus: "available"
-	};
-	if (accountToken.status === "configured_unavailable") return {
-		token: "",
-		source: "config",
-		tokenStatus: "configured_unavailable"
-	};
+	if (accountToken) return accountToken;
 	if (hasAccountToken) return {
 		token: "",
 		source: "none",
@@ -154,16 +146,7 @@ function resolveDiscordToken(cfg, opts = {}) {
 		value: discordCfg?.token,
 		path: "channels.discord.token"
 	});
-	if (configToken.status === "available" && configToken.value) return {
-		token: configToken.value,
-		source: "config",
-		tokenStatus: "available"
-	};
-	if (configToken.status === "configured_unavailable") return {
-		token: "",
-		source: "config",
-		tokenStatus: "configured_unavailable"
-	};
+	if (configToken) return configToken;
 	const envToken = accountId === DEFAULT_ACCOUNT_ID$1 ? normalizeDiscordToken(opts.envToken ?? process.env.DISCORD_BOT_TOKEN, "DISCORD_BOT_TOKEN") : void 0;
 	if (envToken) return {
 		token: envToken,
@@ -178,7 +161,7 @@ function resolveDiscordToken(cfg, opts = {}) {
 }
 //#endregion
 //#region extensions/discord/src/accounts.ts
-const { listAccountIds, resolveDefaultAccountId, resolveAccountConfig: mergeDiscordAccountConfig } = createAccountListHelpers("discord", {
+const { listAccountIds: listDiscordAccountIds, resolveDefaultAccountId: resolveDefaultDiscordAccountId, resolveAccountConfig: mergeDiscordAccountConfig } = createAccountListHelpers("discord", {
 	implicitDefaultAccount: {
 		channelKeys: ["token"],
 		envVars: ["DISCORD_BOT_TOKEN"]
@@ -189,29 +172,48 @@ const { listAccountIds, resolveDefaultAccountId, resolveAccountConfig: mergeDisc
 		"botLoopProtection"
 	]
 });
-const listDiscordAccountIds = listAccountIds;
-const resolveDefaultDiscordAccountId = resolveDefaultAccountId;
 function resolveDiscordAccountConfig(cfg, accountId) {
 	return resolveAccountEntry(cfg.channels?.discord?.accounts, accountId);
 }
-function resolveDiscordAccountAllowFrom(params) {
+function inspectDiscordAccountConfig(params, options) {
 	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const config = mergeDiscordAccountConfig(params.cfg, accountId);
+	const enabled = params.cfg.channels?.discord?.enabled !== false && config.enabled !== false;
 	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const hasAccountToken = Boolean(accountConfig && Object.hasOwn(accountConfig, "token"));
+	return inspectDiscordAccountTokenState({
+		base: {
+			accountId,
+			enabled,
+			...options.includeName ? { name: normalizeOptionalString(config.name) } : {}
+		},
+		config,
+		accountToken: accountConfig?.token,
+		hasAccountToken,
+		channelToken: params.cfg.channels?.discord?.token,
+		resolveFallbackToken: () => options.resolveFallbackToken(accountId)
+	});
+}
+function readConfiguredAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	return resolveDiscordAccountConfig(params.cfg, accountId);
+}
+function resolveDiscordAccountAllowFrom(params) {
+	const accountConfig = readConfiguredAccount(params);
 	const rootConfig = params.cfg.channels?.discord;
 	const allowFrom = accountConfig?.allowFrom ?? rootConfig?.allowFrom;
 	return allowFrom ? mapAllowFromEntries(allowFrom) : void 0;
 }
 function resolveDiscordAccountDmPolicy(params) {
-	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
-	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const accountConfig = readConfiguredAccount(params);
 	const rootConfig = params.cfg.channels?.discord;
 	return normalizeChannelDmPolicy(accountConfig?.dmPolicy ?? rootConfig?.dmPolicy ?? "pairing");
 }
 function createDiscordActionGate(params) {
-	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const accountConfig = readConfiguredAccount(params);
 	return createAccountActionGate({
 		baseActions: params.cfg.channels?.discord?.actions,
-		accountActions: resolveDiscordAccountConfig(params.cfg, accountId)?.actions
+		accountActions: accountConfig?.actions
 	});
 }
 function resolveDiscordAccount(params) {
@@ -267,4 +269,4 @@ function listDiscordStartupAccountIds(cfg) {
 	return [defaultAccountId, ...startupAccountIds.filter((candidateId) => candidateId !== defaultAccountId)];
 }
 //#endregion
-export { inspectDiscordAccountTokenState as _, listEnabledDiscordAccounts as a, resolveDiscordAccount as c, resolveDiscordAccountDisabledReason as d, resolveDiscordAccountDmPolicy as f, selectDiscordActivitiesRuntimeConfig as g, resolveDiscordToken as h, listDiscordStartupAccountIds as i, resolveDiscordAccountAllowFrom as l, normalizeDiscordToken as m, isDiscordAccountEnabledForRuntime as n, mergeDiscordAccountConfig as o, resolveDiscordMaxLinesPerMessage as p, listDiscordAccountIds as r, resolveDefaultDiscordAccountId as s, createDiscordActionGate as t, resolveDiscordAccountConfig as u, resolveDiscordAccountAvailability as v };
+export { selectDiscordActivitiesRuntimeConfig as _, listDiscordStartupAccountIds as a, resolveDefaultDiscordAccountId as c, resolveDiscordAccountConfig as d, resolveDiscordAccountDisabledReason as f, resolveDiscordToken as g, normalizeDiscordToken as h, listDiscordAccountIds as i, resolveDiscordAccount as l, resolveDiscordMaxLinesPerMessage as m, inspectDiscordAccountConfig as n, listEnabledDiscordAccounts as o, resolveDiscordAccountDmPolicy as p, isDiscordAccountEnabledForRuntime as r, mergeDiscordAccountConfig as s, createDiscordActionGate as t, resolveDiscordAccountAllowFrom as u, resolveDiscordAccountAvailability as v };

package/dist/.setup/{allow-list-vxkG9_JD.mjs → allow-list-B_ToXtew.mjs}

@@ -30,27 +30,16 @@ function normalizeRestApiBaseUrl(value) {
 	url.pathname = url.pathname.replace(/\/+$/u, "") || "/";
 	return url;
 }
-function normalizeGatewayOrigin(value) {
-	let url;
-	try {
-		url = new URL(value);
-	} catch {
-		throw new Error("Discord endpoint Gateway origin must be a valid URL");
-	}
-	if (url.protocol !== "wss:" && !(url.protocol === "ws:" && isLoopbackHost(url.hostname))) throw new Error("Discord endpoint Gateway origin must use WSS or loopback WS");
-	if (url.protocol === "wss:" && isBlockedHostnameOrIp(url.hostname)) throw new Error("Discord endpoint Gateway origin must not target a private/internal/special-use hostname or IP address");
-	if (url.username || url.password || url.hash || url.pathname !== "/" || url.search) throw new Error("Discord endpoint Gateway origin must be an origin without credentials, path, query, or fragment");
-	return url.origin;
-}
 function resolveDescriptor(apiUrl) {
 	const restApiBaseUrl = normalizeRestApiBaseUrl(apiUrl);
 	const gatewayBotUrl = new URL(`${restApiBaseUrl.pathname.replace(/\/+$/u, "")}/gateway/bot`, restApiBaseUrl.origin);
 	const gatewayOriginUrl = new URL(restApiBaseUrl.origin);
 	gatewayOriginUrl.protocol = gatewayOriginUrl.protocol === "https:" ? "wss:" : "ws:";
+	if (gatewayOriginUrl.protocol === "wss:" && isBlockedHostnameOrIp(gatewayOriginUrl.hostname)) throw new Error("Discord endpoint Gateway origin must not target a private/internal/special-use hostname or IP address");
 	return Object.freeze({
 		restApiBaseUrl: restApiBaseUrl.toString().replace(/\/$/u, ""),
 		gatewayBotUrl: gatewayBotUrl.toString(),
-		gatewayOrigin: normalizeGatewayOrigin(gatewayOriginUrl.origin)
+		gatewayOrigin: gatewayOriginUrl.origin
 	});
 }
 function isWithinRestApiBase(target, restApiBaseUrl) {
@@ -121,27 +110,22 @@ function getDiscordEndpointRuntime(env = process.env) {
 	});
 }
 function resolveDiscordEndpointMediaGuard(url, retainedRuntime) {
-	if (retainedRuntime === null) return;
-	const runtime = retainedRuntime ?? getDiscordEndpointRuntime();
-	if (!runtime) return;
-	const target = parseHttpAnchor(url, "Discord endpoint media URL");
-	const restOrigin = new URL(runtime.descriptor.restApiBaseUrl).origin;
-	if (target.origin !== restOrigin) throw new Error("Discord endpoint media URL is outside the configured REST origin");
-	return {
-		maxRedirects: 0,
-		ssrfPolicy: {
-			allowedOrigins: [restOrigin],
-			hostnameAllowlist: [target.hostname]
-		}
-	};
+	const guard = resolveEndpointResourceGuard(url, "media", retainedRuntime);
+	return guard ? {
+		maxRedirects: guard.maxRedirects,
+		ssrfPolicy: guard.policy
+	} : void 0;
 }
 function resolveDiscordEndpointAttachmentGuard(url, retainedRuntime) {
+	return resolveEndpointResourceGuard(url, "attachment upload", retainedRuntime);
+}
+function resolveEndpointResourceGuard(url, kind, retainedRuntime) {
 	if (retainedRuntime === null) return;
 	const runtime = retainedRuntime ?? getDiscordEndpointRuntime();
 	if (!runtime) return;
-	const target = parseHttpAnchor(url, "Discord endpoint attachment upload URL");
+	const target = parseHttpAnchor(url, `Discord endpoint ${kind} URL`);
 	const restOrigin = new URL(runtime.descriptor.restApiBaseUrl).origin;
-	if (target.origin !== restOrigin) throw new Error("Discord endpoint attachment upload URL is outside the configured REST origin");
+	if (target.origin !== restOrigin) throw new Error(`Discord endpoint ${kind} URL is outside the configured REST origin`);
 	return {
 		maxRedirects: 0,
 		policy: {
@@ -234,19 +218,6 @@ function normalizeDiscordSlug(value) {
 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) {
 	return resolveDiscordAllowListMatch({
 		allowList: list,
@@ -266,11 +237,13 @@ function resolveDiscordAllowListMatch(params) {
 		matchKey: candidate.id,
 		matchSource: "id"
 	};
-	if (params.allowNameMatching === true) {
-		const namedMatch = resolveDiscordAllowListNameMatch(allowList, candidate);
-		if (namedMatch) return {
+	if (params.allowNameMatching === true) for (const matchSource of ["name", "tag"]) {
+		const value = candidate[matchSource];
+		const matchKey = value ? normalizeDiscordSlug(value) : "";
+		if (matchKey && allowList.names.has(matchKey)) return {
 			allowed: true,
-			...namedMatch
+			matchKey,
+			matchSource
 		};
 	}
 	return { allowed: false };
@@ -288,27 +261,16 @@ function resolveDiscordUserAllowed(params) {
 		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
+		...params,
+		allowList: params.userAllowList
 	}) : false;
+	const roles = hasRoleRestriction ? normalizeDiscordAllowList(params.roleAllowList, ["role:"]) : null;
+	const roleOk = Boolean(roles && (roles.allowAll || params.memberRoleIds.some((roleId) => roles.ids.has(roleId))));
 	return userOk || roleOk;
 }
 function resolveDiscordMemberAccessState(params) {
@@ -340,11 +302,7 @@ function resolveDiscordOwnerAllowFrom(params) {
 	if (!allowList) return;
 	const match = resolveDiscordAllowListMatch({
 		allowList,
-		candidate: {
-			id: params.sender.id,
-			name: params.sender.name,
-			tag: params.sender.tag
-		},
+		candidate: params.sender,
 		allowNameMatching: params.allowNameMatching
 	});
 	if (!match.allowed || !match.matchKey || match.matchKey === "*") return;
@@ -379,33 +337,12 @@ function resolveDiscordGuildEntry(params) {
 	};
 	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,
+	const byName = entries[slug] || entries["*"];
+	return byName ? {
+		...byName,
 		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) {
-	const keys = buildDiscordChannelKeys(params);
-	const parentKeys = parentParams ? buildDiscordChannelKeys(parentParams) : void 0;
-	return resolveChannelEntryMatchWithFallback({
-		entries: channels,
-		keys,
-		parentKeys,
-		wildcardKey: "*"
-	});
+		slug: slug || byName.slug
+	} : null;
 }
 function hasConfiguredDiscordChannels(channels) {
 	return Boolean(channels && Object.keys(channels).length > 0);
@@ -440,16 +377,12 @@ function resolveDiscordChannelConfigWithFallback(params) {
 	const channels = guildInfo?.channels;
 	if (!hasConfiguredDiscordChannels(channels)) return null;
 	const resolvedParentSlug = parentSlug ?? (parentName ? normalizeDiscordSlug(parentName) : "");
-	const match = resolveDiscordChannelEntryMatch(channels, {
-		id: channelId,
-		name: channelName,
-		slug: channelSlug,
-		allowNameMatch: scope !== "thread"
-	}, parentId || parentName || parentSlug ? {
-		id: parentId ?? "",
-		name: parentName,
-		slug: resolvedParentSlug
-	} : void 0);
+	const match = resolveChannelEntryMatchWithFallback({
+		entries: channels,
+		keys: buildChannelKeyCandidates(channelId, scope === "thread" ? void 0 : channelSlug, scope === "thread" ? void 0 : channelName),
+		parentKeys: parentId || parentName || parentSlug ? buildChannelKeyCandidates(parentId ?? "", resolvedParentSlug, parentName) : void 0,
+		wildcardKey: "*"
+	});
 	return resolveChannelMatchConfig(match, resolveDiscordChannelConfigEntry) ?? { allowed: false };
 }
 /** Boolean runtime API retained for plugins built against OpenClaw 2026.9.6. */

package/dist/.setup/{api-DlNUkDqj.mjs → api-CtmE1OUN.mjs}

@@ -1,7 +1,7 @@
-import { D as getDiscordEndpointRuntime, T as parseDiscordRetryAfterBodySeconds } from "./allow-list-vxkG9_JD.mjs";
+import { D as getDiscordEndpointRuntime, T as parseDiscordRetryAfterBodySeconds } from "./allow-list-B_ToXtew.mjs";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { captureChannelReadAuthority, resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
+import { captureChannelReadAuthority, captureEffectAuthority, resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
 import { parseRetryAfterHeaderSeconds, resolveRetryConfig, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
@@ -23,11 +23,10 @@ function summarizeDiscordResponseBody(body, opts = {}) {
 	return truncateUtf16Safe(redactToolPayloadText(summary), 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);
+	return /\bhtml\b/i.test(contentType ?? "") || /^\s*(?:<!doctype\s+html\b|<html\b)/i.test(body);
 }
 function isDiscordRateLimitResponseBody(body) {
-	const normalized = body.toLowerCase();
-	return normalized.includes("error 1015") || normalized.includes("cloudflare") || normalized.includes("rate limit");
+	return /error 1015|cloudflare|rate limit/i.test(body);
 }
 //#endregion
 //#region extensions/discord/src/api.ts
@@ -46,23 +45,21 @@ 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;
+		return JSON.parse(trimmed);
 	} catch {
 		return null;
 	}
-	return null;
 }
 function parseRetryAfterSeconds(text, response) {
 	const payload = parseDiscordApiErrorPayload(text);
 	const retryAfter = parseDiscordRetryAfterBodySeconds(payload?.retry_after);
 	if (retryAfter !== void 0) return retryAfter;
 	const header = response.headers.get("Retry-After");
-	if (!header) return;
-	return parseRetryAfterHeaderSeconds(header);
+	return header ? parseRetryAfterHeaderSeconds(header) : void 0;
 }
-function formatRetryAfterSeconds(value) {
-	if (value === void 0 || !Number.isFinite(value) || value < 0) return;
+function formatRetryAfterSeconds(raw) {
+	const value = parseDiscordRetryAfterBodySeconds(raw);
+	if (value === void 0) return;
 	return `${value < 10 ? value.toFixed(1) : Math.round(value).toString()}s`;
 }
 function formatDiscordApiErrorTextUntrusted(text, response) {
@@ -79,13 +76,9 @@ function formatDiscordApiErrorTextUntrusted(text, response) {
 		return summary;
 	}
 	const message = typeof payload.message === "string" && payload.message.trim() ? payload.message.trim() : "unknown error";
-	const retryAfter = formatRetryAfterSeconds(parseDiscordRetryAfterBodySeconds(payload.retry_after));
+	const retryAfter = formatRetryAfterSeconds(payload.retry_after);
 	return retryAfter ? `${message} (retry after ${retryAfter})` : message;
 }
-function formatDiscordApiErrorText(text, response) {
-	const detail = formatDiscordApiErrorTextUntrusted(text, response);
-	return detail ? redactToolPayloadText(detail) : detail;
-}
 var DiscordApiError = class extends Error {
 	constructor(message, status, retryAfter) {
 		super(message);
@@ -93,13 +86,8 @@ var DiscordApiError = class extends Error {
 		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;
+	if (body === void 0 || 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);
 }
@@ -118,6 +106,7 @@ function createDiscordRequestSignal(options) {
 }
 async function requestDiscord(path, token, options) {
 	const assertReadAuthority = captureChannelReadAuthority();
+	const effect = captureEffectAuthority();
 	const endpoint = options?.endpointRuntime === void 0 ? getDiscordEndpointRuntime() : options.endpointRuntime;
 	const fetchImpl = resolveFetch(endpoint ? (input, init) => endpoint.fetch(input, init, assertReadAuthority) : options?.fetcher ?? fetch);
 	if (!fetchImpl) throw new Error("fetch is not available");
@@ -129,15 +118,20 @@ async function requestDiscord(path, token, options) {
 		const requestSignal = createDiscordRequestSignal(options ?? {});
 		try {
 			assertReadAuthority?.();
-			const res = await fetchImpl(`${endpoint?.descriptor.restApiBaseUrl ?? DISCORD_API_BASE}${path}`, {
-				method: options?.method ?? (body === void 0 ? "GET" : "POST"),
-				headers,
-				body,
-				signal: requestSignal.signal
-			});
+			const request = () => {
+				assertReadAuthority?.();
+				return fetchImpl(`${endpoint?.descriptor.restApiBaseUrl ?? DISCORD_API_BASE}${path}`, {
+					method: options?.method ?? (body === void 0 ? "GET" : "POST"),
+					headers,
+					body,
+					signal: requestSignal.signal
+				});
+			};
+			const res = endpoint ? await effect.run(request) : await effect.initiate(request);
 			if (!res.ok) {
 				const text = await readResponseTextLimited(res, DISCORD_API_ERROR_BODY_LIMIT_BYTES).catch(() => "");
-				const detail = formatDiscordApiErrorText(text, res);
+				const untrustedDetail = formatDiscordApiErrorTextUntrusted(text, res);
+				const detail = untrustedDetail ? redactToolPayloadText(untrustedDetail) : untrustedDetail;
 				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);
@@ -157,7 +151,7 @@ async function requestDiscord(path, token, options) {
 		...retryConfig,
 		label: options?.label ?? path,
 		shouldRetry: (err) => err instanceof DiscordApiError && err.status === 429,
-		retryAfterMs: (err) => getDiscordApiRetryAfterMs(err, retryConfig),
+		retryAfterMs: (err) => err instanceof DiscordApiError && typeof err.retryAfter === "number" ? Math.min(Math.max(0, err.retryAfter * 1e3), retryConfig.maxDelayMs) : void 0,
 		sleep: (ms) => sleepWithAbort(ms, options?.signal)
 	});
 }