@openclaw/slack 2026.5.12-beta.7

package/dist/doctor-contract-KUjHnkQm.js

@@ -0,0 +1,147 @@
+import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode } from "./streaming-compat-RkZgTmQ2.js";
+import { asObjectRecord, hasLegacyAccountStreamingAliases, hasLegacyStreamingAliases, normalizeLegacyChannelAliases } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/slack/src/doctor-contract.ts
+function hasLegacySlackStreamingAliases(value) {
+	return hasLegacyStreamingAliases(value, { includeNativeTransport: true });
+}
+function hasLegacySlackChannelAllowAlias(value) {
+	const channels = asObjectRecord(asObjectRecord(value)?.channels);
+	if (!channels) return false;
+	return Object.values(channels).some((channel) => Object.prototype.hasOwnProperty.call(asObjectRecord(channel) ?? {}, "allow"));
+}
+function normalizeSlackChannelAllowAliases(params) {
+	let changed = false;
+	const nextChannels = { ...params.channels };
+	for (const [channelId, channelValue] of Object.entries(params.channels)) {
+		const channel = asObjectRecord(channelValue);
+		if (!channel || !Object.prototype.hasOwnProperty.call(channel, "allow")) continue;
+		const nextChannel = { ...channel };
+		if (nextChannel.enabled === void 0) {
+			nextChannel.enabled = channel.allow;
+			params.changes.push(`Moved ${params.pathPrefix}.${channelId}.allow → ${params.pathPrefix}.${channelId}.enabled.`);
+		} else params.changes.push(`Removed ${params.pathPrefix}.${channelId}.allow (${params.pathPrefix}.${channelId}.enabled already set).`);
+		delete nextChannel.allow;
+		nextChannels[channelId] = nextChannel;
+		changed = true;
+	}
+	return {
+		channels: nextChannels,
+		changed
+	};
+}
+const legacyConfigRules = [
+	{
+		path: ["channels", "slack"],
+		message: "channels.slack.streamMode, channels.slack.streaming (scalar), chunkMode, blockStreaming, blockStreamingCoalesce, and nativeStreaming are legacy; use channels.slack.streaming.{mode,chunkMode,block.enabled,block.coalesce,nativeTransport}.",
+		match: hasLegacySlackStreamingAliases
+	},
+	{
+		path: [
+			"channels",
+			"slack",
+			"accounts"
+		],
+		message: "channels.slack.accounts.<id>.streamMode, streaming (scalar), chunkMode, blockStreaming, blockStreamingCoalesce, and nativeStreaming are legacy; use channels.slack.accounts.<id>.streaming.{mode,chunkMode,block.enabled,block.coalesce,nativeTransport}.",
+		match: (value) => hasLegacyAccountStreamingAliases(value, hasLegacySlackStreamingAliases)
+	},
+	{
+		path: ["channels", "slack"],
+		message: "channels.slack.channels.<id>.allow is legacy; use channels.slack.channels.<id>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacySlackChannelAllowAlias
+	},
+	{
+		path: [
+			"channels",
+			"slack",
+			"accounts"
+		],
+		message: "channels.slack.accounts.<id>.channels.<id>.allow is legacy; use channels.slack.accounts.<id>.channels.<id>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: (value) => {
+			const accounts = asObjectRecord(value);
+			if (!accounts) return false;
+			return Object.values(accounts).some((account) => hasLegacySlackChannelAllowAlias(account));
+		}
+	}
+];
+function normalizeCompatibilityConfig({ cfg }) {
+	const rawEntry = asObjectRecord(cfg.channels?.slack);
+	if (!rawEntry) return {
+		config: cfg,
+		changes: []
+	};
+	const changes = [];
+	let updated = rawEntry;
+	let changed = false;
+	const aliases = normalizeLegacyChannelAliases({
+		entry: rawEntry,
+		pathPrefix: "channels.slack",
+		changes,
+		normalizeDm: true,
+		normalizeAccountDm: true,
+		resolveStreamingOptions: (entry) => ({
+			resolvedMode: resolveSlackStreamingMode(entry),
+			resolvedNativeTransport: resolveSlackNativeStreaming(entry)
+		})
+	});
+	updated = aliases.entry;
+	changed = aliases.changed;
+	const channels = asObjectRecord(updated.channels);
+	if (channels) {
+		const normalized = normalizeSlackChannelAllowAliases({
+			channels,
+			pathPrefix: "channels.slack.channels",
+			changes
+		});
+		if (normalized.changed) {
+			updated = {
+				...updated,
+				channels: normalized.channels
+			};
+			changed = true;
+		}
+	}
+	const accounts = asObjectRecord(updated.accounts);
+	if (accounts) {
+		let accountsChanged = false;
+		const nextAccounts = { ...accounts };
+		for (const [accountId, accountValue] of Object.entries(accounts)) {
+			const account = asObjectRecord(accountValue);
+			const channelEntries = asObjectRecord(account?.channels);
+			if (!account || !channelEntries) continue;
+			const normalized = normalizeSlackChannelAllowAliases({
+				channels: channelEntries,
+				pathPrefix: `channels.slack.accounts.${accountId}.channels`,
+				changes
+			});
+			if (!normalized.changed) continue;
+			nextAccounts[accountId] = {
+				...account,
+				channels: normalized.channels
+			};
+			accountsChanged = true;
+		}
+		if (accountsChanged) {
+			updated = {
+				...updated,
+				accounts: nextAccounts
+			};
+			changed = true;
+		}
+	}
+	if (!changed) return {
+		config: cfg,
+		changes: []
+	};
+	return {
+		config: {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				slack: updated
+			}
+		},
+		changes
+	};
+}
+//#endregion
+export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/doctor-contract-api.js

