@openclaw/discord 2026.8.1-beta.2 → 2026.8.1

package/dist/outbound-session-route-Bn4uXaoE.js

@@ -0,0 +1,665 @@
+import { _ as parseDiscordTarget, h as normalizeDiscordMessagingTarget } from "./retry-DqHCW6PV.js";
+import { h as readDiscordComponentSpec, m as coerceDiscordComponentParam } from "./components-Dk35LTf_.js";
+import { c as resolveDiscordAccount, r as listDiscordAccountIds, t as createDiscordActionGate } from "./accounts-CfQ-vSyf.js";
+import { t as inspectDiscordAccount } from "./account-inspect-BDfKyuvL.js";
+import { ChannelType } from "discord-api-types/v10";
+import { Type } from "typebox";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { buildOutboundBaseSessionKey, deriveLastRoutePolicy, isAcpSessionKey, isSubagentSessionKey, parseAgentSessionKey, resolveAgentIdFromSessionKey, resolveAgentRoute } from "openclaw/plugin-sdk/routing";
+import { asOptionalRecord, isRecord, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { createUnionActionGate } from "openclaw/plugin-sdk/channel-actions";
+import { buildThreadAwareOutboundSessionRoute } from "openclaw/plugin-sdk/channel-core";
+import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver } from "openclaw/plugin-sdk/approval-native-runtime";
+import { getExecApprovalReplyMetadata, isChannelExecApprovalClientEnabledFromConfig, matchesApprovalRequestFilters } from "openclaw/plugin-sdk/approval-client-runtime";
+import { resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { createApproverRestrictedNativeApprovalCapability } from "openclaw/plugin-sdk/approval-delivery-runtime";
+import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
+import { createInboundEventDeliveryCorrelation } from "openclaw/plugin-sdk/inbound-event-delivery";
+//#region extensions/discord/src/exec-approvals.ts
+function normalizeDiscordApproverId(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return;
+	if (/^\d+$/.test(trimmed)) return trimmed;
+	try {
+		const target = parseDiscordTarget(trimmed);
+		return target?.kind === "user" ? target.id : void 0;
+	} catch {
+		return;
+	}
+}
+function resolveDiscordOwnerApprovers(cfg) {
+	const ownerAllowFrom = cfg.commands?.ownerAllowFrom;
+	if (!Array.isArray(ownerAllowFrom) || ownerAllowFrom.length === 0) return [];
+	return resolveApprovalApprovers({
+		explicit: ownerAllowFrom,
+		normalizeApprover: (value) => normalizeDiscordApproverId(String(value))
+	});
+}
+function getDiscordExecApprovalApprovers(params) {
+	return resolveApprovalApprovers({
+		explicit: params.configOverride?.approvers ?? resolveDiscordAccount(params).config.execApprovals?.approvers ?? resolveDiscordOwnerApprovers(params.cfg),
+		normalizeApprover: (value) => normalizeDiscordApproverId(String(value))
+	});
+}
+function isDiscordExecApprovalClientEnabled(params) {
+	return isChannelExecApprovalClientEnabledFromConfig({
+		enabled: (params.configOverride ?? resolveDiscordAccount(params).config.execApprovals)?.enabled,
+		approverCount: getDiscordExecApprovalApprovers({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			configOverride: params.configOverride
+		}).length
+	});
+}
+function isDiscordExecApprovalApprover(params) {
+	const senderId = params.senderId?.trim();
+	if (!senderId) return false;
+	return getDiscordExecApprovalApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		configOverride: params.configOverride
+	}).includes(senderId);
+}
+function shouldSuppressLocalDiscordExecApprovalPrompt(params) {
+	const metadata = getExecApprovalReplyMetadata(params.payload);
+	const config = resolveDiscordAccount(params).config.execApprovals;
+	return params.hint?.kind === "approval-pending" && params.hint.nativeRouteActive === true && isDiscordExecApprovalClientEnabled(params) && metadata !== null && matchesApprovalRequestFilters({
+		request: {
+			agentId: metadata.agentId,
+			sessionKey: metadata.sessionKey
+		},
+		agentFilter: config?.agentFilter,
+		sessionFilter: config?.sessionFilter
+	});
+}
+//#endregion
+//#region extensions/discord/src/audit-core.ts
+const REQUIRED_TEXT_CHANNEL_PERMISSIONS = ["ViewChannel", "SendMessages"];
+const REQUIRED_VOICE_CHANNEL_PERMISSIONS = [
+	"ViewChannel",
+	"Connect",
+	"Speak",
+	"SendMessages",
+	"ReadMessageHistory"
+];
+function resolveRequiredDiscordChannelPermissions(channelType) {
+	if (channelType === ChannelType.GuildVoice || channelType === ChannelType.GuildStageVoice) return [...REQUIRED_VOICE_CHANNEL_PERMISSIONS];
+	return [...REQUIRED_TEXT_CHANNEL_PERMISSIONS];
+}
+function shouldAuditChannelConfig(config) {
+	if (!config) return true;
+	if (config.enabled === false) return false;
+	return true;
+}
+function listConfiguredGuildChannelKeys(guilds) {
+	if (!guilds) return [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const entry of Object.values(guilds)) {
+		if (!entry || typeof entry !== "object") continue;
+		const channelsRaw = entry.channels;
+		if (!isRecord(channelsRaw)) continue;
+		for (const [key, value] of Object.entries(channelsRaw)) {
+			const channelId = normalizeOptionalString(key) ?? "";
+			if (!channelId) continue;
+			if (channelId === "*") continue;
+			if (!shouldAuditChannelConfig(value)) continue;
+			ids.add(channelId);
+		}
+	}
+	return [...ids].toSorted((a, b) => a.localeCompare(b));
+}
+function collectDiscordAuditChannelIdsForGuilds(guilds) {
+	const keys = listConfiguredGuildChannelKeys(guilds);
+	const channelIds = keys.filter((key) => /^\d+$/.test(key));
+	return {
+		channelIds,
+		unresolvedChannels: keys.length - channelIds.length
+	};
+}
+function collectDiscordAuditChannelIdsForAccount(config) {
+	const collected = collectDiscordAuditChannelIdsForGuilds(config.guilds);
+	const channelIds = new Set(collected.channelIds);
+	let unresolvedVoiceChannels = 0;
+	for (const entry of config.voice?.autoJoin ?? []) {
+		const channelId = normalizeOptionalString(entry?.channelId) ?? "";
+		if (/^\d+$/.test(channelId)) channelIds.add(channelId);
+		else if (channelId) unresolvedVoiceChannels++;
+	}
+	return {
+		channelIds: [...channelIds].toSorted((a, b) => a.localeCompare(b)),
+		unresolvedChannels: collected.unresolvedChannels + unresolvedVoiceChannels
+	};
+}
+async function auditDiscordChannelPermissionsWithFetcher(params) {
+	const started = Date.now();
+	const token = normalizeOptionalString(params.token) ?? "";
+	if (!token || params.channelIds.length === 0) return {
+		ok: true,
+		checkedChannels: 0,
+		unresolvedChannels: 0,
+		channels: [],
+		elapsedMs: Date.now() - started
+	};
+	const channels = [];
+	for (const channelId of params.channelIds) try {
+		const perms = await params.fetchChannelPermissions(channelId, {
+			cfg: params.cfg,
+			token,
+			accountId: params.accountId ?? void 0
+		});
+		const missing = resolveRequiredDiscordChannelPermissions(perms.channelType).filter((p) => !perms.permissions.includes(p));
+		channels.push({
+			channelId,
+			ok: missing.length === 0,
+			missing: missing.length ? missing : void 0,
+			error: null,
+			matchKey: channelId,
+			matchSource: "id"
+		});
+	} catch (err) {
+		channels.push({
+			channelId,
+			ok: false,
+			error: formatErrorMessage(err),
+			matchKey: channelId,
+			matchSource: "id"
+		});
+	}
+	return {
+		ok: channels.every((c) => c.ok),
+		checkedChannels: channels.length,
+		unresolvedChannels: 0,
+		channels,
+		elapsedMs: Date.now() - started
+	};
+}
+//#endregion
+//#region extensions/discord/src/inbound-event-delivery.ts
+const DISCORD_INBOUND_EVENT_DELIVERY_KEY = "__openclawInboundEventDelivery";
+function normalizeDiscordDeliveryTarget(value) {
+	return value.trim().replace(/^discord:/iu, "").replace(/^channel:/iu, "").toLowerCase();
+}
+const discordInboundEventDelivery = createInboundEventDeliveryCorrelation({ targetsMatch: (expected, actual) => normalizeDiscordDeliveryTarget(expected) === normalizeDiscordDeliveryTarget(actual) });
+function withDiscordInboundEventDeliveryMetadata(payload, params) {
+	const sessionKey = params.sessionKey?.trim();
+	if (!sessionKey || params.inboundEventKind !== "room_event") return payload;
+	const channelData = asOptionalRecord(payload.channelData) ?? {};
+	const discordData = asOptionalRecord(channelData.discord) ?? {};
+	return {
+		...payload,
+		channelData: {
+			...channelData,
+			discord: {
+				...discordData,
+				[DISCORD_INBOUND_EVENT_DELIVERY_KEY]: {
+					sessionKey,
+					inboundEventKind: params.inboundEventKind
+				}
+			}
+		}
+	};
+}
+function notifyDiscordInboundEventOutboundPayloadSuccess(params) {
+	const metadata = asOptionalRecord(asOptionalRecord(asOptionalRecord(params.payload.channelData)?.discord)?.[DISCORD_INBOUND_EVENT_DELIVERY_KEY]);
+	if (!metadata) return;
+	discordInboundEventDelivery.notify({
+		sessionKey: normalizeOptionalString(metadata.sessionKey),
+		inboundEventKind: normalizeOptionalString(metadata.inboundEventKind),
+		to: params.to,
+		accountId: params.accountId
+	});
+}
+//#endregion
+//#region extensions/discord/src/trusted-requester-actions.ts
+const trustedRequesterGuildAdminActions = /* @__PURE__ */ new Set([
+	"emoji-upload",
+	"sticker-upload",
+	"role-add",
+	"role-remove",
+	"channel-create",
+	"channel-edit",
+	"channel-delete",
+	"channel-move",
+	"category-create",
+	"category-edit",
+	"category-delete",
+	"event-create",
+	"timeout",
+	"kick",
+	"ban"
+]);
+function isTrustedRequesterGuildAdminAction(action) {
+	return trustedRequesterGuildAdminActions.has(action);
+}
+//#endregion
+//#region extensions/discord/src/channel-actions.ts
+const localExecutionActions = /* @__PURE__ */ new Set([
+	"send",
+	"poll",
+	"upload-file",
+	"thread-reply",
+	"sticker",
+	"emoji-upload",
+	"sticker-upload",
+	"event-create"
+]);
+function resolveDiscordActionExecutionMode({ action }) {
+	return localExecutionActions.has(action) ? "local" : "gateway";
+}
+function resolveDiscordThreadReplyDeliveryAlias(args) {
+	if (normalizeOptionalString(args.target) || normalizeOptionalString(args.to) || normalizeOptionalString(args.channelId)) return;
+	const threadId = normalizeOptionalString(args.threadId);
+	return threadId ? normalizeDiscordMessagingTarget(`channel:${threadId}`) : void 0;
+}
+function resolveDiscordThreadReplyTarget(args) {
+	const threadId = normalizeOptionalString(args.threadId);
+	const target = threadId !== void 0 ? `channel:${threadId}` : normalizeOptionalString(args.channelId) ?? normalizeOptionalString(args.to) ?? normalizeOptionalString(args.target);
+	return target ? normalizeDiscordMessagingTarget(target) : void 0;
+}
+function matchesCurrentDiscordThread(params) {
+	const requestedTarget = resolveDiscordThreadReplyTarget(params.args);
+	if (!requestedTarget) return false;
+	return [params.toolContext.currentChannelId, params.toolContext.currentMessagingTarget].some((currentTarget) => currentTarget !== void 0 && normalizeDiscordMessagingTarget(currentTarget) === requestedTarget);
+}
+const loadDiscordChannelActionsRuntime = createLazyRuntimeModule(() => import("./channel-actions.runtime-UMGGIfSy.js"));
+function listDiscoverableDiscordAccounts(cfg) {
+	return listDiscordAccountIds(cfg).map((accountId) => inspectDiscordAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled && account.configured);
+}
+function resolveDiscordActionDiscovery(cfg) {
+	const accounts = listDiscoverableDiscordAccounts(cfg);
+	if (accounts.length === 0) return null;
+	const unionGate = createUnionActionGate(accounts, (account) => createDiscordActionGate({
+		cfg,
+		accountId: account.accountId
+	}));
+	return { isEnabled: (key, defaultValue = true) => unionGate(key, defaultValue) };
+}
+function resolveScopedDiscordActionDiscovery(params) {
+	if (!params.accountId) return resolveDiscordActionDiscovery(params.cfg);
+	const account = inspectDiscordAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (!account.enabled || !account.configured) return null;
+	const gate = createDiscordActionGate({
+		cfg: params.cfg,
+		accountId: account.accountId
+	});
+	return { isEnabled: (key, defaultValue = true) => gate(key, defaultValue) };
+}
+function describeDiscordMessageTool({ cfg, accountId }) {
+	const discovery = resolveScopedDiscordActionDiscovery({
+		cfg,
+		accountId
+	});
+	if (!discovery) return {
+		actions: [],
+		capabilities: [],
+		schema: null
+	};
+	const actions = /* @__PURE__ */ new Set(["send"]);
+	if (discovery.isEnabled("polls")) actions.add("poll");
+	if (discovery.isEnabled("reactions")) {
+		actions.add("react");
+		actions.add("reactions");
+		actions.add("emoji-list");
+	}
+	if (discovery.isEnabled("messages")) {
+		actions.add("upload-file");
+		actions.add("read");
+		actions.add("edit");
+		actions.add("delete");
+	}
+	if (discovery.isEnabled("pins")) {
+		actions.add("pin");
+		actions.add("unpin");
+		actions.add("list-pins");
+	}
+	if (discovery.isEnabled("permissions")) actions.add("permissions");
+	if (discovery.isEnabled("threads")) {
+		actions.add("thread-create");
+		actions.add("thread-list");
+		actions.add("thread-reply");
+	}
+	if (discovery.isEnabled("search")) actions.add("search");
+	if (discovery.isEnabled("stickers")) actions.add("sticker");
+	if (discovery.isEnabled("memberInfo")) actions.add("member-info");
+	if (discovery.isEnabled("roleInfo")) actions.add("role-info");
+	if (discovery.isEnabled("emojiUploads")) actions.add("emoji-upload");
+	if (discovery.isEnabled("stickerUploads")) actions.add("sticker-upload");
+	if (discovery.isEnabled("roles", false)) {
+		actions.add("role-add");
+		actions.add("role-remove");
+	}
+	if (discovery.isEnabled("channelInfo")) {
+		actions.add("channel-info");
+		actions.add("channel-list");
+	}
+	if (discovery.isEnabled("channels")) {
+		actions.add("channel-create");
+		actions.add("channel-edit");
+		actions.add("channel-delete");
+		actions.add("channel-move");
+		actions.add("category-create");
+		actions.add("category-edit");
+		actions.add("category-delete");
+	}
+	if (discovery.isEnabled("voiceStatus")) actions.add("voice-status");
+	if (discovery.isEnabled("events")) {
+		actions.add("event-list");
+		actions.add("event-create");
+	}
+	if (discovery.isEnabled("moderation", false)) {
+		actions.add("timeout");
+		actions.add("kick");
+		actions.add("ban");
+	}
+	if (discovery.isEnabled("presence", false)) actions.add("set-presence");
+	const schema = [];
+	if (actions.has("react")) schema.push({
+		actions: ["react", "reactions"],
+		properties: { emoji: Type.Optional(Type.String({ description: `Unicode emoji or custom name:id (also <:name:id> / <a:name:id>).${actions.has("emoji-list") ? " Use action:\"emoji-list\" for server emojis." : ""}` })) }
+	});
+	if (actions.has("send")) schema.push({
+		actions: ["send"],
+		visibility: "all-configured",
+		properties: { components: Type.Optional(Type.Object({
+			blocks: Type.Optional(Type.Array(Type.Unknown(), { description: "Discord Components V2 blocks such as text, buttons, selects, media, containers, and separators." })),
+			modal: Type.Optional(Type.Object({}, {
+				additionalProperties: true,
+				description: "Optional Discord modal triggered by generated components."
+			}))
+		}, {
+			additionalProperties: true,
+			description: "Discord Components V2 payload for send actions. Accepts the same object consumed by the Discord components adapter."
+		})) }
+	});
+	return {
+		actions: Array.from(actions),
+		capabilities: ["presentation"],
+		schema
+	};
+}
+const discordMessageActions = {
+	providerOwnedReadGates: true,
+	resolveExecutionMode: resolveDiscordActionExecutionMode,
+	describeMessageTool: describeDiscordMessageTool,
+	supportsAction: ({ action }) => action !== "poll",
+	messageActionTargetAliases: { "thread-reply": {
+		aliases: ["threadId"],
+		deliveryTargetAliases: ["threadId"],
+		resolveDeliveryTarget: ({ args }) => resolveDiscordThreadReplyDeliveryAlias(args),
+		matchesCurrentConversation: ({ args, toolContext }) => matchesCurrentDiscordThread({
+			args,
+			toolContext
+		})
+	} },
+	requiresTrustedRequesterSender: ({ action, toolContext }) => Boolean(toolContext) && isTrustedRequesterGuildAdminAction(action),
+	extractToolSend: ({ args }) => {
+		const action = normalizeOptionalString(args.action) ?? "";
+		if (action === "sendMessage") return extractToolSend(args, "sendMessage");
+		if (action === "threadReply") {
+			const channelId = normalizeOptionalString(args.channelId) ?? "";
+			return channelId ? { to: `channel:${channelId}` } : null;
+		}
+		return null;
+	},
+	prepareSendPayload: ({ ctx, payload }) => {
+		if (ctx.action !== "send") return null;
+		const payloadWithDeliveryMetadata = withDiscordInboundEventDeliveryMetadata(payload, {
+			sessionKey: ctx.sessionKey,
+			inboundEventKind: ctx.inboundEventKind
+		});
+		const rawComponents = coerceDiscordComponentParam(ctx.params.components);
+		if (typeof rawComponents === "function") return null;
+		const componentSpec = rawComponents && typeof rawComponents === "object" && !Array.isArray(rawComponents) ? readDiscordComponentSpec(rawComponents) : void 0;
+		const nativeComponents = Array.isArray(rawComponents) ? rawComponents : void 0;
+		const embeds = Array.isArray(ctx.params.embeds) ? ctx.params.embeds : void 0;
+		if ((componentSpec || nativeComponents) && embeds?.length) return null;
+		const filename = normalizeOptionalString(ctx.params.filename);
+		if (!componentSpec && !nativeComponents && !embeds?.length && !filename) return payloadWithDeliveryMetadata;
+		const discordData = payloadWithDeliveryMetadata.channelData?.discord && typeof payloadWithDeliveryMetadata.channelData.discord === "object" && !Array.isArray(payloadWithDeliveryMetadata.channelData.discord) ? payloadWithDeliveryMetadata.channelData.discord : {};
+		return {
+			...payloadWithDeliveryMetadata,
+			channelData: {
+				...payloadWithDeliveryMetadata.channelData,
+				discord: {
+					...discordData,
+					...componentSpec ? { components: componentSpec } : {},
+					...nativeComponents ? { components: nativeComponents } : {},
+					...embeds?.length ? { embeds } : {},
+					...filename ? { filename } : {}
+				}
+			}
+		};
+	},
+	handleAction: async ({ action, params, cfg, accountId, requesterAccountId, requesterSenderId, senderIsOwner, toolContext, mediaAccess, mediaLocalRoots, mediaReadFile, sessionKey, inboundEventKind, conversationReadOrigin, reply }) => {
+		return await (await loadDiscordChannelActionsRuntime()).handleDiscordMessageAction({
+			action,
+			params,
+			cfg,
+			accountId,
+			requesterSenderId,
+			senderIsOwner,
+			toolContext,
+			mediaAccess,
+			mediaLocalRoots,
+			mediaReadFile,
+			...sessionKey ? { sessionKey } : {},
+			...inboundEventKind ? { inboundEventKind } : {},
+			...requesterAccountId ? { requesterAccountId } : {},
+			...conversationReadOrigin ? { conversationReadOrigin } : {},
+			...reply ? { reply } : {}
+		});
+	}
+};
+//#endregion
+//#region extensions/discord/src/conversation-identity.ts
+function normalizeDiscordTarget(raw, defaultKind) {
+	const trimmed = normalizeOptionalString(raw);
+	if (!trimmed) return;
+	return parseDiscordTarget(trimmed, { defaultKind })?.normalized;
+}
+function buildDiscordConversationIdentity(kind, rawId) {
+	const trimmed = normalizeOptionalString(rawId);
+	return trimmed ? `${kind}:${trimmed}` : void 0;
+}
+function resolveDiscordConversationIdentity(params) {
+	return params.isDirectMessage ? buildDiscordConversationIdentity("user", params.userId) : buildDiscordConversationIdentity("channel", params.channelId);
+}
+function resolveDiscordRuntimeBindingConversationId(params) {
+	if (params.isDirectMessage && !params.isGroupDm) return buildDiscordConversationIdentity("user", params.userId) ?? params.channelId;
+	return params.channelId;
+}
+function resolveDiscordCurrentConversationIdentity(params) {
+	if (normalizeOptionalLowercaseString(params.chatType) === "direct") {
+		const senderTarget = normalizeDiscordTarget(params.from, "user");
+		if (senderTarget?.startsWith("user:")) return senderTarget;
+	}
+	for (const candidate of [
+		params.originatingTo,
+		params.commandTo,
+		params.fallbackTo
+	]) {
+		const target = normalizeDiscordTarget(candidate, "channel");
+		if (target) return target;
+	}
+}
+//#endregion
+//#region extensions/discord/src/monitor/route-resolution.ts
+function buildDiscordRoutePeer(params) {
+	return {
+		kind: params.isGroupDm ? "group" : params.isDirectMessage ? "direct" : "channel",
+		id: params.isDirectMessage && !params.isGroupDm ? params.directUserId?.trim() || params.conversationId : params.conversationId
+	};
+}
+function buildDiscordConversationRouteContext(params) {
+	return {
+		ConversationRouteContextObserved: true,
+		ConversationRoutePeerId: buildDiscordRoutePeer(params).id,
+		NativeChannelId: params.conversationId,
+		InboundAccessAuthorized: true,
+		MessageThreadId: params.isThread ? params.conversationId : void 0,
+		ThreadParentId: params.isThread ? params.parentConversationId : void 0
+	};
+}
+function resolveDiscordConversationRoute(params) {
+	return resolveAgentRoute({
+		cfg: params.cfg,
+		channel: "discord",
+		accountId: params.accountId,
+		guildId: params.guildId ?? void 0,
+		memberRoleIds: params.memberRoleIds,
+		peer: params.peer,
+		parentPeer: params.parentConversationId ? {
+			kind: "channel",
+			id: params.parentConversationId
+		} : void 0
+	});
+}
+function resolveDiscordBoundConversationRoute(params) {
+	return resolveDiscordEffectiveRoute({
+		route: resolveDiscordConversationRoute({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			guildId: params.guildId,
+			memberRoleIds: params.memberRoleIds,
+			peer: buildDiscordRoutePeer({
+				isDirectMessage: params.isDirectMessage,
+				isGroupDm: params.isGroupDm,
+				directUserId: params.directUserId,
+				conversationId: params.conversationId
+			}),
+			parentConversationId: params.parentConversationId
+		}),
+		boundSessionKey: params.boundSessionKey,
+		configuredRoute: params.configuredRoute,
+		matchedBy: params.matchedBy
+	});
+}
+function resolveDiscordEffectiveRoute(params) {
+	const boundSessionKey = params.boundSessionKey?.trim();
+	if (!boundSessionKey) return params.configuredRoute?.route ?? params.route;
+	return {
+		...params.route,
+		sessionKey: boundSessionKey,
+		agentId: resolveAgentIdFromSessionKey(boundSessionKey),
+		lastRoutePolicy: deriveLastRoutePolicy({
+			sessionKey: boundSessionKey,
+			mainSessionKey: params.route.mainSessionKey
+		}),
+		...params.matchedBy ? { matchedBy: params.matchedBy } : {}
+	};
+}
+function hasExplicitRuntimeBindingIntent(record) {
+	if (record.targetKind === "subagent") return true;
+	if (isAcpSessionKey(record.targetSessionKey) || isSubagentSessionKey(record.targetSessionKey)) return true;
+	const metadata = record.metadata;
+	if (!metadata || typeof metadata !== "object") return false;
+	return typeof metadata.boundBy === "string" || typeof metadata.label === "string" || typeof metadata.threadName === "string" || metadata.pluginBindingOwner === "plugin";
+}
+function shouldIgnoreStaleDiscordRouteBinding(params) {
+	const bindingRecord = params.bindingRecord;
+	const boundSessionKey = bindingRecord?.targetSessionKey?.trim();
+	if (!bindingRecord || !boundSessionKey || hasExplicitRuntimeBindingIntent(bindingRecord)) return false;
+	const bound = parseAgentSessionKey(boundSessionKey);
+	const routed = parseAgentSessionKey(params.route.sessionKey);
+	if (!bound || !routed || bound.rest !== routed.rest) return false;
+	return bound.agentId !== params.route.agentId;
+}
+//#endregion
+//#region extensions/discord/src/approval-message-safety.ts
+const DISCORD_APPROVAL_ALLOWED_MENTIONS = { parse: [] };
+const DISCORD_MARKDOWN_META_CHARACTERS = /* @__PURE__ */ new Set([
+	"\\",
+	"`",
+	"*",
+	"_",
+	"{",
+	"}",
+	"[",
+	"]",
+	"(",
+	")",
+	"<",
+	">",
+	"#",
+	"+",
+	"-",
+	".",
+	"!",
+	"|",
+	"~"
+]);
+function escapeDiscordApprovalDisplayCharacter(character) {
+	if (character === "\n") return "\\n";
+	if (character === "\r") return "\\r";
+	if (character === "	") return "\\t";
+	const codePoint = character.codePointAt(0) ?? 0;
+	if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint === 8232 || codePoint === 8233) return `\\u{${codePoint.toString(16).padStart(4, "0")}}`;
+	return DISCORD_MARKDOWN_META_CHARACTERS.has(character) ? `\\${character}` : character;
+}
+/** Keep opaque approval metadata bounded, single-line, and inert in Discord Markdown. */
+function formatDiscordApprovalDisplayValue(value, maxChars = 200) {
+	const limit = Number.isFinite(maxChars) ? Math.max(0, Math.trunc(maxChars)) : 200;
+	const escapedParts = Array.from(value, escapeDiscordApprovalDisplayCharacter);
+	const escaped = escapedParts.join("");
+	if (escaped.length <= limit) return escaped;
+	if (limit <= 3) return ".".repeat(limit);
+	let bounded = "";
+	for (const part of escapedParts) {
+		if (bounded.length + part.length > limit - 3) break;
+		bounded += part;
+	}
+	return `${bounded}...`;
+}
+//#endregion
+//#region extensions/discord/src/outbound-session-route.ts
+function resolveDiscordOutboundSessionRoute(params) {
+	const parsed = parseDiscordTarget(params.target, { defaultKind: resolveDiscordOutboundTargetKindHint(params) });
+	if (!parsed) return null;
+	const explicitThreadId = params.threadId == null ? void 0 : String(params.threadId).trim();
+	const peerId = explicitThreadId || parsed.id;
+	const isDm = parsed.kind === "user" && !explicitThreadId;
+	const recipientSessionExact = /^\d+$/.test(peerId);
+	const peer = {
+		kind: isDm ? "direct" : "channel",
+		id: peerId
+	};
+	const baseSessionKey = buildOutboundBaseSessionKey({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "discord",
+		accountId: params.accountId,
+		peer
+	});
+	return buildThreadAwareOutboundSessionRoute({
+		route: {
+			sessionKey: baseSessionKey,
+			baseSessionKey,
+			recipientSessionExact,
+			peer,
+			chatType: isDm ? "direct" : "channel",
+			from: isDm ? `discord:${peerId}` : `discord:channel:${peerId}`,
+			to: isDm ? `user:${peerId}` : `channel:${peerId}`
+		},
+		threadId: params.threadId,
+		precedence: ["threadId"],
+		useSuffix: false
+	});
+}
+function resolveDiscordOutboundTargetKindHint(params) {
+	const resolvedKind = params.resolvedTarget?.kind;
+	if (resolvedKind === "user") return "user";
+	if (resolvedKind === "group" || resolvedKind === "channel") return "channel";
+	const target = params.target.trim();
+	if (/^channel:/i.test(target)) return "channel";
+	if (/^(user:|discord:|@|<@!?)/i.test(target)) return "user";
+	return "channel";
+}
+//#endregion
+export { shouldSuppressLocalDiscordExecApprovalPrompt as C, isChannelExecApprovalClientEnabledFromConfig as D, createChannelNativeOriginTargetResolver as E, matchesApprovalRequestFilters as O, isDiscordExecApprovalClientEnabled as S, createChannelApproverDmTargetResolver as T, auditDiscordChannelPermissionsWithFetcher as _, buildDiscordRoutePeer as a, getDiscordExecApprovalApprovers as b, resolveDiscordEffectiveRoute as c, resolveDiscordCurrentConversationIdentity as d, resolveDiscordRuntimeBindingConversationId as f, notifyDiscordInboundEventOutboundPayloadSuccess as g, discordInboundEventDelivery as h, buildDiscordConversationRouteContext as i, shouldIgnoreStaleDiscordRouteBinding as l, isTrustedRequesterGuildAdminAction as m, DISCORD_APPROVAL_ALLOWED_MENTIONS as n, resolveDiscordBoundConversationRoute as o, discordMessageActions as p, formatDiscordApprovalDisplayValue as r, resolveDiscordConversationRoute as s, resolveDiscordOutboundSessionRoute as t, resolveDiscordConversationIdentity as u, collectDiscordAuditChannelIdsForAccount as v, createApproverRestrictedNativeApprovalCapability as w, isDiscordExecApprovalApprover as x, resolveRequiredDiscordChannelPermissions as y };