@openclaw/slack 2026.7.1-beta.6 → 2026.7.2-beta.1

package/dist/{interactive-replies-CXpT-vA_.js → interactive-replies-BilWUdcI.js}

@@ -78,8 +78,11 @@ function buildSelectBlock(raw) {
 	const parts = normalizeStringEntries(raw.split("|"));
 	if (parts.length === 0) return null;
 	const [first, second] = parts;
+	if (!first || parts.length >= 2 && !second) return null;
 	const placeholder = parts.length >= 2 ? first : "Choose an option";
-	const choices = parseChoices(parts.length >= 2 ? second : first, SLACK_SELECT_MAX_ITEMS);
+	const choicesText = parts.length >= 2 ? second : first;
+	if (!choicesText) return null;
+	const choices = parseChoices(choicesText, SLACK_SELECT_MAX_ITEMS);
 	if (choices.length === 0) return null;
 	return {
 		type: "select",
@@ -134,6 +137,7 @@ function compileSlackInteractiveReplies(payload) {
 		const matchText = match[0];
 		const directiveType = match[1];
 		const body = match[2];
+		if (!directiveType || !body) continue;
 		const index = match.index ?? 0;
 		const precedingText = text.slice(cursor, index);
 		visibleTextParts.push(precedingText);

package/dist/interactive-replies-api.js

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

package/dist/{message-tool-api-BgWKyu2r.js → message-tool-api-CA9jZrCY.js}

@@ -1,6 +1,6 @@
 import { a as resolveSlackAccount, t as listEnabledSlackAccounts } from "./accounts-BOJJiHSr.js";
 import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
-import { n as isSlackInteractiveRepliesEnabled } from "./interactive-replies-CXpT-vA_.js";
+import { n as isSlackInteractiveRepliesEnabled } from "./interactive-replies-BilWUdcI.js";
 import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
 import { Type } from "typebox";

package/dist/message-tool-api.js

@@ -1,2 +1,2 @@
-import { t as describeSlackMessageTool } from "./message-tool-api-BgWKyu2r.js";
+import { t as describeSlackMessageTool } from "./message-tool-api-CA9jZrCY.js";
 export { describeSlackMessageTool as describeMessageTool };

package/dist/{monitor-Ux-wzUWI.js → monitor-BN_uuvrQ.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { S as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-C1-DFSpw.js";
-import { t as isSlackChannelAllowedByPolicy } from "./policy-Dj-puVPb.js";
-import { o as resolveSlackThreadTs } from "./replies-DpF38e1y.js";
+import { C as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-Ds-y-imP.js";
+import { t as isSlackChannelAllowedByPolicy } from "./policy-f8b0edSi.js";
+import { o as resolveSlackThreadTs } from "./replies-BMvf3ihj.js";
 //#region extensions/slack/src/monitor.ts
 var monitor_exports = /* @__PURE__ */ __exportAll({
 	buildSlackSlashCommandMatcher: () => buildSlackSlashCommandMatcher,

package/dist/outbound-adapter-ECl0go7d.js

@@ -0,0 +1,228 @@
+import { F as SLACK_TEXT_LIMIT, J as SLACK_PRESENTATION_CAPABILITIES, M as resolveSlackAuthoredTextPlacement, g as resolveSlackReplyDeliveryMessages, m as resolveSlackReplyBlockResolution, p as parseSlackReplyBlockSegments } from "./group-policy-C-b2ZnSl.js";
+import { n as resolveSlackThreadTsValue } from "./thread-ts-DUGhaYKq.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-BilWUdcI.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { normalizeMessagePresentation, resolveInteractiveTextFallback } from "openclaw/plugin-sdk/interactive-runtime";
+import { resolvePayloadMediaUrls, sendPayloadMediaSequenceAndFinalize, sendTextMediaPayload } from "openclaw/plugin-sdk/reply-payload";
+import { attachChannelToResult, createAttachedChannelResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
+//#region extensions/slack/src/outbound-adapter.ts
+const SLACK_RENDERED_PRESENTATION_PROVENANCE = Object.freeze({});
+const loadSlackSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-BkKpitPu.js"));
+function resolveSlackSendIdentity(identity) {
+	if (!identity) return;
+	const username = normalizeOptionalString(identity.name);
+	const iconUrl = normalizeOptionalString(identity.avatarUrl);
+	const rawEmoji = normalizeOptionalString(identity.emoji);
+	const iconEmoji = !iconUrl ? rawEmoji : void 0;
+	if (!username && !iconUrl && !iconEmoji) return;
+	return {
+		username,
+		iconUrl,
+		iconEmoji
+	};
+}
+function resolveSlackOutboundBlockResolution(payload) {
+	const slackData = payload.channelData?.slack;
+	const presentation = normalizeMessagePresentation(payload.presentation);
+	if (!Boolean(slackData?.blocks !== void 0 || presentation || payload.interactive?.blocks.length)) return {
+		authoredTextPlacement: resolveSlackAuthoredTextPlacement(payload),
+		segments: []
+	};
+	const { authoredTextPlacement: _authoredTextPlacement, renderedPresentationProvenance: _renderedPresentationProvenance, renderedPresentationSegments: _renderedPresentationSegments, ...preservedSlackData } = slackData ?? {};
+	return resolveSlackReplyBlockResolution({
+		...payload,
+		channelData: {
+			...payload.channelData,
+			slack: preservedSlackData
+		}
+	}, { materializeAuthoredText: true });
+}
+function withSlackRenderedPresentation(payload, slackData, resolution) {
+	const { authoredTextPlacement: _authoredTextPlacement, blocks: _blocks, renderedPresentationProvenance: _renderedPresentationProvenance, renderedPresentationSegments: _renderedPresentationSegments, ...preservedSlackData } = slackData ?? {};
+	return {
+		...payload,
+		channelData: {
+			...payload.channelData,
+			slack: {
+				...preservedSlackData,
+				authoredTextPlacement: resolution.authoredTextPlacement,
+				renderedPresentationProvenance: SLACK_RENDERED_PRESENTATION_PROVENANCE,
+				renderedPresentationSegments: resolution.segments
+			}
+		}
+	};
+}
+function readSlackAuthoredTextPlacement(value) {
+	return value === "none" || value === "blocks" || value === "outside-blocks" ? value : void 0;
+}
+async function sendSlackOutboundMessage(params) {
+	const send = resolveOutboundSendDep(params.deps, "slack") ?? (await loadSlackSendRuntime()).sendMessageSlack;
+	const slackIdentity = resolveSlackSendIdentity(params.identity);
+	const threadTs = resolveSlackThreadTsValue({
+		replyToId: params.replyToId,
+		threadId: params.threadId
+	});
+	const sendOptions = {
+		cfg: params.cfg,
+		threadTs,
+		accountId: params.accountId ?? void 0,
+		...params.mediaUrl ? {
+			mediaUrl: params.mediaUrl,
+			mediaAccess: params.mediaAccess,
+			mediaLocalRoots: params.mediaLocalRoots,
+			mediaReadFile: params.mediaReadFile
+		} : {},
+		...params.blocks ? { blocks: params.blocks } : {},
+		...params.authoredTextPlacement ? { authoredTextPlacement: params.authoredTextPlacement } : {},
+		...Object.hasOwn(params, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: params.nativeDataFallbackBaseText } : {},
+		...params.textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
+		...slackIdentity ? { identity: slackIdentity } : {},
+		...params.deliveryQueueId ? { deliveryQueueId: params.deliveryQueueId } : {},
+		...params.onPlatformSendDispatch ? { onPlatformSendDispatch: params.onPlatformSendDispatch } : {},
+		...params.onDeliveryResult ? { onDeliveryResult: async (progress) => {
+			await params.onDeliveryResult?.(attachChannelToResult("slack", progress));
+		} } : {}
+	};
+	return await send(params.to, params.text, sendOptions);
+}
+function createSlackAttachedSendAdapter() {
+	return createAttachedChannelResultAdapter({
+		channel: "slack",
+		sendText: async ({ cfg, to, text, accountId, deps, replyToId, threadId, identity, deliveryQueueId, onPlatformSendDispatch, onDeliveryResult }) => await sendSlackOutboundMessage({
+			cfg,
+			to,
+			text,
+			accountId,
+			deps,
+			replyToId,
+			threadId,
+			identity,
+			deliveryQueueId,
+			onPlatformSendDispatch,
+			onDeliveryResult
+		}),
+		sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile, accountId, deps, replyToId, threadId, identity, deliveryQueueId, onPlatformSendDispatch, onDeliveryResult }) => await sendSlackOutboundMessage({
+			cfg,
+			to,
+			text,
+			mediaUrl,
+			mediaAccess,
+			mediaLocalRoots,
+			mediaReadFile,
+			accountId,
+			deps,
+			replyToId,
+			threadId,
+			identity,
+			deliveryQueueId,
+			onPlatformSendDispatch,
+			onDeliveryResult
+		})
+	});
+}
+const slackOutbound = {
+	deliveryMode: "direct",
+	chunker: null,
+	textChunkLimit: SLACK_TEXT_LIMIT,
+	normalizePayload: ({ payload, cfg, accountId }) => isSlackInteractiveRepliesEnabled({
+		cfg,
+		accountId
+	}) ? compileSlackInteractiveReplies(payload) : payload,
+	presentationCapabilities: SLACK_PRESENTATION_CAPABILITIES,
+	renderPresentation: ({ payload, ctx }) => {
+		const payloadForBudget = isSlackInteractiveRepliesEnabled({
+			cfg: ctx.cfg,
+			accountId: ctx.accountId
+		}) ? compileSlackInteractiveReplies(payload) : payload;
+		const slackData = payload.channelData?.slack;
+		const resolution = resolveSlackOutboundBlockResolution(payloadForBudget);
+		return resolution.segments.length > 0 ? withSlackRenderedPresentation(payloadForBudget, slackData, resolution) : null;
+	},
+	sendPayload: async (ctx) => {
+		const payload = {
+			...ctx.payload,
+			text: resolveInteractiveTextFallback({
+				text: ctx.payload.text,
+				interactive: ctx.payload.interactive
+			}) ?? ""
+		};
+		const slackData = payload.channelData?.slack;
+		const hasRenderedPresentationProvenance = slackData?.renderedPresentationProvenance === SLACK_RENDERED_PRESENTATION_PROVENANCE;
+		const renderedSegments = hasRenderedPresentationProvenance ? parseSlackReplyBlockSegments(slackData?.renderedPresentationSegments) : void 0;
+		const renderedPlacement = hasRenderedPresentationProvenance ? readSlackAuthoredTextPlacement(slackData?.authoredTextPlacement) : void 0;
+		let resolution;
+		if (renderedSegments) {
+			if (!renderedPlacement) throw new Error("Slack rendered presentation is missing authored text placement");
+			resolution = {
+				authoredTextPlacement: renderedPlacement,
+				segments: renderedSegments
+			};
+		} else resolution = resolveSlackOutboundBlockResolution(payload);
+		if (resolution.segments.length === 0) return await sendTextMediaPayload({
+			channel: "slack",
+			ctx: {
+				...ctx,
+				payload
+			},
+			adapter: slackOutbound
+		});
+		const mediaUrls = resolvePayloadMediaUrls(payload);
+		const deliveryMessages = resolveSlackReplyDeliveryMessages({
+			authoredTextPlacement: resolution.authoredTextPlacement,
+			segments: resolution.segments,
+			text: payload.text
+		});
+		const useSingleDeliveryMarker = mediaUrls.length === 0 && deliveryMessages.length === 1;
+		return attachChannelToResult("slack", await sendPayloadMediaSequenceAndFinalize({
+			text: "",
+			mediaUrls,
+			send: async ({ text, mediaUrl }) => await sendSlackOutboundMessage({
+				cfg: ctx.cfg,
+				to: ctx.to,
+				text,
+				mediaUrl,
+				mediaAccess: ctx.mediaAccess,
+				mediaLocalRoots: ctx.mediaLocalRoots,
+				mediaReadFile: ctx.mediaReadFile,
+				accountId: ctx.accountId,
+				deps: ctx.deps,
+				replyToId: ctx.replyToId,
+				threadId: ctx.threadId,
+				identity: ctx.identity,
+				deliveryQueueId: useSingleDeliveryMarker ? ctx.deliveryQueueId : void 0,
+				onPlatformSendDispatch: useSingleDeliveryMarker ? ctx.onPlatformSendDispatch : void 0,
+				onDeliveryResult: ctx.onDeliveryResult
+			}),
+			finalize: async () => {
+				let lastResult;
+				for (const message of deliveryMessages) lastResult = await sendSlackOutboundMessage({
+					cfg: ctx.cfg,
+					to: ctx.to,
+					text: message.text,
+					mediaAccess: ctx.mediaAccess,
+					mediaLocalRoots: ctx.mediaLocalRoots,
+					mediaReadFile: ctx.mediaReadFile,
+					...message.blocks ? { blocks: message.blocks } : {},
+					...message.authoredTextPlacement ? { authoredTextPlacement: message.authoredTextPlacement } : {},
+					...message.nativeDataFallbackBaseText ? { nativeDataFallbackBaseText: message.nativeDataFallbackBaseText } : {},
+					...message.textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
+					accountId: ctx.accountId,
+					deps: ctx.deps,
+					replyToId: ctx.replyToId,
+					threadId: ctx.threadId,
+					identity: ctx.identity,
+					deliveryQueueId: useSingleDeliveryMarker ? ctx.deliveryQueueId : void 0,
+					onPlatformSendDispatch: useSingleDeliveryMarker ? ctx.onPlatformSendDispatch : void 0,
+					onDeliveryResult: ctx.onDeliveryResult
+				});
+				if (!lastResult) throw new Error("Slack rendered presentation produced no deliverable segment");
+				return lastResult;
+			}
+		}));
+	},
+	...createSlackAttachedSendAdapter()
+};
+//#endregion
+export { slackOutbound };