@@ -0,0 +1,2 @@
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-KUjHnkQm.js";
+export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/errors-BYFHR24f.js

@@ -0,0 +1,109 @@
+import { redactSensitiveText } from "openclaw/plugin-sdk/logging-core";
+//#region extensions/slack/src/errors.ts
+const NO_ERROR_DETAIL = "no error detail";
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function redact(value) {
+	return redactSensitiveText(value);
+}
+function addStringDetail(details, label, value) {
+	if (typeof value !== "string") return;
+	const trimmed = redact(value.trim());
+	if (trimmed) details.push(label ? `${label}: ${trimmed}` : trimmed);
+}
+function addScalarDetail(details, label, value) {
+	if (typeof value === "string") {
+		addStringDetail(details, label, value);
+		return;
+	}
+	if (typeof value === "number" || typeof value === "boolean") details.push(`${label}: ${String(value)}`);
+}
+function addStringListDetail(details, label, value) {
+	if (!Array.isArray(value)) return;
+	const entries = value.flatMap((entry) => {
+		if (typeof entry !== "string") return [];
+		const trimmed = redact(entry.trim());
+		return trimmed ? [trimmed] : [];
+	});
+	if (entries.length) details.push(`${label}: ${entries.join(", ")}`);
+}
+function safeStringify(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		const result = JSON.stringify(value, (_key, nested) => {
+			if (typeof nested !== "object" || nested === null) return nested;
+			if (seen.has(nested)) return "[Circular]";
+			seen.add(nested);
+			return nested;
+		});
+		return result ? redact(result) : void 0;
+	} catch {
+		return;
+	}
+}
+function addSlackResponseMetadata(details, value) {
+	if (!isRecord(value)) return;
+	addStringListDetail(details, "scopes", value.scopes);
+	addStringListDetail(details, "accepted", value.acceptedScopes);
+	const messages = value.messages;
+	if (Array.isArray(messages)) for (const message of messages) addStringDetail(details, "slack message", message);
+	const warnings = value.warnings;
+	if (Array.isArray(warnings)) for (const warning of warnings) addStringDetail(details, "slack warning", warning);
+}
+function addSlackDataDetails(details, value) {
+	if (!isRecord(value)) return;
+	addScalarDetail(details, "slack error", value.error);
+	addScalarDetail(details, "needed", value.needed);
+	addScalarDetail(details, "provided", value.provided);
+	addSlackResponseMetadata(details, value.response_metadata);
+}
+function addRecordDetails(details, value) {
+	addScalarDetail(details, "code", value.code);
+	addScalarDetail(details, "status", value.status);
+	addScalarDetail(details, "statusCode", value.statusCode);
+	addScalarDetail(details, "statusMessage", value.statusMessage);
+	addScalarDetail(details, "retryAfter", value.retryAfter);
+	addScalarDetail(details, "errno", value.errno);
+	addScalarDetail(details, "syscall", value.syscall);
+	addScalarDetail(details, "hostname", value.hostname);
+	addScalarDetail(details, "type", value.type);
+	addStringDetail(details, "statusText", value.statusText);
+	addStringDetail(details, "body", value.body);
+	addSlackDataDetails(details, value.data);
+	if (isRecord(value.response)) {
+		addScalarDetail(details, "response status", value.response.status);
+		addStringDetail(details, "response statusText", value.response.statusText);
+		addSlackDataDetails(details, value.response.data);
+	}
+}
+function collectSlackErrorDetails(error) {
+	const details = [];
+	if (error === void 0 || error === null) return details;
+	if (typeof error === "string") {
+		addStringDetail(details, "", error);
+		return details;
+	}
+	if (error instanceof Error) {
+		addStringDetail(details, "", error.message || error.name);
+		if (error.cause !== void 0) {
+			const cause = formatSlackError(error.cause, "");
+			if (cause) details.push(`cause: ${cause}`);
+		}
+	}
+	if (isRecord(error)) {
+		addRecordDetails(details, error);
+		const fallback = safeStringify(error);
+		if (details.length === 0 && fallback && fallback !== "{}") details.push(fallback);
+	}
+	return details;
+}
+function formatSlackError(error, fallback = NO_ERROR_DETAIL) {
+	const details = collectSlackErrorDetails(error);
+	if (details.length > 0) return details.join("; ");
+	if (error === void 0 || error === null) return fallback;
+	if (typeof error === "string" && !error.trim()) return fallback;
+	return safeStringify(error) ?? fallback;
+}
+//#endregion
+export { formatSlackError as t };

