@openclaw/slack 2026.7.2-beta.5 → 2026.7.2-beta.7

package/dist/actions.runtime-BIRU_G4M.js

@@ -0,0 +1,2 @@
+import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, n as downloadSlackFile, o as listSlackPins, p as resolveSlackConversationName, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-D3NuJvva.js";
+export { deleteSlackMessage, downloadSlackFile, editSlackMessage, getSlackMemberInfo, listSlackEmojis, listSlackPins, listSlackReactions, pinSlackMessage, reactSlackMessage, readSlackMessages, removeOwnSlackReactions, removeSlackReaction, resolveSlackConversationName, sendSlackMessage, unpinSlackMessage };

package/dist/api.js

@@ -1,18 +1,18 @@
 import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath, t as handleSlackHttpRequest } from "./registry-bbjH7IHX.js";
-import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, r as mergeSlackAccountConfig, t as listEnabledSlackAccounts } from "./accounts-BSr252c_.js";
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, r as mergeSlackAccountConfig, t as listEnabledSlackAccounts } from "./accounts-CHAeNZOX.js";
 import { t as resolveSlackReplyToMode } from "./account-reply-mode-DrUXogvO.js";
-import { t as inspectSlackAccount } from "./account-inspect-jn1xLaVi.js";
+import { t as inspectSlackAccount } from "./account-inspect-DEKpg9Ip.js";
 import { a as resolveSlackChannelId, i as parseSlackTarget, n as looksLikeSlackTargetId, r as normalizeSlackMessagingTarget } from "./target-parsing-N6lHogYZ.js";
 import "./targets-KmjP2E8s.js";
-import { n as buildSlackThreadingToolContext, r as resolveSlackAutoThreadId, t as slackPlugin } from "./channel-Cnrlie9S.js";
-import { R as buildSlackInteractiveBlocks, a as allowListMatches, c as normalizeSlackAllowOwnerEntry, d as resolveSlackUserAllowed, et as SLACK_MAX_BLOCKS, l as normalizeSlackSlug, n as resolveSlackGroupRequireMention, nt as validateSlackBlocksArray, o as normalizeAllowList, r as resolveSlackGroupToolPolicy, s as normalizeAllowListLower, tt as parseSlackBlocksInput, u as resolveSlackAllowListMatch, z as buildSlackPresentationBlocks } from "./group-policy-CthIXE2T.js";
-import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-CvKoWYYQ.js";
-import { c as createSlackWebClient, d as getSlackWriteClient, f as SLACK_DEFAULT_RETRY_OPTIONS, g as resolveSlackWriteClientOptions, h as resolveSlackWebClientOptions, i as clearSlackWriteClientCacheForTest, l as createSlackWriteClient, p as SLACK_WRITE_RETRY_OPTIONS, s as createSlackTokenCacheKey, t as probeSlack } from "./probe-BhQTDVBQ.js";
-import { n as resetSlackChannelTypeCacheForTest, r as resolveSlackChannelType } from "./channel-type-CPDX8EV-.js";
-import { t as slackSetupPlugin } from "./channel.setup-DyZdLwUB.js";
-import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, n as downloadSlackFile, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-BkOaiDSX.js";
-import { l as recordSlackThreadParticipation, o as clearSlackThreadParticipationCache, s as hasSlackThreadParticipation } from "./send-2IoDXPeB.js";
-import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-CeixfVuC.js";
+import { n as buildSlackThreadingToolContext, r as resolveSlackAutoThreadId, t as slackPlugin } from "./channel-B9fVdW3s.js";
+import { R as buildSlackInteractiveBlocks, a as allowListMatches, c as normalizeSlackAllowOwnerEntry, d as resolveSlackUserAllowed, it as validateSlackBlocksArray, l as normalizeSlackSlug, n as resolveSlackGroupRequireMention, nt as SLACK_MAX_BLOCKS, o as normalizeAllowList, r as resolveSlackGroupToolPolicy, rt as parseSlackBlocksInput, s as normalizeAllowListLower, u as resolveSlackAllowListMatch, z as buildSlackPresentationBlocks } from "./group-policy-NQZti9t-.js";
+import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-DkhFpMoy.js";
+import { _ as resolveSlackWriteClientOptions, c as createSlackTokenCacheKey, f as getSlackWriteClient, g as resolveSlackWebClientOptions, i as clearSlackWriteClientCacheForTest, l as createSlackWebClient, m as SLACK_WRITE_RETRY_OPTIONS, p as SLACK_DEFAULT_RETRY_OPTIONS, t as probeSlack, u as createSlackWriteClient } from "./probe-CgDsSops.js";
+import { n as resetSlackChannelTypeCacheForTest, r as resolveSlackChannelType } from "./channel-type-DXyos1d2.js";
+import { t as slackSetupPlugin } from "./channel.setup-CLP5oTvh.js";
+import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, n as downloadSlackFile, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-D3NuJvva.js";
+import { l as recordSlackThreadParticipation, o as clearSlackThreadParticipationCache, s as hasSlackThreadParticipation } from "./send-DsLeZpST.js";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-CnCIAktf.js";
 import { t as collectSlackSecurityAuditFindings } from "./security-audit-DR097212.js";
