@openclaw/slack 2026.8.1-beta.2 → 2026.8.1

package/dist/{message-tool-api-BykQB4AU.js → message-tool-api-CJ0kjcg5.js}

@@ -1,5 +1,5 @@
-import { n as listSlackAccountIds } from "./accounts-CK4AVI2_.js";
-import { t as inspectSlackAccount } from "./account-inspect-Drw2gAiN.js";
+import { n as listSlackAccountIds } from "./accounts-Dm_H77gH.js";
+import { t as inspectSlackAccount } from "./account-inspect-CN2hBsim.js";
 import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
 import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
@@ -24,6 +24,7 @@ function listSlackMessageActions(cfg, accountId) {
 		actions.add("reactions");
 	}
 	if (isActionEnabled("messages")) {
+		actions.add("conversation-open");
 		actions.add("read");
 		actions.add("edit");
 		actions.add("delete");
@@ -71,8 +72,9 @@ const SLACK_MESSAGE_ID_ACTIONS = [
 function createSlackFileActionSchema() {
 	return { fileId: Type.Optional(Type.String({ description: "Slack file id, starting with \"F\" (for example F0B0LTT8M36). Required for action=\"download-file\". Read it from inbound Slack file metadata at event.files[].id. This is not the Slack message timestamp/messageId." })) };
 }
-function createSlackReactionEmojiSchema() {
-	return { emoji: Type.Optional(Type.String({ description: "Slack emoji shortcode name (for example \"white_check_mark\" or \"+1\") or common emoji character (for example \"✅\"). Colons are optional around shortcodes." })) };
+function createSlackReactionEmojiSchema(emojiListAvailable) {
+	const discoveryHint = emojiListAvailable ? " Discover workspace custom emoji with action:\"emoji-list\"." : "";
+	return { emoji: Type.Optional(Type.String({ description: "Slack standard or workspace custom emoji shortcode (for example \"white_check_mark\" or \"+1\") or common emoji character (for example \"✅\"). Colons are optional." + discoveryHint })) };
 }
 function createSlackForcedMediaSchema() {
 	const description = "Preserve original image bytes without image optimization. Slack still uploads a regular file; this does not convert it into a Slack document.";
@@ -105,6 +107,22 @@ function describeSlackMessageTool({ cfg, accountId }) {
 	const actions = listSlackMessageActions(cfg, accountId);
 	const capabilities = /* @__PURE__ */ new Set();
 	const schema = [];
+	if (actions.includes("conversation-open")) schema.push({
+		actions: ["conversation-open"],
+		visibility: "all-configured",
+		properties: {
+			userIds: Type.Optional(Type.Array(Type.String({ pattern: "^[UW][A-Z0-9]+$" }), {
+				minItems: 1,
+				maxItems: 8,
+				uniqueItems: true,
+				description: "Slack conversation-open: 1-8 other member IDs. One opens a DM; multiple open or reuse a group DM. Exclude the calling account. Use the returned target with action=\"send\"."
+			})),
+			teamId: Type.Optional(Type.String({
+				pattern: "^T[A-Z0-9]+$",
+				description: "Slack workspace for conversation-open. Defaults to the trusted current workspace for the selected account; required for detached Enterprise operations."
+			}))
+		}
+	});
 	if (actions.includes("send")) capabilities.add("presentation");
 	if (actions.includes("download-file")) schema.push({
 		properties: createSlackFileActionSchema(),
@@ -119,7 +137,7 @@ function describeSlackMessageTool({ cfg, accountId }) {
 		actions: ["upload-file"]
 	});
 	if (actions.includes("react")) schema.push({
-		properties: createSlackReactionEmojiSchema(),
+		properties: createSlackReactionEmojiSchema(actions.includes("emoji-list")),
 		actions: ["react", "reactions"]
 	});
 	const messageIdActions = [];

package/dist/message-tool-api.js

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

package/dist/{monitor-1nF1NtqT.js → monitor-Dq5Cmrvp.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { E as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-CDNvBXUi.js";
-import { t as isSlackChannelAllowedByPolicy } from "./policy-TapwbeaT.js";
-import { o as resolveSlackThreadTs } from "./replies-CeOfv82I.js";
+import { T as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-CN_8hFv2.js";
+import { t as isSlackChannelAllowedByPolicy } from "./policy-CtQVbde1.js";
+import { o as resolveSlackThreadTs } from "./replies-BSiRQOJ1.js";
 //#region extensions/slack/src/monitor.ts
 var monitor_exports = /* @__PURE__ */ __exportAll({
 	buildSlackSlashCommandMatcher: () => buildSlackSlashCommandMatcher,

package/dist/{outbound-adapter-S81tsswN.js → outbound-adapter-DYaI8ThX.js}

@@ -1,15 +1,27 @@
+import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-Dm_H77gH.js";
 import { a as parseSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import { B as SLACK_TEXT_LIMIT, I as resolveSlackAuthoredTextPlacement, at as escapeSlackMrkdwn, g as resolveSlackReplyBlockResolution, h as parseSlackReplyBlockSegments, q as SLACK_QUESTION_FINALIZATION_BLOCKS, st as SLACK_PRESENTATION_CAPABILITIES, tt as resolveSlackQuestionActionIds, v as resolveSlackReplyDeliveryMessages } from "./group-policy-c4RP9bjc.js";
+import { M as SLACK_TEXT_LIMIT, O as resolveSlackAuthoredTextPlacement, c as assertSlackDetachedTargetAllowed, d as resolveSlackReplyBlockResolution, et as escapeSlackMrkdwn, p as resolveSlackReplyDeliveryMessages, q as resolveSlackQuestionActionIds, rt as SLACK_PRESENTATION_CAPABILITIES, u as parseSlackReplyBlockSegments, z as SLACK_QUESTION_FINALIZATION_BLOCKS } from "./group-policy-BdwszjYn.js";
 import { n as resolveSlackThreadTsValue } from "./thread-ts-DUGhaYKq.js";
+import { t as mergeSlackSendResults } from "./send-results-eeOu_HYm.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, resolveLegacyInteractiveTextFallback } from "openclaw/plugin-sdk/interactive-runtime";
+import { resolvePayloadMediaUrls, sendPayloadMediaSequenceAndFinalize, sendTextMediaPayload } from "openclaw/plugin-sdk/reply-payload";
 import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
-import { resolvePayloadMediaUrls, sendPayloadMediaSequenceAndFinalize, sendTextMediaPayload } from "openclaw/plugin-sdk/reply-payload";
-import { attachChannelToResult, createAttachedChannelResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
+import { attachChannelToResult } from "openclaw/plugin-sdk/channel-send-result";
 //#region extensions/slack/src/outbound-adapter.ts
+function toSlackOutboundResult(result) {
+	const { channelId, ...delivery } = result;
+	return attachChannelToResult("slack", channelId === void 0 ? delivery : {
+		...delivery,
+		target: {
+			kind: "channel",
+			id: channelId
+		}
+	});
+}
 const SLACK_RENDERED_PRESENTATION_PROVENANCE_KEY = randomBytes(32);
 function createSlackRenderedPresentationProvenance(resolution) {
 	return createHmac("sha256", SLACK_RENDERED_PRESENTATION_PROVENANCE_KEY).update(JSON.stringify([resolution.authoredTextPlacement, resolution.segments])).digest("base64url");
@@ -39,7 +51,7 @@ function readSlackRenderedPresentation(slackData) {
 		return;
 	}
 }
-const loadSlackSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-BmgNe6S9.js"));
+const loadSlackSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-D_Bb6IuH.js"));
 function resolveSlackSendIdentity(identity) {
 	if (!identity) return;
 	const username = normalizeOptionalString(identity.name);
@@ -87,43 +99,45 @@ function withSlackRenderedPresentation(payload, slackData, resolution) {
 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
+async function prepareSlackOutboundSend(ctx) {
+	const account = resolveSlackAccount({
+		cfg: ctx.cfg,
+		accountId: ctx.accountId
 	});
-	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.forceDocument ? { forceDocument: true } : {}
-		} : {},
-		...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));
-		} } : {}
+	const target = parseSlackTarget(ctx.to, { defaultKind: "channel" });
+	assertSlackDetachedTargetAllowed(account.accountId, target?.teamId);
+	const send = resolveOutboundSendDep(ctx.deps, "slack") ?? (await loadSlackSendRuntime()).sendMessageSlack;
+	const token = resolveSlackOperationToken(account, "write");
+	const botToken = account.botToken?.trim();
+	const tokenOverride = token && token !== botToken ? token : void 0;
+	return async (params) => {
+		const slackIdentity = resolveSlackSendIdentity(params.identity);
+		const threadTs = resolveSlackThreadTsValue(params);
+		const sendOptions = {
+			cfg: params.cfg,
+			...tokenOverride ? { token: tokenOverride } : {},
+			threadTs,
+			accountId: params.accountId ?? void 0,
+			...params.mediaUrl ? {
+				mediaUrl: params.mediaUrl,
+				mediaAccess: params.mediaAccess,
+				mediaLocalRoots: params.mediaLocalRoots,
+				mediaReadFile: params.mediaReadFile,
+				...params.forceDocument ? { forceDocument: true } : {}
+			} : {},
+			...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?.(toSlackOutboundResult(progress));
+			} } : {}
+		};
+		return await send(params.to, params.text, sendOptions);
 	};
-	return await send(params.to, params.text, sendOptions);
-}
-function createSlackAttachedSendAdapter() {
-	return createAttachedChannelResultAdapter({
-		channel: "slack",
-		sendText: sendSlackOutboundMessage,
-		sendMedia: sendSlackOutboundMessage
-	});
 }
 const slackOutbound = {
 	deliveryMode: "direct",
@@ -136,11 +150,19 @@ const slackOutbound = {
 		return resolution.segments.length > 0 ? withSlackRenderedPresentation(payload, slackData, resolution) : null;
 	},
 	sendPayload: async (ctx) => {
+		const send = await prepareSlackOutboundSend(ctx);
+		const { mediaUrl: _mediaUrl, ...commonCtx } = ctx;
+		const preparedCtx = {
+			...commonCtx,
+			replyToId: resolveSlackThreadTsValue(ctx),
+			threadId: null,
+			deliveryQueueId: void 0
+		};
 		const payload = {
-			...ctx.payload,
+			...preparedCtx.payload,
 			text: resolveLegacyInteractiveTextFallback({
-				text: ctx.payload.text,
-				interactive: ctx.payload.interactive
+				text: preparedCtx.payload.text,
+				interactive: preparedCtx.payload.interactive
 			}) ?? ""
 		};
 		const slackData = payload.channelData?.slack;
@@ -148,43 +170,48 @@ const slackOutbound = {
 		let resolution;
 		if (renderedResolution) resolution = renderedResolution;
 		else resolution = resolveSlackOutboundBlockResolution(payload);
-		if (resolution.segments.length === 0) return await sendTextMediaPayload({
-			channel: "slack",
-			ctx: {
-				...ctx,
-				payload
-			},
-			adapter: slackOutbound
-		});
+		if (resolution.segments.length === 0) {
+			const sendPart = async (part) => toSlackOutboundResult(await send(part));
+			return await sendTextMediaPayload({
+				channel: "slack",
+				ctx: {
+					...preparedCtx,
+					payload
+				},
+				adapter: {
+					sendText: sendPart,
+					sendMedia: sendPart
+				}
+			});
+		}
 		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({
+		const sentResults = [];
+		return toSlackOutboundResult(await sendPayloadMediaSequenceAndFinalize({
 			text: "",
 			mediaUrls,
-			send: async ({ text, mediaUrl }) => await sendSlackOutboundMessage({
-				...ctx,
+			send: async ({ text, mediaUrl }) => await send({
+				...preparedCtx,
 				text,
-				mediaUrl,
-				deliveryQueueId: useSingleDeliveryMarker ? ctx.deliveryQueueId : void 0
+				mediaUrl
 			}),
+			onResult: (result) => {
+				sentResults.push(result);
+			},
 			finalize: async () => {
-				let lastResult;
-				for (const message of deliveryMessages) lastResult = await sendSlackOutboundMessage({
-					...ctx,
+				for (const message of deliveryMessages) sentResults.push(await send({
+					...preparedCtx,
 					text: message.text,
 					...message.blocks ? { blocks: message.blocks } : {},
 					...message.authoredTextPlacement ? { authoredTextPlacement: message.authoredTextPlacement } : {},
 					...message.nativeDataFallbackBaseText ? { nativeDataFallbackBaseText: message.nativeDataFallbackBaseText } : {},
-					...message.textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
-					deliveryQueueId: useSingleDeliveryMarker ? ctx.deliveryQueueId : void 0
-				});
-				if (!lastResult) throw new Error("Slack rendered presentation produced no deliverable segment");
-				return lastResult;
+					...message.textIsSlackPlainText ? { textIsSlackPlainText: true } : {}
+				}));
+				return mergeSlackSendResults(sentResults);
 			}
 		}));
 	},
@@ -203,7 +230,7 @@ const slackOutbound = {
 		const result = results.find(({ channel, meta }) => channel === "slack" && Array.isArray(meta?.slackQuestionActionIds) && meta.slackQuestionActionIds.some((actionId) => typeof actionId === "string" && questionActionIds.includes(actionId)));
 		const deliveredDisplayBlocks = (result?.meta)?.[SLACK_QUESTION_FINALIZATION_BLOCKS];
 		if (!deliveryMessage || !deliveredDisplayBlocks || !result?.messageId) return;
-		const channelId = result.channelId;
+		const channelId = result.target?.kind === "channel" ? result.target.id : void 0;
 		if (!channelId) return;
 		const teamId = parseSlackTarget(target.to, { defaultKind: "channel" })?.teamId;
 		const questionMessageId = typeof result.meta?.slackQuestionMessageId === "string" ? result.meta.slackQuestionMessageId : result.messageId;
@@ -232,7 +259,15 @@ const slackOutbound = {
 			}
 		});
 	},
-	...createSlackAttachedSendAdapter()
+	sendText: async (ctx) => {
+		return toSlackOutboundResult(await (await prepareSlackOutboundSend(ctx))(ctx));
+	},
+	sendMedia: async (ctx) => {
+		return toSlackOutboundResult(await (await prepareSlackOutboundSend(ctx))({
+			...ctx,
+			deliveryQueueId: void 0
+		}));
+	}
 };
 //#endregion
 export { slackOutbound };