package/dist/exec-approvals-7xUNgLi9.js

@@ -0,0 +1,58 @@
+import { a as resolveSlackAccount } from "./accounts-ClAPP5ry.js";
+import { normalizeStringifiedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { doesApprovalRequestMatchChannelAccount } from "openclaw/plugin-sdk/approval-native-runtime";
+import { resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { createChannelExecApprovalProfile, isChannelExecApprovalTargetRecipient } from "openclaw/plugin-sdk/approval-client-runtime";
+//#region extensions/slack/src/exec-approvals.ts
+function normalizeSlackApproverId(value) {
+	const trimmed = normalizeStringifiedOptionalString(value);
+	if (!trimmed) return;
+	const prefixed = trimmed.match(/^(?:slack|user):([A-Z0-9]+)$/i);
+	if (prefixed?.[1]) return prefixed[1];
+	const mention = trimmed.match(/^<@([A-Z0-9]+)>$/i);
+	if (mention?.[1]) return mention[1];
+	return /^[UW][A-Z0-9]+$/i.test(trimmed) ? trimmed : void 0;
+}
+function resolveSlackOwnerApprovers(cfg) {
+	const ownerAllowFrom = cfg.commands?.ownerAllowFrom;
+	if (!Array.isArray(ownerAllowFrom) || ownerAllowFrom.length === 0) return [];
+	return resolveApprovalApprovers({
+		explicit: ownerAllowFrom,
+		normalizeApprover: normalizeSlackApproverId
+	});
+}
+function getSlackExecApprovalApprovers(params) {
+	const account = resolveSlackAccount(params).config;
+	return resolveApprovalApprovers({
+		explicit: account.execApprovals?.approvers ?? resolveSlackOwnerApprovers(params.cfg),
+		normalizeApprover: normalizeSlackApproverId
+	});
+}
+function isSlackExecApprovalTargetRecipient(params) {
+	return isChannelExecApprovalTargetRecipient({
+		...params,
+		channel: "slack",
+		normalizeSenderId: normalizeSlackApproverId,
+		matchTarget: ({ target, normalizedSenderId }) => normalizeSlackApproverId(target.to) === normalizedSenderId
+	});
+}
+const slackExecApprovalProfile = createChannelExecApprovalProfile({
+	resolveConfig: (params) => resolveSlackAccount(params).config.execApprovals,
+	resolveApprovers: getSlackExecApprovalApprovers,
+	normalizeSenderId: normalizeSlackApproverId,
+	isTargetRecipient: isSlackExecApprovalTargetRecipient,
+	matchesRequestAccount: (params) => doesApprovalRequestMatchChannelAccount({
+		cfg: params.cfg,
+		request: params.request,
+		channel: "slack",
+		accountId: params.accountId
+	})
+});
+const isSlackExecApprovalClientEnabled = slackExecApprovalProfile.isClientEnabled;
+const isSlackExecApprovalApprover = slackExecApprovalProfile.isApprover;
+const isSlackExecApprovalAuthorizedSender = slackExecApprovalProfile.isAuthorizedSender;
+const resolveSlackExecApprovalTarget = slackExecApprovalProfile.resolveTarget;
+const shouldHandleSlackExecApprovalRequest = slackExecApprovalProfile.shouldHandleRequest;
+const shouldSuppressLocalSlackExecApprovalPrompt = slackExecApprovalProfile.shouldSuppressLocalPrompt;
+//#endregion
+export { normalizeSlackApproverId as a, shouldSuppressLocalSlackExecApprovalPrompt as c, isSlackExecApprovalClientEnabled as i, isSlackExecApprovalApprover as n, resolveSlackExecApprovalTarget as o, isSlackExecApprovalAuthorizedSender as r, shouldHandleSlackExecApprovalRequest as s, getSlackExecApprovalApprovers as t };

package/dist/group-policy-CyLUK6My.js

@@ -0,0 +1,41 @@
+import { i as resolveDefaultSlackAccountId, r as mergeSlackAccountConfig } from "./accounts-ClAPP5ry.js";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
+import { normalizeHyphenSlug } from "openclaw/plugin-sdk/string-normalization-runtime";
+import { resolveToolsBySender } from "openclaw/plugin-sdk/channel-policy";
+//#region extensions/slack/src/group-policy.ts
+function resolveSlackChannelPolicyEntry(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSlackAccountId(params.cfg));
+	const channelMap = mergeSlackAccountConfig(params.cfg, accountId).channels ?? {};
+	if (Object.keys(channelMap).length === 0) return;
+	const channelId = params.groupId?.trim();
+	const channelName = params.groupChannel?.replace(/^#/, "");
+	const normalizedName = normalizeHyphenSlug(channelName);
+	const candidates = [
+		channelId ?? "",
+		channelName ? `#${channelName}` : "",
+		channelName ?? "",
+		normalizedName
+	].filter(Boolean);
+	for (const candidate of candidates) if (candidate && channelMap[candidate]) return channelMap[candidate];
+	return channelMap["*"];
+}
+function resolveSenderToolsEntry(entry, params) {
+	if (!entry) return;
+	return resolveToolsBySender({
+		toolsBySender: entry.toolsBySender,
+		senderId: params.senderId,
+		senderName: params.senderName,
+		senderUsername: params.senderUsername,
+		senderE164: params.senderE164
+	}) ?? entry.tools;
+}
+function resolveSlackGroupRequireMention(params) {
+	const resolved = resolveSlackChannelPolicyEntry(params);
+	if (typeof resolved?.requireMention === "boolean") return resolved.requireMention;
+	return true;
+}
+function resolveSlackGroupToolPolicy(params) {
+	return resolveSenderToolsEntry(resolveSlackChannelPolicyEntry(params), params);
+}
+//#endregion
+export { resolveSlackGroupToolPolicy as n, resolveSlackGroupRequireMention as t };

package/dist/http-routes-api.js

@@ -0,0 +1,2 @@
+import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-DtTPmga1.js";
+export { registerSlackPluginHttpRoutes };

package/dist/inbound-contract-test-api.js

@@ -0,0 +1,3 @@
+import { t as prepareSlackMessage } from "./prepare-D3YqV8jB.js";
+import { t as createInboundSlackTestContext } from "./prepare.test-helpers-DVcjRhfG.js";
+export { createInboundSlackTestContext, prepareSlackMessage };

package/dist/index.js

@@ -0,0 +1,33 @@
+import { defineBundledChannelEntry, loadBundledEntryExportSync } from "openclaw/plugin-sdk/channel-entry-contract";
+//#region extensions/slack/index.ts
+function registerSlackPluginHttpRoutes(api) {
+	loadBundledEntryExportSync(import.meta.url, {
+		specifier: "./http-routes-api.js",
+		exportName: "registerSlackPluginHttpRoutes"
+	})(api);
+}
+var slack_default = defineBundledChannelEntry({
+	id: "slack",
+	name: "Slack",
+	description: "Slack channel plugin",
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./channel-plugin-api.js",
+		exportName: "slackPlugin"
+	},
+	secrets: {
+		specifier: "./secret-contract-api.js",
+		exportName: "channelSecrets"
+	},
+	runtime: {
+		specifier: "./runtime-setter-api.js",
+		exportName: "setSlackRuntime"
+	},
+	accountInspect: {
+		specifier: "./account-inspect-api.js",
+		exportName: "inspectSlackReadOnlyAccount"
+	},
+	registerFull: registerSlackPluginHttpRoutes
+});
+//#endregion
+export { slack_default as default };

package/dist/interactive-replies-api.js

@@ -0,0 +1,2 @@
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-qAIfuBor.js";
+export { compileSlackInteractiveReplies, isSlackInteractiveRepliesEnabled };

package/dist/interactive-replies-qAIfuBor.js

@@ -0,0 +1,173 @@
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId } from "./accounts-ClAPP5ry.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/slack/src/interactive-replies.ts
+const SLACK_BUTTON_MAX_ITEMS = 5;
+const SLACK_SELECT_MAX_ITEMS = 100;
+const SLACK_DIRECTIVE_RE = /\[\[(slack_buttons|slack_select):\s*([^\]]+)\]\]/gi;
+const SLACK_OPTIONS_LINE_RE = /^\s*Options:\s*(.+?)\s*\.?\s*$/i;
+const SLACK_AUTO_SELECT_MAX_ITEMS = 12;
+const SLACK_SIMPLE_OPTION_RE = /^[a-z0-9][a-z0-9 _+/-]{0,31}$/i;
+function parseChoice(raw, options) {
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	const delimiter = trimmed.indexOf(":");
+	if (delimiter === -1) return {
+		label: trimmed,
+		value: trimmed
+	};
+	const label = trimmed.slice(0, delimiter).trim();
+	let value = trimmed.slice(delimiter + 1).trim();
+	if (!label || !value) return null;
+	let style;
+	if (options?.allowStyle) {
+		const styleDelimiter = value.lastIndexOf(":");
+		if (styleDelimiter !== -1) {
+			const maybeStyle = normalizeLowercaseStringOrEmpty(value.slice(styleDelimiter + 1));
+			if (maybeStyle === "primary" || maybeStyle === "secondary" || maybeStyle === "success" || maybeStyle === "danger") {
+				const unstyledValue = value.slice(0, styleDelimiter).trim();
+				if (unstyledValue) {
+					value = unstyledValue;
+					style = maybeStyle;
+				}
+			}
+		}
+	}
+	return style ? {
+		label,
+		value,
+		style
+	} : {
+		label,
+		value
+	};
+}
+function parseChoices(raw, maxItems, options) {
+	return raw.split(",").map((entry) => parseChoice(entry, options)).filter((entry) => Boolean(entry)).slice(0, maxItems);
+}
+function buildTextBlock(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return null;
+	return {
+		type: "text",
+		text: trimmed
+	};
+}
+function buildButtonsBlock(raw) {
+	const choices = parseChoices(raw, SLACK_BUTTON_MAX_ITEMS, { allowStyle: true });
+	if (choices.length === 0) return null;
+	return {
+		type: "buttons",
+		buttons: choices.map((choice) => Object.assign({
+			label: choice.label,
+			value: choice.value
+		}, choice.style ? { style: choice.style } : {}))
+	};
+}
+function buildSelectBlock(raw) {
+	const parts = raw.split("|").map((entry) => entry.trim()).filter(Boolean);
+	if (parts.length === 0) return null;
+	const [first, second] = parts;
+	const placeholder = parts.length >= 2 ? first : "Choose an option";
+	const choices = parseChoices(parts.length >= 2 ? second : first, SLACK_SELECT_MAX_ITEMS);
+	if (choices.length === 0) return null;
+	return {
+		type: "select",
+		placeholder,
+		options: choices
+	};
+}
+function hasSlackBlocks(payload) {
+	const blocks = (payload.channelData?.slack)?.blocks;
+	if (typeof blocks === "string") return blocks.trim().length > 0;
+	return Array.isArray(blocks) && blocks.length > 0;
+}
+function parseSimpleSlackOptions(raw) {
+	const entries = raw.split(",").map((entry) => entry.trim()).filter(Boolean);
+	if (entries.length < 2 || entries.length > SLACK_AUTO_SELECT_MAX_ITEMS) return null;
+	if (!entries.every((entry) => SLACK_SIMPLE_OPTION_RE.test(entry))) return null;
+	if (new Set(entries.map((entry) => normalizeLowercaseStringOrEmpty(entry))).size !== entries.length) return null;
+	return entries.map((entry) => ({
+		label: entry,
+		value: entry
+	}));
+}
+function resolveInteractiveRepliesFromCapabilities(capabilities) {
+	if (!capabilities) return false;
+	if (Array.isArray(capabilities)) return capabilities.some((entry) => normalizeLowercaseStringOrEmpty(String(entry)) === "interactivereplies");
+	if (typeof capabilities === "object") return capabilities.interactiveReplies === true;
+	return false;
+}
+function isSlackInteractiveRepliesEnabled(params) {
+	return resolveInteractiveRepliesFromCapabilities(resolveSlackAccount({
+		cfg: params.cfg,
+		accountId: params.accountId ?? resolveDefaultSlackAccountId(params.cfg)
+	}).config.capabilities);
+}
+function compileSlackInteractiveReplies(payload) {
+	const text = payload.text;
+	if (!text) return payload;
+	const generatedBlocks = [];
+	const visibleTextParts = [];
+	let cursor = 0;
+	let matchedDirective = false;
+	let generatedInteractiveBlock = false;
+	SLACK_DIRECTIVE_RE.lastIndex = 0;
+	for (const match of text.matchAll(SLACK_DIRECTIVE_RE)) {
+		matchedDirective = true;
+		const matchText = match[0];
+		const directiveType = match[1];
+		const body = match[2];
+		const index = match.index ?? 0;
+		const precedingText = text.slice(cursor, index);
+		visibleTextParts.push(precedingText);
+		const section = buildTextBlock(precedingText);
+		if (section) generatedBlocks.push(section);
+		const block = normalizeLowercaseStringOrEmpty(directiveType) === "slack_buttons" ? buildButtonsBlock(body) : buildSelectBlock(body);
+		if (block) {
+			generatedInteractiveBlock = true;
+			generatedBlocks.push(block);
+		}
+		cursor = index + matchText.length;
+	}
+	const trailingText = text.slice(cursor);
+	visibleTextParts.push(trailingText);
+	const trailingSection = buildTextBlock(trailingText);
+	if (trailingSection) generatedBlocks.push(trailingSection);
+	const cleanedText = visibleTextParts.join("");
+	if (!matchedDirective || !generatedInteractiveBlock) return parseSlackOptionsLine(payload);
+	return {
+		...payload,
+		text: cleanedText.trim() || void 0,
+		interactive: { blocks: [...payload.interactive?.blocks ?? [], ...generatedBlocks] }
+	};
+}
+function parseSlackOptionsLine(payload) {
+	const text = payload.text;
+	if (!text || payload.interactive?.blocks?.length || hasSlackBlocks(payload)) return payload;
+	const lines = text.split("\n");
+	const lastNonEmptyIndex = [...lines.keys()].toReversed().find((index) => lines[index]?.trim());
+	if (lastNonEmptyIndex == null) return payload;
+	const match = (lines[lastNonEmptyIndex] ?? "").match(SLACK_OPTIONS_LINE_RE);
+	if (!match) return payload;
+	const choices = parseSimpleSlackOptions(match[1] ?? "");
+	if (!choices) return payload;
+	const bodyText = lines.filter((_, index) => index !== lastNonEmptyIndex).join("\n").trim();
+	const generatedBlocks = [];
+	const bodyBlock = buildTextBlock(bodyText);
+	if (bodyBlock) generatedBlocks.push(bodyBlock);
+	generatedBlocks.push(choices.length <= SLACK_BUTTON_MAX_ITEMS ? {
+		type: "buttons",
+		buttons: choices
+	} : {
+		type: "select",
+		placeholder: "Choose an option",
+		options: choices
+	});
+	return {
+		...payload,
+		text: bodyText || void 0,
+		interactive: { blocks: [...payload.interactive?.blocks ?? [], ...generatedBlocks] }
+	};
+}
+//#endregion
+export { isSlackInteractiveRepliesEnabled as n, parseSlackOptionsLine as r, compileSlackInteractiveReplies as t };