@openclaw/slack 2026.9.6 → 2026.9.8

package/dist/.setup/{session-status-Cf7AvWOt.mjs → session-status-DscajIsd.mjs}

@@ -1,8 +1,8 @@
 import { n as isSlackPluginAccountConfigured } from "./account-configured-sUohAxZr.mjs";
-import { a as resolveDefaultSlackAccountId, i as mergeSlackAccountConfig, o as resolveSlackAccount, r as listSlackAccountIds, s as resolveSlackAccountAllowFrom } from "./accounts-BBHvg0pY.mjs";
-import { a as parseSlackTarget, n as formatSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-DEsPjngB.mjs";
-import { t as slackContextTargetsMatch } from "./targets-Cku2KCvg.mjs";
-import { O as resolveSlackAllowListMatch, T as normalizeAllowListLower, k as resolveSlackUserAllowListForTeam, o as formatSlackError } from "./probe-DiYIMPJo.mjs";
+import { a as mergeSlackAccountConfig, c as resolveSlackAccountAllowFrom, i as listSlackAccountIds, o as resolveDefaultSlackAccountId, s as resolveSlackAccount } from "./accounts-D_N9IqNA.mjs";
+import { a as parseSlackTarget, n as formatSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-FFE26kOV.mjs";
+import { t as slackContextTargetsMatch } from "./targets-C6LZQL1Q.mjs";
+import { A as resolveSlackUserAllowListForTeam, k as resolveSlackAllowListMatch, o as formatSlackError } from "./probe-B2Y9qc_z.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringifiedOptionalString, readNonBlankString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeMessageChannel } from "openclaw/plugin-sdk/routing";
@@ -13,29 +13,19 @@ import { isSingleUseReplyToMode } from "openclaw/plugin-sdk/reply-reference";
 import { buildChannelKeyCandidates } from "openclaw/plugin-sdk/channel-targets";
 import { createNativeApprovalChannelRouteGates, doesApprovalRequestSelectChannelAccount, resolveApprovalKind, resolveApprovalRequestSessionConversation } from "openclaw/plugin-sdk/approval-native-runtime";
 import { createChannelApprovalAuth, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { normalizeHyphenSlug, normalizeStringEntriesLower } from "openclaw/plugin-sdk/string-normalization-runtime";
 import { createChannelExecApprovalProfile, isChannelExecApprovalClientEnabledFromConfig, isChannelExecApprovalTargetRecipient, matchesApprovalRequestFilters } from "openclaw/plugin-sdk/approval-client-runtime";
-import { normalizeHyphenSlug } from "openclaw/plugin-sdk/string-normalization-runtime";
-import { channelRouteTargetsMatchExact, stringifyRouteThreadId } from "openclaw/plugin-sdk/channel-route";
 import { resolveGlobalMap } from "openclaw/plugin-sdk/global-singleton";
+import { channelRouteTargetsMatchExact, stringifyRouteThreadId } from "openclaw/plugin-sdk/channel-route";
 import { normalizeMessagePresentation, renderMessagePresentationChartFallbackText, renderMessagePresentationFallbackText, renderMessagePresentationTableFallbackText } from "openclaw/plugin-sdk/interactive-runtime";
+import { buildApprovalResolutionRef } from "openclaw/plugin-sdk/approval-reference-runtime";
 import { eastAsianWidthType } from "get-east-asian-width";
 import { resolveIntegerOption } from "openclaw/plugin-sdk/number-runtime";
+import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
+import { inspectRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-binding-runtime";
 import { resolveConfiguredBindingRoute, resolveRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-runtime";
 import { resolveScopeRequireMention, resolveScopeToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
-//#region extensions/slack/src/account-reply-mode.ts
-function normalizeSlackChatType(raw) {
-	const value = raw?.trim().toLowerCase();
-	if (!value) return;
-	if (value === "direct" || value === "dm") return "direct";
-	if (value === "group" || value === "channel") return value;
-}
-function resolveSlackReplyToMode(account, chatType) {
-	const normalized = normalizeSlackChatType(chatType ?? void 0);
-	if (normalized && account.replyToModeByChatType?.[normalized] !== void 0) return account.replyToModeByChatType[normalized] ?? "off";
-	return account.replyToMode ?? "off";
-}
-//#endregion
 //#region extensions/slack/src/action-threading.ts
 const SLACK_PRIVATE_ACTION_DELIVERY_RESULT = Symbol("slack.action.delivery-result");
 function resolveSlackAutoThreadId(params) {
@@ -51,6 +41,24 @@ function resolveSlackAutoThreadId(params) {
 	return context.currentThreadTs;
 }
 //#endregion
+//#region extensions/slack/src/approval-plugin-policy.ts
+/** Returns undefined only when Slack plugin approvals retain legacy account authorization. */
+function resolvePluginApprovalSlackApprovers(cfg, request) {
+	const policy = cfg.approvals?.plugin?.slack;
+	if (!policy) return;
+	const subject = request.request.policySubject;
+	const plugins = policy.plugins;
+	if (!subject && plugins && Object.keys(plugins).length > 0) return [];
+	const plugin = subject && plugins && Object.hasOwn(plugins, subject.pluginKey) ? plugins[subject.pluginKey] : void 0;
+	const tools = plugin?.tools;
+	if (tools && Object.keys(tools).length > 0) {
+		if (!subject?.tool) return [];
+		const toolKey = encodeURIComponent(subject.tool);
+		if (Object.hasOwn(tools, toolKey)) return tools[toolKey]?.approvers ?? [];
+	}
+	return plugin?.approvers ?? policy.approvers;
+}
+//#endregion
 //#region extensions/slack/src/exec-approvals.ts
 function normalizeSlackUserLikeId(value) {
 	const upper = value.toUpperCase();
@@ -109,6 +117,40 @@ const isSlackExecApprovalAuthorizedSender = slackExecApprovalProfile.isAuthorize
 const resolveSlackExecApprovalTarget = slackExecApprovalProfile.resolveTarget;
 const shouldSuppressLocalSlackExecApprovalPrompt = slackExecApprovalProfile.shouldSuppressLocalPrompt;
 //#endregion
+//#region extensions/slack/src/installation-identity-state.ts
+const slackInstallationStates = resolveGlobalMap(Symbol.for("openclaw.slack.installation-identities"), "close-and-restart");
+function registerSlackInstallationState(accountId, kind, teamId) {
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const owner = Symbol(`slack-installation:${normalizedAccountId}`);
+	slackInstallationStates.set(normalizedAccountId, {
+		kind,
+		teamId,
+		owner
+	});
+	return {
+		update: (nextKind, nextTeamId) => {
+			if (slackInstallationStates.get(normalizedAccountId)?.owner === owner) slackInstallationStates.set(normalizedAccountId, {
+				kind: nextKind,
+				teamId: nextTeamId,
+				owner
+			});
+		},
+		release: () => {
+			if (slackInstallationStates.get(normalizedAccountId)?.owner === owner) slackInstallationStates.delete(normalizedAccountId);
+		}
+	};
+}
+function getSlackInstallationKind(accountId) {
+	return slackInstallationStates.get(normalizeAccountId(accountId))?.kind;
+}
+function getSlackInstallationTeamId(accountId) {
+	const state = slackInstallationStates.get(normalizeAccountId(accountId));
+	return state?.kind === "workspace" ? state.teamId : void 0;
+}
+function isSlackWorkspaceInstallation(accountId) {
+	return getSlackInstallationKind(accountId) === "workspace";
+}
+//#endregion
 //#region extensions/slack/src/approval-auth.ts
 function resolveSlackApprovalInputs(params) {
 	const account = resolveSlackAccount(params).config;
@@ -117,14 +159,22 @@ function resolveSlackApprovalInputs(params) {
 		defaultTo: account.defaultTo
 	};
 }
-function slackApprovalTargetMatches(senderId, approvers) {
+function slackApprovalTargetMatches(senderId, approvers, accountTeamId) {
 	const sender = parseSlackTarget(senderId, { defaultKind: "user" });
-	return sender?.kind === "user" && resolveSlackAllowListMatch({
-		allowList: normalizeAllowListLower([...approvers]),
+	return sender?.kind === "user" && (!accountTeamId || sender.teamId?.toLowerCase() === accountTeamId.toLowerCase()) && resolveSlackAllowListMatch({
+		allowList: normalizeStringEntriesLower([...approvers]),
 		teamId: sender.teamId,
 		id: sender.id
 	}).allowed;
 }
+function resolveSlackApprovalOriginTeamId(request) {
+	if (normalizeLowercaseStringOrEmpty(request.request.turnSourceChannel) !== "slack") return;
+	try {
+		return parseSlackTarget(request.request.turnSourceTo ?? "")?.teamId;
+	} catch {
+		return;
+	}
+}
 const slackApproval = createChannelApprovalAuth({
 	channelLabel: "Slack",
 	resolveInputs: resolveSlackApprovalInputs,
@@ -135,64 +185,71 @@ const slackApproval = createChannelApprovalAuth({
 });
 const getSlackApprovalApprovers = slackApproval.resolveApprovers;
 const isSlackApprovalAuthorizedSender = slackApproval.isAuthorizedSender;
+function isSlackPluginApprovalAuthorizedSender(params) {
+	if (!params.request) return params.cfg.approvals?.plugin?.slack ? Boolean(params.senderId && normalizeSlackApproverTarget(params.senderId)) : isSlackApprovalAuthorizedSender(params);
+	if (resolvePluginApprovalSlackApprovers(params.cfg, params.request) === void 0) return isSlackApprovalAuthorizedSender(params);
+	const teamId = resolveSlackApprovalTeamId({
+		...params,
+		request: params.request
+	});
+	return Boolean(params.senderId && slackApprovalTargetMatches(params.senderId, getSlackApprovalApproversForTeam({
+		...params,
+		teamId
+	}), teamId));
+}
 function getSlackApprovalApproversForTeam(params) {
+	const configured = params.request ? resolvePluginApprovalSlackApprovers(params.cfg, params.request) : void 0;
+	if (params.request) {
+		const accountId = resolveSlackAccount(params).accountId;
+		const installedTeamId = getSlackInstallationTeamId(accountId);
+		const originTeamId = resolveSlackApprovalOriginTeamId(params.request);
+		const enterprise = getSlackInstallationKind(accountId) === "enterprise";
+		if (installedTeamId && originTeamId && installedTeamId.toLowerCase() !== originTeamId.toLowerCase() || enterprise && !originTeamId || configured !== void 0 && !installedTeamId && !enterprise) return [];
+	}
+	const approvers = configured ?? getSlackApprovalApprovers(params);
 	return resolveApprovalApprovers({
 		allowFrom: resolveSlackUserAllowListForTeam({
-			allowList: getSlackApprovalApprovers(params),
+			allowList: [...approvers],
 			teamId: params.teamId
 		}),
 		normalizeApprover: normalizeSlackApproverTarget
 	});
 }
-//#endregion
-//#region extensions/slack/src/installation-identity-state.ts
-const slackInstallationStates = resolveGlobalMap(Symbol.for("openclaw.slack.installation-identities"), "close-and-restart");
-function registerSlackInstallationState(accountId, kind) {
-	const normalizedAccountId = normalizeAccountId(accountId);
-	const owner = Symbol(`slack-installation:${normalizedAccountId}`);
-	slackInstallationStates.set(normalizedAccountId, {
-		kind,
-		owner
-	});
-	return {
-		update: (nextKind) => {
-			if (slackInstallationStates.get(normalizedAccountId)?.owner === owner) slackInstallationStates.set(normalizedAccountId, {
-				kind: nextKind,
-				owner
-			});
-		},
-		release: () => {
-			if (slackInstallationStates.get(normalizedAccountId)?.owner === owner) slackInstallationStates.delete(normalizedAccountId);
-		}
-	};
-}
-function getSlackInstallationKind(accountId) {
-	return slackInstallationStates.get(normalizeAccountId(accountId))?.kind;
-}
-function isSlackWorkspaceInstallation(accountId) {
-	return getSlackInstallationKind(accountId) === "workspace";
+function resolveSlackApprovalTeamId(params) {
+	return getSlackInstallationTeamId(resolveSlackAccount(params).accountId) ?? resolveSlackApprovalOriginTeamId(params.request);
 }
 //#endregion
 //#region extensions/slack/src/approval-native-gates.ts
-const DEFAULT_APPROVAL_FORWARDING_MODE = "session";
+function isSlackPluginApprovalRequest(request) {
+	return resolveApprovalKind(request) === "plugin";
+}
+function resolveSlackApproverDmTargets(params) {
+	if (!shouldHandleSlackNativeApprovalRequest(params)) return [];
+	const teamId = resolveSlackApprovalTeamId(params);
+	return (params.approvalKind === "plugin" ? isSlackPluginApprovalRequest(params.request) ? getSlackApprovalApproversForTeam({
+		...params,
+		teamId,
+		request: params.request
+	}) : [] : getSlackExecApprovalApprovers(params)).map((approver) => {
+		const target = parseSlackTarget(approver, { defaultKind: "user" });
+		if (!target || target.kind !== "user") throw new Error("Slack approval approver target must be a user");
+		return { to: formatSlackTarget({
+			kind: "user",
+			id: target.id,
+			teamId: target.teamId ?? teamId,
+			explicitKind: true
+		}) };
+	});
+}
 const SLACK_DM_CHANNEL_ID_RE = /^D[A-Z0-9]{8,}$/i;
 const SLACK_USER_ID_RE = /^[UW][A-Z0-9]{8,}$/i;
 function isSlackApprovalTransportEnabled(params) {
 	const account = resolveSlackAccount(params);
 	return isSlackPluginAccountConfigured(account);
 }
-function resolveSlackNativeApprovalConfig(params) {
-	return resolveSlackAccount(params).config.execApprovals;
-}
-function resolvePluginApprovalForwardingConfig(cfg) {
-	return cfg.approvals?.plugin;
-}
 function normalizeSlackThreadMatchKey(threadId) {
 	return threadId == null ? "" : String(threadId).trim();
 }
-function normalizeComparableTarget(value) {
-	return normalizeLowercaseStringOrEmpty(value);
-}
 function extractSlackSessionKind(sessionKey) {
 	if (!sessionKey) return null;
 	const match = sessionKey.match(/slack:(direct|channel|group):/i);
@@ -248,15 +305,12 @@ function resolveSlackFallbackOriginTarget(request) {
 function normalizeSlackOriginTarget(target) {
 	return {
 		...target,
-		to: normalizeComparableTarget(target.to)
+		to: normalizeLowercaseStringOrEmpty(target.to)
 	};
 }
-function parseComparableSlackTarget(target) {
-	return parseSlackTarget(target.to, { defaultKind: "channel" });
-}
 function isSlackDmChannelToUserRoutePair(a, b) {
-	const left = parseComparableSlackTarget(a);
-	const right = parseComparableSlackTarget(b);
+	const left = parseSlackTarget(a.to, { defaultKind: "channel" });
+	const right = parseSlackTarget(b.to, { defaultKind: "channel" });
 	if (!left || !right) return false;
 	if (left.teamId?.toLowerCase() !== right.teamId?.toLowerCase()) return false;
 	return left.kind === "channel" && SLACK_DM_CHANNEL_ID_RE.test(left.id) && right.kind === "user" || right.kind === "channel" && SLACK_DM_CHANNEL_ID_RE.test(right.id) && left.kind === "user";
@@ -293,7 +347,7 @@ function normalizeSlackForwardTarget(target) {
 }
 const { canApprovalPotentiallyRouteToChannel: canApprovalPotentiallyRouteToSlack, isSessionApprovalEligible: isForwardedSlackSessionApprovalEligible, isExplicitTargetEligible: isForwardedSlackExplicitTargetEligible } = createNativeApprovalChannelRouteGates({
 	channel: "slack",
-	defaultForwardingMode: DEFAULT_APPROVAL_FORWARDING_MODE,
+	defaultForwardingMode: "session",
 	isTransportEnabled: isSlackApprovalTransportEnabled,
 	listAccountIds: listSlackAccountIds,
 	resolveDefaultAccountId: resolveDefaultSlackAccountId,
@@ -301,128 +355,91 @@ const { canApprovalPotentiallyRouteToChannel: canApprovalPotentiallyRouteToSlack
 	resolveTurnSourceTarget: resolveTurnSourceSlackOriginTarget,
 	targetsMatch: slackTargetsMatch
 });
-function hasSlackPluginApprovers(params) {
-	return getSlackApprovalApproversForTeam(params).length > 0;
-}
 function isSlackPluginNativeApprovalClientConfigEnabled(params) {
-	const slackNativeConfig = resolveSlackNativeApprovalConfig(params);
-	return isChannelExecApprovalClientEnabledFromConfig({
+	const slackNativeConfig = resolveSlackAccount(params).config.execApprovals;
+	const policy = params.cfg.approvals?.plugin?.slack;
+	return (policy?.approvers?.length ?? 0) > 0 || Object.values(policy?.plugins ?? {}).some((plugin) => (plugin.approvers?.length ?? 0) > 0 || Object.values(plugin.tools ?? {}).some((tool) => tool.approvers.length > 0)) || isChannelExecApprovalClientEnabledFromConfig({
 		enabled: slackNativeConfig?.enabled,
 		approverCount: getSlackApprovalApprovers(params).length
 	});
 }
-function isSlackPluginForwardingRoutePotentiallyEnabled(params) {
-	return canApprovalPotentiallyRouteToSlack({
-		...params,
-		approvalKind: "plugin"
-	});
-}
-function isSlackPluginNativeApprovalClientEnabled(params) {
-	return isSlackPluginNativeApprovalClientConfigEnabled(params) || isSlackPluginForwardingRoutePotentiallyEnabled(params);
-}
-function shouldHandleSlackPluginViaNativeClientConfig(params) {
+function shouldHandleSlackViaNativeClientConfig(params) {
 	if (!doesApprovalRequestSelectChannelAccount({
 		...params,
 		channel: "slack",
 		defaultAccountId: resolveDefaultSlackAccountId(params.cfg),
-		eligibleAccountIds: listSlackNativeApprovalEligibleAccountIds({
-			...params,
-			approvalKind: "plugin"
-		})
+		eligibleAccountIds: listSlackNativeApprovalEligibleAccountIds(params)
 	})) return false;
-	return isSlackNativeApprovalAccountEligible({
-		...params,
-		approvalKind: "plugin"
-	});
-}
-function matchesSlackNativeApprovalFilters(params) {
-	return matchesApprovalRequestFilters({
-		request: params.request.request,
-		agentFilter: params.agentFilter,
-		sessionFilter: params.sessionFilter
-	});
+	return isSlackNativeApprovalAccountEligible(params);
 }
 function isSlackNativeApprovalAccountEligible(params) {
-	const config = resolveSlackNativeApprovalConfig(params);
+	const config = resolveSlackAccount(params).config.execApprovals;
+	const pluginRequest = params.approvalKind === "plugin" && isSlackPluginApprovalRequest(params.request) ? params.request : void 0;
+	if (params.approvalKind === "plugin" && !pluginRequest) return false;
 	const approverCount = params.approvalKind === "exec" ? getSlackExecApprovalApprovers(params).length : getSlackApprovalApproversForTeam({
-		...params,
-		teamId: resolveEnterpriseApprovalTeamId(params.request)
+		cfg: params.cfg,
+		accountId: params.accountId,
+		teamId: resolveSlackApprovalTeamId(params),
+		...pluginRequest ? { request: pluginRequest } : {}
 	}).length;
-	return isSlackApprovalTransportEnabled(params) && isChannelExecApprovalClientEnabledFromConfig({
+	const selectedPolicy = pluginRequest ? resolvePluginApprovalSlackApprovers(params.cfg, pluginRequest) : void 0;
+	return isSlackApprovalTransportEnabled(params) && (selectedPolicy !== void 0 ? approverCount > 0 : isChannelExecApprovalClientEnabledFromConfig({
 		enabled: config?.enabled,
 		approverCount
-	}) && matchesSlackNativeApprovalFilters({
-		request: params.request,
+	}) && matchesApprovalRequestFilters({
+		request: params.request.request,
 		agentFilter: config?.agentFilter,
 		sessionFilter: config?.sessionFilter
-	});
+	}));
 }
 function listSlackNativeApprovalEligibleAccountIds(params) {
+	if (params.approvalKind === "plugin") return listSlackAccountIds(params.cfg).filter((accountId) => isSlackNativeApprovalAccountEligible({
+		...params,
+		accountId
+	}));
 	const accountId = params.accountId ?? resolveDefaultSlackAccountId(params.cfg);
 	return isSlackNativeApprovalAccountEligible({
 		...params,
 		accountId
 	}) ? [accountId] : [];
 }
-function isAnyForwardedSlackExplicitTargetEligible(params) {
-	return (resolvePluginApprovalForwardingConfig(params.cfg)?.targets ?? []).some((target) => isForwardedSlackExplicitTargetEligible({
-		...params,
-		approvalKind: "plugin",
-		target
-	}));
-}
-function shouldHandleSlackPluginViaForwarding(params) {
-	return isForwardedSlackSessionApprovalEligible({
-		...params,
-		approvalKind: "plugin"
-	}) || isAnyForwardedSlackExplicitTargetEligible(params);
-}
 function shouldHandleSlackPluginViaForwardingSession(params) {
 	return isForwardedSlackSessionApprovalEligible({
 		...params,
 		approvalKind: "plugin"
 	});
 }
-function isSlackNativeApprovalClientEnabled(params) {
-	if (params.approvalKind === "exec") return isSlackExecApprovalClientEnabled(params);
-	return isSlackPluginNativeApprovalClientEnabled(params);
-}
 function isSlackAnyNativeApprovalClientEnabled(params) {
-	return isSlackNativeApprovalClientEnabled({
-		...params,
-		approvalKind: "exec"
-	}) || isSlackNativeApprovalClientEnabled({
+	return isSlackExecApprovalClientEnabled(params) || isSlackPluginNativeApprovalClientConfigEnabled(params) || canApprovalPotentiallyRouteToSlack({
 		...params,
 		approvalKind: "plugin"
 	});
 }
 function shouldHandleSlackNativeApprovalRequest(params) {
-	if (getSlackInstallationKind(resolveSlackAccount(params).accountId) === "enterprise" && !resolveEnterpriseApprovalTeamId(params.request)) return false;
-	if (resolveApprovalKind(params.request, params.approvalKind) === "plugin") return shouldHandleSlackPluginViaNativeClientConfig(params) || shouldHandleSlackPluginViaForwarding(params);
+	if (getSlackInstallationKind(resolveSlackAccount(params).accountId) === "enterprise" && !resolveSlackApprovalOriginTeamId(params.request)) return false;
+	const approvalKind = resolveApprovalKind(params.request, params.approvalKind);
+	if (approvalKind === "plugin") {
+		if (!isSlackPluginApprovalRequest(params.request)) return false;
+		if (resolvePluginApprovalSlackApprovers(params.cfg, params.request) !== void 0) return shouldHandleSlackViaNativeClientConfig({
+			...params,
+			approvalKind
+		});
+		return shouldHandleSlackViaNativeClientConfig({
+			...params,
+			approvalKind
+		}) || shouldHandleSlackPluginViaForwardingSession(params) || (params.cfg.approvals?.plugin?.targets ?? []).some((target) => isForwardedSlackExplicitTargetEligible({
+			...params,
+			approvalKind,
+			target
+		}));
+	}
 	const turnSourceChannel = normalizeMessageChannel(params.request.request.turnSourceChannel);
 	if (turnSourceChannel && turnSourceChannel !== "slack") return false;
-	if (!doesApprovalRequestSelectChannelAccount({
-		...params,
-		channel: "slack",
-		defaultAccountId: resolveDefaultSlackAccountId(params.cfg),
-		eligibleAccountIds: listSlackNativeApprovalEligibleAccountIds({
-			...params,
-			approvalKind: "exec"
-		})
-	})) return false;
-	return isSlackNativeApprovalAccountEligible({
+	return shouldHandleSlackViaNativeClientConfig({
 		...params,
 		approvalKind: "exec"
 	});
 }
-function resolveEnterpriseApprovalTeamId(request) {
-	try {
-		const target = resolveTurnSourceSlackOriginTarget(request);
-		return target ? parseSlackTarget(target.to)?.teamId : void 0;
-	} catch {
-		return;
-	}
-}
 //#endregion
 //#region extensions/slack/src/blocks-input.ts
 const SLACK_MAX_BLOCKS = 50;
@@ -433,7 +450,7 @@ function parseBlocksJson(raw) {
 		throw new Error("blocks must be valid JSON");
 	}
 }
-function assertBlocksArray(raw) {
+function validateSlackBlocksArray(raw) {
 	if (!Array.isArray(raw)) throw new Error("blocks must be an array");
 	if (raw.length === 0) throw new Error("blocks must contain at least one block");
 	if (raw.length > 50) throw new Error(`blocks cannot exceed 50 items`);
@@ -442,15 +459,77 @@ function assertBlocksArray(raw) {
 		const type = block.type;
 		if (typeof type !== "string" || type.trim().length === 0) throw new Error("each block must include a non-empty string type");
 	}
-}
-function validateSlackBlocksArray(raw) {
-	assertBlocksArray(raw);
 	return raw;
 }
 function parseSlackBlocksInput(raw) {
 	if (raw == null) return;
 	return validateSlackBlocksArray(typeof raw === "string" ? parseBlocksJson(raw) : raw);
 }
+const SLACK_BUTTON_VALUE_MAX = 2e3;
+const SLACK_SECTION_TEXT_MAX = 3e3;
+const SLACK_PRESENTATION_CAPABILITIES = {
+	supported: true,
+	buttons: true,
+	selects: true,
+	context: true,
+	divider: true,
+	charts: true,
+	tables: true,
+	limits: {
+		actions: {
+			maxActionsPerRow: 25,
+			maxValueBytes: SLACK_BUTTON_VALUE_MAX,
+			supportsStyles: true
+		},
+		selects: {
+			maxOptions: 100,
+			maxValueBytes: 150
+		},
+		text: {
+			encoding: "characters",
+			markdownDialect: "slack-mrkdwn",
+			supportsEdit: true
+		}
+	}
+};
+//#endregion
+//#region extensions/slack/src/approval-actions.ts
+const SLACK_APPROVAL_VALUE_PREFIX = "openclaw:approval:v1:";
+const SLACK_APPROVAL_HEADER_BLOCK_ID = "openclaw_approval_header";
+function isApprovalDecision(value) {
+	return value === "allow-once" || value === "allow-always" || value === "deny";
+}
+/** Encode portable approval facts without exposing a slash command to Slack callbacks. */
+function encodeSlackApprovalAction(action) {
+	const encode = (approvalId) => `${SLACK_APPROVAL_VALUE_PREFIX}${JSON.stringify({
+		approvalId,
+		approvalKind: action.approvalKind,
+		decision: action.decision
+	})}`;
+	const exact = encode(action.approvalId);
+	return exact.length <= 2e3 ? exact : encode(buildApprovalResolutionRef({
+		approvalId: action.approvalId,
+		approvalKind: action.approvalKind
+	}));
+}
+/** Decode only the exact Slack-owned approval envelope. Malformed callbacks fail closed. */
+function decodeSlackApprovalAction(value) {
+	if (typeof value !== "string" || !value.startsWith(SLACK_APPROVAL_VALUE_PREFIX)) return null;
+	try {
+		const decoded = JSON.parse(value.slice(21));
+		if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) return null;
+		const record = decoded;
+		if (Object.keys(record).length !== 3 || typeof record.approvalId !== "string" || record.approvalId.length === 0 || record.approvalKind !== "exec" && record.approvalKind !== "plugin" && record.approvalKind !== "system-agent" || !isApprovalDecision(record.decision)) return null;
+		return {
+			type: "approval",
+			approvalId: record.approvalId,
+			approvalKind: record.approvalKind,
+			decision: record.decision
+		};
+	} catch {
+		return null;
+	}
+}
 //#endregion
 //#region extensions/slack/src/monitor/mrkdwn.ts
 function escapeSlackMrkdwn(value) {
@@ -717,61 +796,37 @@ function buildSlackDataTableBlock(block, options = {}) {
 		...block.rowHeaderColumnIndex !== void 0 ? { row_header_column_index: block.rowHeaderColumnIndex } : {}
 	};
 }
-/** Extract a deterministic accessible summary from a native Slack table block. */
-function renderSlackDataTableFallbackText(value) {
+function renderSlackDataTable(value, render, mrkdwnSafe = false) {
 	const block = asOptionalRecord(value);
 	if (block?.type !== "data_table") return;
 	const parsed = parseSlackDataTable(block);
-	if (parsed) return renderMessagePresentationTableFallbackText({
+	if (parsed) return render({
 		type: "table",
 		caption: parsed.caption,
 		headers: parsed.headers,
 		rows: parsed.rows
 	});
-	return readNonBlankString(block.caption)?.trim();
+	const caption = readNonBlankString(block.caption)?.trim();
+	return caption && mrkdwnSafe ? escapeSlackMrkdwn(caption) : caption;
+}
+/** Extract a deterministic accessible summary from a native Slack table block. */
+function renderSlackDataTableFallbackText(value, mrkdwnSafe = false) {
+	return renderSlackDataTable(value, mrkdwnSafe ? renderSlackMessagePresentationTableFallbackText : renderMessagePresentationTableFallbackText, mrkdwnSafe);
 }
 function escapeCompactFallbackCell(value) {
 	return value.replaceAll("\\", "\\\\").replaceAll("	", "\\t").replaceAll("\r", "\\r").replaceAll("\n", "\\n");
 }
-function escapeSlackBasicTableCell(value, mrkdwnSafe) {
-	return escapeCompactFallbackCell(mrkdwnSafe ? escapeSlackMrkdwn(value) : value);
-}
-function renderSlackBasicTableRows(value, mrkdwnSafe) {
-	return parseSlackBasicTableRows(value)?.map((row) => row.map((cell) => escapeSlackBasicTableCell(cell, mrkdwnSafe)).join("	")).join("\n");
-}
 /** Render Slack's inbound `table` block as ordered, delimiter-safe TSV. */
-function renderSlackTableFallbackText(value) {
-	return renderSlackBasicTableRows(value, false);
-}
-/** Render Slack's inbound `table` block without activating mrkdwn control tokens. */
-function renderSlackTableMrkdwnFallbackText(value) {
-	return renderSlackBasicTableRows(value, true);
+function renderSlackTableFallbackText(value, mrkdwnSafe = false) {
+	return parseSlackBasicTableRows(value)?.map((row) => row.map((cell) => escapeCompactFallbackCell(mrkdwnSafe ? escapeSlackMrkdwn(cell) : cell)).join("	")).join("\n");
 }
 /** Render each native table cell once for bounded, formatting-disabled delivery. */
 function renderSlackDataTableCompactPlainTextFallback(value) {
-	const block = asOptionalRecord(value);
-	if (block?.type !== "data_table") return;
-	const parsed = parseSlackDataTable(block);
-	if (!parsed) return readNonBlankString(block.caption)?.trim();
-	return [
-		`${escapeCompactFallbackCell(parsed.caption)} (table)`,
-		parsed.headers.map(escapeCompactFallbackCell).join("	"),
-		...parsed.rows.map((row) => row.map(escapeCompactFallbackCell).join("	"))
-	].join("\n");
-}
-/** Render a native table as mrkdwn without activating raw cell control tokens. */
-function renderSlackDataTableMrkdwnFallbackText(value) {
-	const block = asOptionalRecord(value);
-	if (block?.type !== "data_table") return;
-	const parsed = parseSlackDataTable(block);
-	if (parsed) return renderSlackMessagePresentationTableFallbackText({
-		type: "table",
-		caption: parsed.caption,
-		headers: parsed.headers,
-		rows: parsed.rows
-	});
-	const caption = readNonBlankString(block.caption)?.trim();
-	return caption ? escapeSlackMrkdwn(caption) : void 0;
+	return renderSlackDataTable(value, (table) => [
+		`${escapeCompactFallbackCell(table.caption)} (table)`,
+		table.headers.map(escapeCompactFallbackCell).join("	"),
+		...table.rows.map((row) => row.map(escapeCompactFallbackCell).join("	"))
+	].join("\n"));
 }
 //#endregion
 //#region extensions/slack/src/data-visualization.ts
@@ -883,41 +938,31 @@ function parseSlackDataVisualizationBlock(value) {
 	}] })?.blocks[0];
 	return normalizedBlock?.type === "chart" ? normalizedBlock : void 0;
 }
-/** Extract a deterministic accessible summary from a native Slack chart block. */
-function renderSlackDataVisualizationFallbackText(value) {
-	const block = asOptionalRecord(value);
-	if (block?.type !== "data_visualization") return;
-	const parsed = parseSlackDataVisualizationBlock(block);
-	if (parsed) return renderMessagePresentationChartFallbackText(parsed);
-	return typeof block.title === "string" && block.title.trim() ? block.title.trim() : void 0;
-}
-/** Render a native chart as mrkdwn without activating raw data control tokens. */
-function renderSlackDataVisualizationMrkdwnFallbackText(value) {
+/** Extract an accessible summary, escaping mrkdwn control tokens when requested. */
+function renderSlackDataVisualizationFallbackText(value, mrkdwnSafe = false) {
 	const block = asOptionalRecord(value);
 	if (block?.type !== "data_visualization") return;
 	const parsed = parseSlackDataVisualizationBlock(block);
-	if (parsed) return renderSlackMessagePresentationChartFallbackText(parsed);
-	return typeof block.title === "string" && block.title.trim() ? escapeSlackMrkdwn(block.title.trim()) : void 0;
+	if (parsed) return mrkdwnSafe ? renderSlackMessagePresentationChartFallbackText(parsed) : renderMessagePresentationChartFallbackText(parsed);
+	const title = typeof block.title === "string" ? block.title.trim() : "";
+	return title ? mrkdwnSafe ? escapeSlackMrkdwn(title) : title : void 0;
 }
 //#endregion
 //#region extensions/slack/src/format.ts
 const SLACK_ANGLE_TOKEN_RE = /<[^>\n]+>/g;
 function isAllowedSlackAngleToken(token) {
-	if (!token.startsWith("<") || !token.endsWith(">")) return false;
 	const inner = token.slice(1, -1);
 	return inner.startsWith("@") || inner.startsWith("#") || inner.startsWith("!") || inner.startsWith("mailto:") || inner.startsWith("tel:") || inner.startsWith("http://") || inner.startsWith("https://") || inner.startsWith("slack://");
 }
 function escapeSlackMrkdwnContent(text, mentions) {
 	if (mentions === "escape") return escapeSlackMrkdwn(text);
-	if (!text) return "";
 	if (!text.includes("&") && !text.includes("<") && !text.includes(">")) return text;
-	SLACK_ANGLE_TOKEN_RE.lastIndex = 0;
 	const out = [];
 	let lastIndex = 0;
-	for (let match = SLACK_ANGLE_TOKEN_RE.exec(text); match; match = SLACK_ANGLE_TOKEN_RE.exec(text)) {
-		const matchIndex = match.index ?? 0;
+	for (const match of text.matchAll(SLACK_ANGLE_TOKEN_RE)) {
+		const matchIndex = match.index;
 		out.push(escapeSlackMrkdwn(text.slice(lastIndex, matchIndex)));
-		const token = match[0] ?? "";
+		const token = match[0];
 		out.push(isAllowedSlackAngleToken(token) ? token : escapeSlackMrkdwn(token));
 		lastIndex = matchIndex + token.length;
 	}
@@ -925,7 +970,6 @@ function escapeSlackMrkdwnContent(text, mentions) {
 	return out.join("");
 }
 function escapeSlackMrkdwnText(text, mentions) {
-	if (!text) return "";
 	if (!text.includes("&") && !text.includes("<") && !text.includes(">")) return text;
 	return text.split("\n").map((line) => {
 		if (line.startsWith("> ")) return `> ${escapeSlackMrkdwnContent(line.slice(2), mentions)}`;
@@ -1235,6 +1279,39 @@ function markdownToSlackMrkdwnChunks(markdown, limit, options = {}) {
 	}).map(({ rendered }) => rendered.length > normalizedLimit ? protectSlackAssistantTranscriptRoleHeaders(rendered) : rendered);
 }
 //#endregion
+//#region extensions/slack/src/question-actions.ts
+const SLACK_QUESTION_VALUE_PREFIX = "slq1:";
+const QUESTION_RECORD_ID_PATTERN = /^ask_[a-f0-9]{32}$/u;
+function encodeSlackQuestionAction(action) {
+	if (!QUESTION_RECORD_ID_PATTERN.test(action.questionId) || !Number.isInteger(action.optionIndex) || action.optionIndex < 0 || action.optionIndex > 3) return;
+	const value = `${SLACK_QUESTION_VALUE_PREFIX}${action.questionId}:${action.optionIndex}`;
+	return value.length <= 2e3 ? value : void 0;
+}
+function decodeSlackQuestionAction(value) {
+	if (typeof value !== "string" || value.length > 2e3) return null;
+	const match = /^slq1:(ask_[a-f0-9]{32}):([0-3])$/u.exec(value);
+	return match?.[1] && match[2] ? {
+		questionId: match[1],
+		optionIndex: Number(match[2])
+	} : null;
+}
+async function resolveSlackQuestionAction(params) {
+	let result;
+	try {
+		result = await (params.resolveQuestion ?? questionGatewayRuntime.resolveOption)({
+			cfg: params.cfg,
+			questionId: params.action.questionId,
+			optionIndex: params.action.optionIndex,
+			senderId: params.userId,
+			clientDisplayName: `Slack question (${params.accountId})`
+		});
+	} catch {
+		await params.respond("Could not submit this answer.").catch(() => {});
+		return;
+	}
+	await params.respond(result.status === "answered" ? "Answer submitted." : "This question was already answered.").catch(() => {});
+}
+//#endregion
 //#region extensions/slack/src/reply-action-ids.ts
 const SLACK_REPLY_BUTTON_ACTION_ID = "openclaw:reply_button";
 const SLACK_REPLY_LINK_ACTION_ID = "openclaw:reply_link";
@@ -1349,15 +1426,8 @@ function readControlElementText(value, options = {}) {
 	}
 }
 function readControlElementsText(values, options = {}) {
-	const seen = /* @__PURE__ */ new Set();
-	const labels = [];
-	for (const value of values) {
-		const candidate = readControlElementText(value, options);
-		if (!candidate || seen.has(candidate)) continue;
-		seen.add(candidate);
-		labels.push(candidate);
-	}
-	return labels.length > 0 ? labels.join("\n") : void 0;
+	const labels = values.map((value) => readControlElementText(value, options)).filter(Boolean);
+	return [...new Set(labels)].join("\n") || void 0;
 }
 function readSectionText(block, options = {}) {
 	const parts = [readTextObject(block.text, options)];
@@ -1382,9 +1452,9 @@ function renderSlackBlockFallbackText(raw, options = {}) {
 		case "file": return "Shared a file";
 		case "context": return readContextText(block, options);
 		case "actions": return readActionsText(block, options);
-		case "data_visualization": return options.nativeDataFormat === "plain" ? renderSlackDataVisualizationFallbackText(block) : renderSlackDataVisualizationMrkdwnFallbackText(block);
-		case "data_table": return options.nativeDataFormat === "plain" ? renderSlackDataTableFallbackText(block) : renderSlackDataTableMrkdwnFallbackText(block);
-		case "table": return options.nativeDataFormat === "plain" ? renderSlackTableFallbackText(block) : renderSlackTableMrkdwnFallbackText(block);
+		case "data_visualization": return renderSlackDataVisualizationFallbackText(block, options.nativeDataFormat !== "plain");
+		case "data_table": return renderSlackDataTableFallbackText(block, options.nativeDataFormat !== "plain");
+		case "table": return renderSlackTableFallbackText(block, options.nativeDataFormat !== "plain");
 		default: return;
 	}
 }
@@ -1446,12 +1516,6 @@ function isSlackNativeResponseUrlRejection(error) {
 	const record = asOptionalRecord(error);
 	return record?.code === "slack_bolt_respond_error" && record.statusCode === 400;
 }
-/** Extract a complete accessible summary from a supported native data block. */
-function renderSlackNativeDataFallbackText(value) {
-	const type = asOptionalRecord(value)?.type;
-	if (type === "data_visualization") return renderSlackDataVisualizationMrkdwnFallbackText(value);
-	if (type === "data_table") return renderSlackDataTableMrkdwnFallbackText(value);
-}
 function comparableText(value) {
 	return value.replace(/\s+/gu, " ").trim();
 }
@@ -1515,7 +1579,7 @@ function buildSlackNativeDataAccessibilityText(text, blocks) {
 }
 /** Preserve every native data block's content once when Slack requires a text-only retry. */
 function appendSlackNativeDataFallbackText(text, blocks) {
-	return appendSlackNativeDataFallback(text, blocks, renderSlackNativeDataFallbackText);
+	return appendSlackNativeDataFallback(text, blocks, (block) => hasSlackNativeDataBlock([block]) ? renderSlackBlockFallbackText(block) : void 0);
 }
 /** Build a bounded plain-text retry without activating control tokens. */
 function appendSlackNativeDataPlainTextFallback(text, blocks) {
@@ -1586,8 +1650,22 @@ function normalizeSlackRouteBindingConfig(cfg) {
 	return normalizedCfg;
 }
 function resolveSlackConversationBindingRoute(params) {
+	const { resolveRoute } = params;
+	let baseRuntimeRoute;
+	const resolveBaseRoute = (threadInspection) => baseRuntimeRoute ??= resolveRuntimeConversationBindingRoute({
+		resolveRoute: threadInspection ? (selection) => inspectRuntimeConversationBindingRoute({
+			route: resolveRoute(selection),
+			inspection: threadInspection
+		}).route : resolveRoute,
+		touchBinding: params.touchBinding,
+		conversation: {
+			channel: "slack",
+			accountId: params.accountId,
+			conversationId: params.baseConversationId
+		}
+	});
 	const boundThreadRoute = params.bindingsEnabled && params.runtimeBindingThreadId ? resolveRuntimeConversationBindingRoute({
-		route: params.route,
+		resolveRoute: (selection) => selection.bindingRecord || !selection.bindingOwnerAvailable ? resolveRoute(selection) : resolveBaseRoute(selection.inspection).route,
 		touchBinding: params.touchBinding,
 		conversation: {
 			channel: "slack",
@@ -1598,18 +1676,17 @@ function resolveSlackConversationBindingRoute(params) {
 	}) : null;
 	const runtimeRoute = !params.bindingsEnabled ? {
 		bindingOwnerAvailable: true,
-		route: params.route,
+		route: resolveRoute({
+			inspection: {
+				status: "available",
+				binding: null
+			},
+			bindingOwnerAvailable: true,
+			bindingRecord: null
+		}),
 		bindingRecord: null,
 		boundSessionKey: void 0
-	} : boundThreadRoute?.boundSessionKey || boundThreadRoute?.bindingRecord ? boundThreadRoute : resolveRuntimeConversationBindingRoute({
-		route: boundThreadRoute?.route ?? params.route,
-		touchBinding: params.touchBinding,
-		conversation: {
-			channel: "slack",
-			accountId: params.accountId,
-			conversationId: params.baseConversationId
-		}
-	});
+	} : boundThreadRoute && (boundThreadRoute.bindingRecord || boundThreadRoute.bindingOwnerAvailable === false) ? boundThreadRoute : resolveBaseRoute();
 	const configuredRoute = params.bindingsEnabled && !runtimeRoute.boundSessionKey && !runtimeRoute.bindingRecord ? resolveConfiguredBindingRoute({
 		cfg: params.cfg,
 		route: runtimeRoute.route,
@@ -1734,4 +1811,4 @@ async function renameSlackSession(params) {
 	}
 }
 //#endregion
-export { SLACK_DATA_TABLE_AGGREGATE_CELL_CHARACTERS_MAX as $, countSlackTextUtf8Bytes as A, resolveSlackExecApprovalTarget as At, SLACK_REPLY_LINK_ACTION_ID as B, buildSlackBlocksFallbackText as C, registerSlackInstallationState as Ct, SLACK_MESSAGE_TEXT_HARD_LIMIT as D, isSlackExecApprovalAuthorizedSender as Dt, SLACK_EDIT_TEXT_MAX_BYTES as E, getSlackExecApprovalApprovers as Et, SLACK_CALLBACK_BUTTON_ACTION_ID as F, isSlackQuestionActionId as G, SLACK_SESSION_LINK_ACTION_ID as H, SLACK_CALLBACK_SELECT_ACTION_ID as I, markdownToSlackMrkdwnChunks as J, resolveSlackQuestionActionIds as K, SLACK_QUESTION_BUTTON_ACTION_ID as L, truncateSlackTextByUtf8Bytes as M, SLACK_PRIVATE_ACTION_DELIVERY_RESULT as Mt, SLACK_APPROVAL_BUTTON_ACTION_ID as N, resolveSlackAutoThreadId as Nt, SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT as O, isSlackExecApprovalClientEnabled as Ot, SLACK_APPROVAL_SELECT_ACTION_ID as P, resolveSlackReplyToMode as Pt, hasSlackDataVisualizationBlock as Q, SLACK_QUESTION_FINALIZATION_BLOCKS as R, stripSlackNativeDataBlocks as S, isSlackWorkspaceInstallation as St, renderSlackBlockFallbackText as T, isSlackApprovalAuthorizedSender as Tt, isSlackApprovalActionId as U, SLACK_REPLY_SELECT_ACTION_ID as V, isSlackCallbackActionId as W, buildSlackDataVisualizationBlock as X, normalizeSlackOutboundText as Y, canRenderSlackDataVisualization as Z, createSlackNativeDataBaseTextConsumer as _, resolveTurnSourceSlackOriginTarget as _t, resolveSlackGroupRequireMention as a, renderSlackMessagePresentationFallbackText as at, isSlackInvalidBlocksResponse as b, slackTargetsMatch as bt, qualifySlackRoutePeerId as c, parseSlackBlocksInput as ct, resolveSlackConversationBindingRoute as d, isSlackAnyNativeApprovalClientEnabled as dt, buildSlackDataTableBlock as et, assertSlackDetachedTargetAllowed as f, normalizeSlackForwardTarget as ft, buildSlackNativeDataAccessibilityText as g, resolveSlackFallbackOriginTarget as gt, appendSlackNativeDataPlainTextFallback as h, resolveSessionSlackOriginTarget as ht, buildSlackChannelPolicyScope as i, renderSlackMessagePresentationChartFallbackText as it, truncateSlackText as j, shouldSuppressLocalSlackExecApprovalPrompt as jt, SLACK_TEXT_LIMIT as k, normalizeSlackApproverId as kt, resolveSlackEnterpriseMainDmSessionKey as l, validateSlackBlocksArray as lt, appendSlackNativeDataFallbackText as m, resolveEnterpriseApprovalTeamId as mt, setSlackSessionStatus as n, countSlackDataTableCellCharacters as nt, resolveSlackGroupToolPolicy as o, escapeSlackMrkdwn as ot, SLACK_MALFORMED_NATIVE_DATA_FALLBACK as p, normalizeSlackOriginTarget as pt, chunkSlackMrkdwnText as q, buildSlackChannelIdCandidates as r, resolveSlackDataTableCellCharacterCount as rt, qualifySlackConversationId as s, SLACK_MAX_BLOCKS as st, renameSlackSession as t, countSlackDataTableBlocksCellCharacters as tt, normalizeSlackRouteBindingConfig as u, hasSlackPluginApprovers as ut, hasSlackNativeDataBlock as v, shouldHandleSlackNativeApprovalRequest as vt, buildSlackCompleteBlocksFallbackText as w, getSlackApprovalApproversForTeam as wt, isSlackNativeResponseUrlRejection as x, getSlackInstallationKind as xt, isSlackInvalidBlocksError as y, shouldHandleSlackPluginViaForwardingSession as yt, SLACK_REPLY_BUTTON_ACTION_ID as z };
+export { buildSlackDataVisualizationBlock as $, countSlackTextUtf8Bytes as A, getSlackApprovalApproversForTeam as At, SLACK_REPLY_LINK_ACTION_ID as B, resolveSlackExecApprovalTarget as Bt, buildSlackBlocksFallbackText as C, resolveSessionSlackOriginTarget as Ct, SLACK_MESSAGE_TEXT_HARD_LIMIT as D, shouldHandleSlackNativeApprovalRequest as Dt, SLACK_EDIT_TEXT_MAX_BYTES as E, resolveTurnSourceSlackOriginTarget as Et, SLACK_CALLBACK_BUTTON_ACTION_ID as F, registerSlackInstallationState as Ft, isSlackQuestionActionId as G, SLACK_SESSION_LINK_ACTION_ID as H, resolvePluginApprovalSlackApprovers as Ht, SLACK_CALLBACK_SELECT_ACTION_ID as I, getSlackExecApprovalApprovers as It, encodeSlackQuestionAction as J, resolveSlackQuestionActionIds as K, SLACK_QUESTION_BUTTON_ACTION_ID as L, isSlackExecApprovalAuthorizedSender as Lt, truncateSlackTextByUtf8Bytes as M, resolveSlackApprovalTeamId as Mt, SLACK_APPROVAL_BUTTON_ACTION_ID as N, getSlackInstallationKind as Nt, SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT as O, shouldHandleSlackPluginViaForwardingSession as Ot, SLACK_APPROVAL_SELECT_ACTION_ID as P, isSlackWorkspaceInstallation as Pt, normalizeSlackOutboundText as Q, SLACK_QUESTION_FINALIZATION_BLOCKS as R, isSlackExecApprovalClientEnabled as Rt, stripSlackNativeDataBlocks as S, normalizeSlackOriginTarget as St, renderSlackBlockFallbackText as T, resolveSlackFallbackOriginTarget as Tt, isSlackApprovalActionId as U, SLACK_PRIVATE_ACTION_DELIVERY_RESULT as Ut, SLACK_REPLY_SELECT_ACTION_ID as V, shouldSuppressLocalSlackExecApprovalPrompt as Vt, isSlackCallbackActionId as W, resolveSlackAutoThreadId as Wt, chunkSlackMrkdwnText as X, resolveSlackQuestionAction as Y, markdownToSlackMrkdwnChunks as Z, createSlackNativeDataBaseTextConsumer as _, parseSlackBlocksInput as _t, resolveSlackGroupRequireMention as a, countSlackDataTableCellCharacters as at, isSlackInvalidBlocksResponse as b, isSlackPluginApprovalRequest as bt, qualifySlackRoutePeerId as c, renderSlackMessagePresentationFallbackText as ct, resolveSlackConversationBindingRoute as d, decodeSlackApprovalAction as dt, canRenderSlackDataVisualization as et, assertSlackDetachedTargetAllowed as f, encodeSlackApprovalAction as ft, buildSlackNativeDataAccessibilityText as g, SLACK_MAX_BLOCKS as gt, appendSlackNativeDataPlainTextFallback as h, SLACK_SECTION_TEXT_MAX as ht, buildSlackChannelPolicyScope as i, countSlackDataTableBlocksCellCharacters as it, truncateSlackText as j, isSlackPluginApprovalAuthorizedSender as jt, SLACK_TEXT_LIMIT as k, slackTargetsMatch as kt, resolveSlackEnterpriseMainDmSessionKey as l, escapeSlackMrkdwn as lt, appendSlackNativeDataFallbackText as m, SLACK_PRESENTATION_CAPABILITIES as mt, setSlackSessionStatus as n, SLACK_DATA_TABLE_AGGREGATE_CELL_CHARACTERS_MAX as nt, resolveSlackGroupToolPolicy as o, resolveSlackDataTableCellCharacterCount as ot, SLACK_MALFORMED_NATIVE_DATA_FALLBACK as p, SLACK_BUTTON_VALUE_MAX as pt, decodeSlackQuestionAction as q, buildSlackChannelIdCandidates as r, buildSlackDataTableBlock as rt, qualifySlackConversationId as s, renderSlackMessagePresentationChartFallbackText as st, renameSlackSession as t, hasSlackDataVisualizationBlock as tt, normalizeSlackRouteBindingConfig as u, SLACK_APPROVAL_HEADER_BLOCK_ID as ut, hasSlackNativeDataBlock as v, validateSlackBlocksArray as vt, buildSlackCompleteBlocksFallbackText as w, resolveSlackApproverDmTargets as wt, isSlackNativeResponseUrlRejection as x, normalizeSlackForwardTarget as xt, isSlackInvalidBlocksError as y, isSlackAnyNativeApprovalClientEnabled as yt, SLACK_REPLY_BUTTON_ACTION_ID as z, normalizeSlackApproverId as zt };