@openclaw/slack 2026.9.1-beta.1 → 2026.9.2

package/dist/{directory-live-lC6X_Ru-.js → directory-live-BuBPHmju.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { a as resolveSlackAccount } from "./accounts-Dm_H77gH.js";
-import { i as createSlackLookupClient } from "./probe-4_aHtVT3.js";
-import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
+import { s as createSlackLookupClient } from "./probe-Biy--yhL.js";
+import { n as fetchSlackChannelListPage, t as collectSlackCursorPages } from "./cursor-pages-ByFwo-Py.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/directory-live.ts
 var directory_live_exports = /* @__PURE__ */ __exportAll({
@@ -91,12 +91,7 @@ async function listSlackDirectoryGroupsLive(params) {
 	if (!client) return [];
 	const query = normalizeQuery(params.query);
 	const rows = (await collectSlackCursorPages({
-		fetchPage: (cursor) => client.conversations.list({
-			types: "public_channel,private_channel",
-			exclude_archived: false,
-			limit: 1e3,
-			cursor
-		}),
+		fetchPage: (cursor) => fetchSlackChannelListPage(client, cursor),
 		collectPageItems: (res) => Array.isArray(res.channels) ? res.channels : []
 	})).filter((channel) => {
 		const name = normalizeOptionalLowercaseString(channel.name);

package/dist/{doctor-contract-BAy7-EUQ.js → doctor-contract-BNjw9bxb.js}

@@ -171,11 +171,12 @@ function normalizeCompatibilityConfig({ cfg }) {
 		scope: "root-and-accounts",
 		onRemove: ({ key, pathPrefix }) => changes.push(`Removed retired ${pathPrefix}.${key}; Slack detects org-wide installations automatically.`)
 	});
+	const aliases = streamingAliasMigration.normalizeChannelConfig({
+		cfg: retired.config,
+		changes
+	});
 	return normalizeChannelConfigEntries({
-		cfg: streamingAliasMigration.normalizeChannelConfig({
-			cfg: retired.config,
-			changes
-		}).config,
+		cfg: aliases.config,
 		channelId: "slack",
 		changes,
 		normalizeEntry: normalizeSlackEntry

package/dist/doctor-contract-api.js

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

package/dist/{message-tool-api-CWosHSi5.js → message-tool-api-uNEfQYGY.js}

@@ -1,6 +1,6 @@
 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 { t as inspectSlackAccount } from "./account-inspect-C3sePHWa.js";
+import { r as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-CukseRVL.js";
 import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
 import { Type } from "typebox";
@@ -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");
@@ -106,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(),

package/dist/message-tool-api.js

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

package/dist/{monitor-DrNCGneD.js → monitor-DI07pfJl.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { T as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-D4nDgxCh.js";
-import { t as isSlackChannelAllowedByPolicy } from "./policy-BoP6t88v.js";
-import { o as resolveSlackThreadTs } from "./replies-D9XMM_S0.js";
+import { M as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-DoaUvAM4.js";
+import { t as isSlackChannelAllowedByPolicy } from "./policy-Bh5TOqII.js";
+import { a as resolveSlackThreadTs } from "./replies-DENuTcPO.js";
 //#region extensions/slack/src/monitor.ts
 var monitor_exports = /* @__PURE__ */ __exportAll({
 	buildSlackSlashCommandMatcher: () => buildSlackSlashCommandMatcher,

package/dist/{outbound-adapter-DkT2vUE9.js → outbound-adapter-B5QyTRpJ.js}

@@ -1,24 +1,27 @@
-import { a as parseSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import { B as SLACK_TEXT_LIMIT, I as resolveSlackAuthoredTextPlacement, ct as escapeSlackMrkdwn, dt as SLACK_PRESENTATION_CAPABILITIES, q as SLACK_QUESTION_FINALIZATION_BLOCKS, tt as resolveSlackQuestionActionIds, v as parseSlackReplyBlockSegments, x as resolveSlackReplyDeliveryMessages, y as resolveSlackReplyBlockResolution } from "./group-policy-CU1tEGpS.js";
-import { n as resolveSlackThreadTsValue } from "./thread-ts-DUGhaYKq.js";
+import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-Dm_H77gH.js";
+import { K as resolveSlackQuestionActionIds, R as SLACK_QUESTION_FINALIZATION_BLOCKS, at as escapeSlackMrkdwn, f as assertSlackDetachedTargetAllowed, k as SLACK_TEXT_LIMIT } from "./session-status-BynwcZSO.js";
+import { a as parseSlackTarget } from "./target-parsing-PbxGDbr9.js";
+import { a as resolveSlackReplyDeliveryMessages, h as SLACK_PRESENTATION_CAPABILITIES, n as parseSlackReplyBlockSegments, r as resolveSlackReplyBlockResolution, s as resolveSlackAuthoredTextPlacement } from "./reply-blocks-PRkhyAN7.js";
+import { r as resolveSlackThreadTsValue } from "./thread-ts-CukseRVL.js";
+import { t as mergeSlackSendResults } from "./send-results-eeOu_HYm.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createMessageReceiptFromOutboundResults, resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
+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 channelId === void 0 ? delivery : {
+	return attachChannelToResult("slack", channelId === void 0 ? delivery : {
 		...delivery,
 		target: {
 			kind: "channel",
 			id: channelId
 		}
-	};
+	});
 }
 const SLACK_RENDERED_PRESENTATION_PROVENANCE_KEY = randomBytes(32);
 function createSlackRenderedPresentationProvenance(resolution) {
@@ -49,7 +52,7 @@ function readSlackRenderedPresentation(slackData) {
 		return;
 	}
 }
-const loadSlackSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-DQeNKa2J.js"));
+const loadSlackSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-C8D6cKGm.js"));
 function resolveSlackSendIdentity(identity) {
 	if (!identity) return;
 	const username = normalizeOptionalString(identity.name);
@@ -97,43 +100,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", toSlackOutboundResult(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: async (ctx) => toSlackOutboundResult(await sendSlackOutboundMessage(ctx)),
-		sendMedia: async (ctx) => toSlackOutboundResult(await sendSlackOutboundMessage(ctx))
-	});
 }
 const slackOutbound = {
 	deliveryMode: "direct",
@@ -146,11 +151,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;
@@ -158,66 +171,50 @@ 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;
 		const sentResults = [];
-		return attachChannelToResult("slack", toSlackOutboundResult(await sendPayloadMediaSequenceAndFinalize({
+		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,
-						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
-					});
-					sentResults.push(lastResult);
-				}
-				if (!lastResult) throw new Error("Slack rendered presentation produced no deliverable segment");
-				if (sentResults.length === 1) return lastResult;
-				const receipt = createMessageReceiptFromOutboundResults({ results: sentResults });
-				receipt.parts = receipt.parts.map((part, index) => ({
-					...part,
-					index
+				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 } : {}
 				}));
-				const questionResult = sentResults.find((result) => result.meta?.slackQuestionActionIds.length);
-				return {
-					...lastResult,
-					receipt,
-					...questionResult?.meta ? { meta: {
-						...questionResult.meta,
-						slackQuestionMessageId: questionResult.meta.slackQuestionMessageId ?? questionResult.messageId
-					} } : {}
-				};
+				return mergeSlackSendResults(sentResults);
 			}
-		})));
+		}));
 	},
 	afterDeliverPayload: async ({ cfg, target, payload, results }) => {
 		const questionId = questionGatewayRuntime.readAskUserQuestionId(payload);
@@ -263,7 +260,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 };