-import { n as resolveSlackRuntimeGroupPolicy } from "./provider-PSppCU_K.js";
+import { n as resolveSlackRuntimeGroupPolicy } from "./provider-DmRizMZt.js";
 export { SLACK_DEFAULT_RETRY_OPTIONS, SLACK_MAX_BLOCKS, SLACK_WRITE_RETRY_OPTIONS, resetSlackChannelTypeCacheForTest as __resetSlackChannelTypeCacheForTest, resetSlackChannelTypeCacheForTest, allowListMatches, buildSlackInteractiveBlocks, buildSlackPresentationBlocks, buildSlackThreadingToolContext, clearSlackThreadParticipationCache, clearSlackWriteClientCacheForTest, collectSlackSecurityAuditFindings, createSlackTokenCacheKey, createSlackWebClient, createSlackWriteClient, deleteSlackMessage, downloadSlackFile, editSlackMessage, extractSlackToolSend, getSlackMemberInfo, getSlackWriteClient, handleSlackHttpRequest, hasSlackThreadParticipation, inspectSlackAccount, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listSlackEmojis, listSlackMessageActions, listSlackPins, listSlackReactions, looksLikeSlackTargetId, mergeSlackAccountConfig, normalizeAllowList, normalizeAllowListLower, normalizeSlackAllowOwnerEntry, normalizeSlackMessagingTarget, normalizeSlackSlug, normalizeSlackWebhookPath, parseSlackBlocksInput, parseSlackTarget, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, recordSlackThreadParticipation, registerSlackHttpHandler, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAllowListMatch, resolveSlackAutoThreadId, resolveSlackChannelId, resolveSlackChannelType, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackReplyToMode, resolveSlackRuntimeGroupPolicy, resolveSlackUserAllowed, resolveSlackWebClientOptions, resolveSlackWriteClientOptions, sendSlackMessage, slackPlugin, slackSetupPlugin, unpinSlackMessage, validateSlackBlocksArray };

package/dist/approval-handler.runtime-BA05P0QT.js

@@ -0,0 +1,367 @@
+import { F as SLACK_EDIT_TEXT_MAX_BYTES, U as truncateSlackTextByUtf8Bytes, bt as normalizeSlackApproverId, ft as shouldHandleSlackNativeApprovalRequest, h as resolveSlackReplyBlocks, ot as isSlackAnyNativeApprovalClientEnabled } from "./group-policy-NQZti9t-.js";
+import { r as sendMessageSlack } from "./send-DsLeZpST.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
+import { buildApprovalPresentationFromActionDescriptors } from "openclaw/plugin-sdk/approval-reply-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { logError } from "openclaw/plugin-sdk/logging-core";
+import { createChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+//#region extensions/slack/src/approval-handler.runtime.ts
+const SLACK_CONTEXT_ELEMENTS_MAX = 10;
+const SLACK_TEXT_OBJECT_MAX = 3e3;
+function resolveHandlerContext(params) {
+	const context = params.context;
+	const accountId = normalizeOptionalString(params.accountId) ?? "";
+	if (!context?.app || !accountId) return null;
+	return {
+		accountId,
+		context
+	};
+}
+function truncateSlackMrkdwn(text, maxChars) {
+	const limit = Math.max(0, Math.floor(maxChars));
+	if (text.length <= limit) return text;
+	if (limit <= 1) return truncateUtf16Safe(text, limit);
+	return `${truncateUtf16Safe(text, limit - 1)}…`;
+}
+function buildSlackCodeBlock(text) {
+	let fence = "```";
+	while (text.includes(fence)) fence += "`";
+	return `${fence}\n${text}\n${fence}`;
+}
+function formatSlackApprover(resolvedBy) {
+	const normalized = resolvedBy ? normalizeSlackApproverId(resolvedBy) : void 0;
+	if (normalized) return `<@${normalized}>`;
+	const trimmed = normalizeOptionalString(resolvedBy);
+	return trimmed ? trimmed : null;
+}
+function formatSlackMetadataLine(label, value) {
+	return `*${label}:* ${value}`;
+}
+function buildSlackMetadataLines(metadata) {
+	const lines = [];
+	for (const item of metadata) lines.push(formatSlackMetadataLine(item.label, item.value));
+	return lines;
+}
+function buildSlackMetadataContextElements(metadata) {
+	const lines = buildSlackMetadataLines(metadata);
+	const visibleLineCount = lines.length > SLACK_CONTEXT_ELEMENTS_MAX ? SLACK_CONTEXT_ELEMENTS_MAX - 1 : lines.length;
+	const elements = [];
+	for (let index = 0; index < visibleLineCount; index += 1) {
+		const line = lines[index];
+		if (line === void 0) continue;
+		elements.push({
+			type: "mrkdwn",
+			text: truncateSlackMrkdwn(line, SLACK_TEXT_OBJECT_MAX)
+		});
+	}
+	if (lines.length > SLACK_CONTEXT_ELEMENTS_MAX) elements.push({
+		type: "mrkdwn",
+		text: `…+${lines.length - visibleLineCount} more`
+	});
+	return elements;
+}
+function buildSlackMetadataContextBlocks(metadata) {
+	const metadataElements = buildSlackMetadataContextElements(metadata);
+	return metadataElements.length > 0 ? [{
+		type: "context",
+		elements: metadataElements
+	}] : [];
+}
+function resolveSlackApprovalDecisionLabel(decision) {
+	return decision === "allow-once" ? "Allowed once" : decision === "allow-always" ? "Allowed always" : "Denied";
+}
+function buildSlackPluginMetadata(view) {
+	return [{
+		label: "Approval ID",
+		value: view.approvalId
+	}, ...view.metadata];
+}
+function resolveSlackPluginDescription(view) {
+	return normalizeOptionalString(view.description) ?? "A plugin action needs your approval.";
+}
+function buildSlackPluginRequestBlocks(view) {
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Request*\n${truncateSlackMrkdwn(view.title, 2600)}`
+		}
+	}, ...buildSlackMetadataContextBlocks(buildSlackPluginMetadata(view))];
+}
+function buildSlackExecPendingApprovalText(view) {
+	const metadataLines = buildSlackMetadataLines(view.metadata);
+	return [
+		"*Exec approval required*",
+		"A command needs your approval.",
+		"",
+		"*Command*",
+		buildSlackCodeBlock(view.commandText),
+		...metadataLines
+	].join("\n");
+}
+function buildSlackPluginPendingApprovalText(view) {
+	const metadataLines = buildSlackMetadataLines(buildSlackPluginMetadata(view));
+	return [
+		"*Plugin approval required*",
+		resolveSlackPluginDescription(view),
+		"",
+		"*Request*",
+		view.title,
+		...metadataLines
+	].join("\n");
+}
+function buildSlackPendingApprovalText(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginPendingApprovalText(view) : buildSlackExecPendingApprovalText(view);
+}
+function buildSlackExecPendingApprovalBlocks(view) {
+	const interactiveBlocks = resolveSlackReplyBlocks({
+		text: "",
+		presentation: buildApprovalPresentationFromActionDescriptors(view.actions)
+	}) ?? [];
+	return [
+		{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: "*Exec approval required*\nA command needs your approval."
+			}
+		},
+		{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: `*Command*\n${buildSlackCodeBlock(truncateSlackMrkdwn(view.commandText, 2600))}`
+			}
+		},
+		...buildSlackMetadataContextBlocks(view.metadata),
+		...interactiveBlocks
+	];
+}
+function buildSlackPluginPendingApprovalBlocks(view) {
+	const interactiveBlocks = resolveSlackReplyBlocks({
+		text: "",
+		presentation: buildApprovalPresentationFromActionDescriptors(view.actions)
+	}) ?? [];
+	return [
+		{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: `*Plugin approval required*\n${truncateSlackMrkdwn(resolveSlackPluginDescription(view), 2600)}`
+			}
+		},
+		...buildSlackPluginRequestBlocks(view),
+		...interactiveBlocks
+	];
+}
+function buildSlackPendingApprovalBlocks(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginPendingApprovalBlocks(view) : buildSlackExecPendingApprovalBlocks(view);
+}
+function buildSlackExecResolvedText(view) {
+	const resolvedBy = formatSlackApprover(view.resolvedBy);
+	return [
+		`*Exec approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*`,
+		resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved.",
+		"",
+		"*Command*",
+		buildSlackCodeBlock(view.commandText)
+	].join("\n");
+}
+function buildSlackPluginResolvedText(view) {
+	const resolvedBy = formatSlackApprover(view.resolvedBy);
+	const metadataLines = buildSlackMetadataLines(buildSlackPluginMetadata(view));
+	return [
+		`*Plugin approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*`,
+		resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved.",
+		"",
+		"*Request*",
+		view.title,
+		...metadataLines
+	].join("\n");
+}
+function buildSlackResolvedText(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginResolvedText(view) : buildSlackExecResolvedText(view);
+}
+function buildSlackExecResolvedBlocks(view) {
+	const resolvedBy = formatSlackApprover(view.resolvedBy);
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Exec approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*\n${resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved."}`
+		}
+	}, {
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Command*\n${buildSlackCodeBlock(truncateSlackMrkdwn(view.commandText, 2600))}`
+		}
+	}];
+}
+function buildSlackPluginResolvedBlocks(view) {
+	const resolvedBy = formatSlackApprover(view.resolvedBy);
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Plugin approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*\n${resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved."}`
+		}
+	}, ...buildSlackPluginRequestBlocks(view)];
+}
+function buildSlackResolvedBlocks(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginResolvedBlocks(view) : buildSlackExecResolvedBlocks(view);
+}
+function buildSlackExecExpiredText(view) {
+	return [
+		"*Exec approval expired*",
+		"This approval request expired before it was resolved.",
+		"",
+		"*Command*",
+		buildSlackCodeBlock(view.commandText)
+	].join("\n");
+}
+function buildSlackPluginExpiredText(view) {
+	const metadataLines = buildSlackMetadataLines(buildSlackPluginMetadata(view));
+	return [
+		"*Plugin approval expired*",
+		"This approval request expired before it was resolved.",
+		"",
+		"*Request*",
+		view.title,
+		...metadataLines
+	].join("\n");
+}
+function buildSlackExpiredText(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginExpiredText(view) : buildSlackExecExpiredText(view);
+}
+function buildSlackExecExpiredBlocks(view) {
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: "*Exec approval expired*\nThis approval request expired before it was resolved."
+		}
+	}, {
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Command*\n${buildSlackCodeBlock(truncateSlackMrkdwn(view.commandText, 2600))}`
+		}
+	}];
+}
+function buildSlackPluginExpiredBlocks(view) {
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: "*Plugin approval expired*\nThis approval request expired before it was resolved."
+		}
+	}, ...buildSlackPluginRequestBlocks(view)];
+}
+function buildSlackExpiredBlocks(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginExpiredBlocks(view) : buildSlackExecExpiredBlocks(view);
+}
+async function updateMessage(params) {
+	try {
+		await params.app.client.chat.update({
+			channel: params.channelId,
+			ts: params.messageTs,
+			text: truncateSlackTextByUtf8Bytes(params.text, SLACK_EDIT_TEXT_MAX_BYTES),
+			blocks: params.blocks
+		});
+	} catch (err) {
+		logError(`slack approvals: failed to update message: ${String(err)}`);
+	}
+}
+const slackApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+	eventKinds: ["exec", "plugin"],
+	availability: {
+		isConfigured: (params) => {
+			const resolved = resolveHandlerContext(params);
+			return resolved ? isSlackAnyNativeApprovalClientEnabled({
+				cfg: params.cfg,
+				accountId: resolved.accountId
+			}) : false;
+		},
+		shouldHandle: (params) => {
+			const resolved = resolveHandlerContext(params);
+			if (!resolved) return false;
+			return shouldHandleSlackNativeApprovalRequest({
+				cfg: params.cfg,
+				accountId: resolved.accountId,
+				approvalKind: params.approvalKind,
+				request: params.request
+			});
+		}
+	},
+	presentation: {
+		buildPendingPayload: ({ view }) => ({
+			text: buildSlackPendingApprovalText(view),
+			blocks: buildSlackPendingApprovalBlocks(view)
+		}),
+		buildResolvedResult: ({ view }) => ({
+			kind: "update",
+			payload: {
+				text: buildSlackResolvedText(view),
+				blocks: buildSlackResolvedBlocks(view)
+			}
+		}),
+		buildExpiredResult: ({ view }) => ({
+			kind: "update",
+			payload: {
+				text: buildSlackExpiredText(view),
+				blocks: buildSlackExpiredBlocks(view)
+			}
+		})
+	},
+	transport: {
+		prepareTarget: ({ plannedTarget }) => ({
+			dedupeKey: buildChannelApprovalNativeTargetKey(plannedTarget.target),
+			target: {
+				to: plannedTarget.target.to,
+				threadTs: plannedTarget.target.threadId != null ? String(plannedTarget.target.threadId) : void 0
+			}
+		}),
+		deliverPending: async ({ cfg, accountId, context, preparedTarget, pendingPayload }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return null;
+			const message = await sendMessageSlack(preparedTarget.to, pendingPayload.text, {
+				cfg,
+				accountId: resolved.accountId,
+				threadTs: preparedTarget.threadTs,
+				blocks: pendingPayload.blocks,
+				client: resolved.context.app.client
+			});
+			return {
+				channelId: message.channelId,
+				messageTs: message.messageId
+			};
+		},
+		updateEntry: async ({ cfg, accountId, context, entry, payload }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return;
+			const nextPayload = payload;
+			await updateMessage({
+				app: resolved.context.app,
+				channelId: entry.channelId,
+				messageTs: entry.messageTs,
+				text: nextPayload.text,
+				blocks: nextPayload.blocks
+			});
+		}
+	},
+	observe: { onDeliveryError: ({ error, request }) => {
+		logError(`slack approvals: failed to deliver approval ${request.id}: ${String(error)}`);
+	} }
+});
+//#endregion
+export { slackApprovalNativeRuntime };

package/dist/block-text-DkHaoGem.js

@@ -0,0 +1,79 @@
+import { N as renderSlackBlockFallbackText } from "./group-policy-NQZti9t-.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/slack/src/monitor/block-text.ts
+function readSlackBlockType(block) {
+	return block && typeof block === "object" && !Array.isArray(block) ? block.type : void 0;
+}
+function hasSlackTableBlock(blocks) {
+	return blocks?.some((block) => readSlackBlockType(block) === "table") ?? false;
+}
+function hasSlackMessageTableBlock(message) {
+	return hasSlackTableBlock(message.blocks) || message.attachments?.some((attachment) => !isSlackUnfurlAttachment(attachment) && hasSlackTableBlock(attachment.blocks)) === true;
+}
+function isSlackUnfurlAttachment(attachment) {
+	return attachment.is_msg_unfurl === true || attachment.is_app_unfurl === true || typeof attachment.app_unfurl_url === "string" && attachment.app_unfurl_url.trim().length > 0;
+}
+function resolveSlackBlocksText(blocks) {
+	if (!blocks?.length) return;
+	const parts = [];
+	let hasRichText = false;
+	let hasNativeData = false;
+	for (const block of blocks) {
+		const blockType = readSlackBlockType(block);
+		hasRichText ||= blockType === "rich_text";
+		hasNativeData ||= blockType === "data_visualization" || blockType === "data_table" || blockType === "table";
+		const text = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
+		if (text) parts.push(text);
+	}
+	return parts.length > 0 ? {
+		text: parts.join("\n"),
+		hasRichText,
+		hasNativeData
+	} : void 0;
+}
+function appendDistinctSlackText(base, addition) {
+	if (!base) return addition;
+	const comparableBase = `\n${base.replace(/\r\n?/g, "\n")}\n`;
+	const comparableAddition = `\n${addition.replace(/\r\n?/g, "\n")}\n`;
+	if (comparableBase.includes(comparableAddition)) return base;
+	return `${base}\n${addition}`;
+}
+function resolveSlackAttachmentTableTexts(attachments) {
+	const seen = /* @__PURE__ */ new Set();
+	const texts = [];
+	for (const attachment of attachments ?? []) {
+		if (isSlackUnfurlAttachment(attachment)) continue;
+		for (const block of attachment.blocks ?? []) {
+			if (readSlackBlockType(block) !== "table") continue;
+			const text = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
+			if (!text || seen.has(text)) continue;
+			seen.add(text);
+			texts.push(text);
+		}
+	}
+	return texts;
+}
+/** Resolve agent-visible Slack text while admitting only native tables from attachments. */
+function resolveSlackMessageText(message, options = {}) {
+	let resolved = chooseSlackPrimaryText({
+		messageText: options.preserveMessageTextWhitespace ? typeof message.text === "string" && message.text.trim().length > 0 ? message.text : void 0 : normalizeOptionalString(message.text),
+		blocksText: resolveSlackBlocksText(message.blocks)
+	});
+	for (const tableText of resolveSlackAttachmentTableTexts(message.attachments)) resolved = appendDistinctSlackText(resolved, tableText);
+	return resolved;
+}
+function chooseSlackPrimaryText(params) {
+	const { messageText, blocksText } = params;
+	if (!blocksText) return messageText;
+	if (!messageText) return blocksText.text;
+	if (blocksText.hasNativeData) {
+		const comparableMessageText = messageText.replace(/\s+/g, " ").trim();
+		const comparableBlocksText = blocksText.text.replace(/\s+/g, " ").trim();
+		if (comparableMessageText.includes(comparableBlocksText)) return messageText;
+		return comparableBlocksText.startsWith(comparableMessageText) ? blocksText.text : `${messageText}\n${blocksText.text}`;
+	}
+	if (blocksText.hasRichText && blocksText.text.length > messageText.length) return blocksText.text;
+	return blocksText.text.length > messageText.length && blocksText.text.startsWith(messageText) ? blocksText.text : messageText;
+}
+//#endregion
+export { resolveSlackMessageText as a, resolveSlackBlocksText as i, hasSlackTableBlock as n, isSlackUnfurlAttachment as r, hasSlackMessageTableBlock as t };