@openclaw/slack 2026.7.1 → 2026.7.2-beta.1

package/dist/{relay-source-D2jv1iGg.js → relay-source-B-6LFUdz.js}

@@ -1,4 +1,4 @@
-import { a as SLACK_SOCKET_RECONNECT_POLICY, o as formatUnknownError } from "./provider-C1-DFSpw.js";
+import { c as formatUnknownError, s as SLACK_SOCKET_RECONNECT_POLICY } from "./provider-Ds-y-imP.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { Buffer } from "node:buffer";
@@ -49,7 +49,7 @@ async function monitorSlackRelaySource(params) {
 			params.runtime.log?.(warn(`slack relay mode disconnected; reconnecting in ${Math.round(delayMs / 1e3)}s (attempt ${reconnectAttempts}) reason="${formatUnknownError(err)}"`));
 			await sleepWithAbort(delayMs, params.abortSignal);
 		} finally {
-			closeRelayWebSocket(connection?.ws);
+			closeRelayWebSocket(connection);
 			params.setIdentity?.(void 0);
 		}
 	}
@@ -58,10 +58,6 @@ function openRelayWebSocket(config, abortSignal) {
 	if (abortSignal?.aborted) return Promise.reject(/* @__PURE__ */ new Error("Slack relay websocket aborted before connect"));
 	return new Promise((resolve, reject) => {
 		const ws = new WebSocket(buildRelayWebSocketUrl(config), buildRelayWebSocketOptions(config.authToken));
-		const bufferedMessages = [];
-		const onEarlyMessage = (data) => bufferedMessages.push(data);
-		const detachBuffer = () => ws.off("message", onEarlyMessage);
-		ws.on("message", onEarlyMessage);
 		const cleanup = () => {
 			ws.off("open", onOpen);
 			ws.off("error", onError);
@@ -69,26 +65,20 @@ function openRelayWebSocket(config, abortSignal) {
 			abortSignal?.removeEventListener("abort", onAbort);
 		};
 		const onOpen = () => {
+			ws.pause();
 			cleanup();
-			resolve({
-				ws,
-				bufferedMessages,
-				detachBuffer
-			});
+			resolve(ws);
 		};
 		const onError = (error) => {
 			cleanup();
-			detachBuffer();
 			reject(error);
 		};
 		const onClose = (code, reason) => {
 			cleanup();
-			detachBuffer();
 			reject(new Error(formatRelayClose(code, reason)));
 		};
 		const onAbort = () => {
 			cleanup();
-			detachBuffer();
 			closeRelayWebSocket(ws);
 			reject(/* @__PURE__ */ new Error("Slack relay websocket aborted during connect"));
 		};
@@ -99,7 +89,7 @@ function openRelayWebSocket(config, abortSignal) {
 	});
 }
 function runRelayWebSocket(params) {
-	const { ws } = params.connection;
+	const ws = params.connection;
 	const relayState = {};
 	let pending = Promise.resolve();
 	return new Promise((resolve, reject) => {
@@ -149,12 +139,11 @@ function runRelayWebSocket(params) {
 			closeRelayWebSocket(ws);
 			settleResolve();
 		};
-		params.connection.detachBuffer();
 		ws.on("message", onMessage);
 		ws.once("error", onError);
 		ws.once("close", onClose);
 		params.abortSignal?.addEventListener("abort", onAbort, { once: true });
-		for (const message of params.connection.bufferedMessages) onMessage(message);
+		ws.resume();
 	});
 }
 async function handleRelayFrame(params) {

package/dist/replies-BMvf3ihj.js

@@ -0,0 +1,420 @@
+import { C as hasSlackNativeDataBlock, D as markdownToSlackMrkdwnChunks, F as SLACK_TEXT_LIMIT, f as hasSlackReplyStructuredContent, h as resolveSlackReplyBlocks, k as buildSlackBlocksFallbackText, m as resolveSlackReplyBlockResolution, w as isSlackInvalidBlocksError, x as buildSlackNativeDataAccessibilityText } from "./group-policy-C-b2ZnSl.js";
+import { l as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack, u as chunkSlackTextAtHardLimit } from "./send-NEfJ0GvM.js";
+import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-Ds-y-imP.js";
+import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";
+import { deliverTextOrMediaReply, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
+import { buildCanonicalSentMessageHookContext, createInternalHookEvent, fireAndForgetHook, toInternalMessageSentContext, toPluginMessageContext, toPluginMessageSentEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
+//#region extensions/slack/src/message-sent-hook.ts
+/**
+* Slack-side emission of the `message_sent` plugin hook.
+*
+* Mirrors the Telegram pattern in `extensions/telegram/src/bot/delivery.replies.ts`
+* (`buildTelegramSentHookContext`, `emitMessageSentHooks`, `emitTelegramMessageSentHooks`).
+*
+* Without this, plugins observing `message_sent` see Telegram outbound but not
+* Slack outbound — even though `docs/plugins/hooks.md` documents the hook as
+* firing for all successful outbound deliveries.
+*/
+function buildSlackSentHookContext(params) {
+	return buildCanonicalSentMessageHookContext({
+		to: params.to,
+		content: params.content,
+		success: params.success,
+		error: params.error,
+		channelId: "slack",
+		accountId: params.accountId ?? void 0,
+		conversationId: params.to,
+		sessionKey: params.sessionKeyForInternalHooks,
+		messageId: params.messageId,
+		isGroup: params.isGroup,
+		groupId: params.groupId
+	});
+}
+function emitInternalSlackMessageSentHook(params) {
+	if (!params.sessionKeyForInternalHooks) return;
+	const canonical = buildSlackSentHookContext(params);
+	fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "sent", params.sessionKeyForInternalHooks, toInternalMessageSentContext(canonical))), "slack: message:sent internal hook failed");
+}
+function emitMessageSentHooks(params) {
+	if (!params.enabled && !params.sessionKeyForInternalHooks) return;
+	const canonical = buildSlackSentHookContext(params);
+	if (params.enabled) fireAndForgetHook(Promise.resolve(params.hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical))), "slack: message_sent plugin hook failed");
+	emitInternalSlackMessageSentHook(params);
+}
+/**
+* Fire both the plugin `message_sent` hook and (if a session key is supplied)
+* the internal `message:sent` hook for a successful or failed Slack outbound
+* delivery.
+*
+* Safe to call after every `chat.postMessage` — the function self-gates on
+* `hookRunner.hasHooks("message_sent")` so plugins not observing the hook
+* incur no cost.
+*/
+function emitSlackMessageSentHooks(params) {
+	const hookRunner = getGlobalHookRunner();
+	emitMessageSentHooks({
+		...params,
+		hookRunner,
+		enabled: hookRunner?.hasHooks("message_sent") ?? false
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/replies.ts
+function readSlackReplyBlocks(payload) {
+	return resolveSlackReplyBlocks(payload);
+}
+function resolveSlackMediaHookSpokenText(payload) {
+	return (getReplyPayloadTtsSupplement(payload)?.spokenText ?? payload.spokenText)?.trim() || void 0;
+}
+function resolveDeliveredSlackReplyThreadTs(params) {
+	return (params.replyToMode === "off" ? void 0 : params.payloadReplyToId) ?? params.replyThreadTs;
+}
+async function deliverReplies(params) {
+	let latestResult;
+	const sendReply = async (input) => {
+		return await sendMessageSlack(params.target, input.text, {
+			cfg: params.cfg,
+			token: params.token,
+			threadTs: input.threadTs,
+			accountId: params.accountId,
+			...input.mediaUrl ? { mediaUrl: input.mediaUrl } : {},
+			...input.blocks ? { blocks: input.blocks } : {},
+			...input.authoredTextPlacement ? { authoredTextPlacement: input.authoredTextPlacement } : {},
+			...Object.hasOwn(input, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: input.nativeDataFallbackBaseText } : {},
+			...input.textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
+			...input.textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
+			...params.eventScope ? {
+				client: params.eventScope.client,
+				enterpriseEventScope: params.eventScope,
+				textLimit: params.textLimit,
+				...params.mediaMaxBytes !== void 0 ? { mediaMaxBytes: params.mediaMaxBytes } : {}
+			} : {},
+			...params.identity ? { identity: params.identity } : {},
+			...params.metadata ? { metadata: params.metadata } : {}
+		});
+	};
+	for (const payload of params.replies) {
+		if (payload.isReasoning === true) continue;
+		const threadTs = resolveDeliveredSlackReplyThreadTs({
+			replyToMode: params.replyToMode,
+			payloadReplyToId: payload.replyToId,
+			replyThreadTs: params.replyThreadTs
+		});
+		const reply = resolveSendableOutboundReplyParts(payload);
+		const textRaw = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
+		const { authoredTextPlacement, segments } = resolveSlackReplyBlockResolution(payload, { materializeAuthoredText: !reply.hasMedia && hasSlackReplyStructuredContent(payload) });
+		if (!textRaw && !reply.hasMedia && segments.length === 0) continue;
+		const emitSent = (content, result) => {
+			if (params.deferMessageSentHooks) return;
+			emitSlackMessageSentHooks({
+				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+				to: params.messageSentHookTarget ?? params.target,
+				accountId: params.accountId,
+				content,
+				success: true,
+				messageId: result?.messageId,
+				isGroup: params.isGroup,
+				groupId: params.groupId
+			});
+		};
+		const emitFailed = (content, error) => {
+			if (params.deferMessageSentHooks) return;
+			emitSlackMessageSentHooks({
+				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+				to: params.messageSentHookTarget ?? params.target,
+				accountId: params.accountId,
+				content,
+				success: false,
+				error: formatErrorMessage(error),
+				isGroup: params.isGroup,
+				groupId: params.groupId
+			});
+		};
+		const spokenText = resolveSlackMediaHookSpokenText(payload);
+		const hookParts = [];
+		let outsideText = authoredTextPlacement === "outside-blocks" ? textRaw ?? "" : "";
+		let lastResult;
+		let delivered = false;
+		try {
+			if (reply.hasMedia) {
+				const mediaCaption = outsideText;
+				if (mediaCaption) {
+					hookParts.push(mediaCaption);
+					outsideText = "";
+				} else if (!textRaw && spokenText) hookParts.push(spokenText);
+				const mediaDelivery = await deliverTextOrMediaReply({
+					payload,
+					text: mediaCaption,
+					sendText: async (text) => {
+						lastResult = await sendReply({
+							text,
+							threadTs
+						});
+					},
+					sendMedia: async ({ mediaUrl, caption }) => {
+						lastResult = await sendReply({
+							text: caption ?? "",
+							mediaUrl,
+							threadTs
+						});
+					}
+				});
+				delivered ||= mediaDelivery !== "empty";
+			}
+			for (const segment of segments) {
+				if (segment.kind === "text") {
+					const text = [outsideText, segment.text].filter(Boolean).join("\n\n");
+					outsideText = "";
+					if (!text) continue;
+					hookParts.push(text);
+					for (const chunk of chunkSlackTextAtHardLimit(text)) {
+						lastResult = await sendReply({
+							text: chunk,
+							threadTs,
+							textIsSlackPlainText: true
+						});
+						delivered = true;
+					}
+					continue;
+				}
+				const baseText = outsideText;
+				outsideText = "";
+				const accessibilityText = buildSlackNativeDataAccessibilityText(baseText, segment.blocks) || buildSlackBlocksFallbackText(segment.blocks);
+				hookParts.push(accessibilityText);
+				const segmentPlacement = baseText ? "outside-blocks" : authoredTextPlacement === "blocks" ? "blocks" : "none";
+				lastResult = await sendReply({
+					text: baseText,
+					threadTs,
+					blocks: segment.blocks,
+					authoredTextPlacement: segmentPlacement,
+					...baseText ? { nativeDataFallbackBaseText: baseText } : {}
+				});
+				delivered = true;
+			}
+			if (outsideText && !reply.hasMedia) {
+				hookParts.push(outsideText);
+				lastResult = await sendReply({
+					text: outsideText,
+					threadTs
+				});
+				delivered = true;
+			}
+		} catch (error) {
+			emitFailed(hookParts.join("\n\n") || textRaw || spokenText || "", error);
+			throw error;
+		}
+		if (delivered) {
+			emitSent(hookParts.join("\n\n") || textRaw || spokenText || "", reply.hasMedia ? void 0 : lastResult);
+			latestResult = lastResult;
+			params.runtime.log?.(`delivered reply to ${params.target}`);
+		}
+	}
+	return latestResult;
+}
+/**
+* Compute effective threadTs for a Slack reply based on replyToMode.
+* - "off": stay in thread if already in one, otherwise main channel
+* - "first": first reply goes to thread, subsequent replies to main channel
+* - "all": all replies go to thread
+*/
+function resolveSlackThreadTs(params) {
+	return createSlackReplyReferencePlanner({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: params.hasReplied,
+		isThreadReply: params.isThreadReply
+	}).use();
+}
+function createSlackReplyReferencePlanner(params) {
+	return createReplyReferencePlanner({
+		replyToMode: params.isThreadReply ?? Boolean(params.incomingThreadTs && params.incomingThreadTs !== params.messageTs) ? "all" : params.replyToMode,
+		existingId: params.incomingThreadTs,
+		startId: params.messageTs,
+		hasReplied: params.hasReplied
+	});
+}
+function createSlackReplyDeliveryPlan(params) {
+	const replyReference = createSlackReplyReferencePlanner({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: params.hasRepliedRef.value,
+		isThreadReply: params.isThreadReply
+	});
+	return {
+		peekThreadTs: () => replyReference.peek(),
+		nextThreadTs: () => replyReference.use(),
+		markSent: () => {
+			replyReference.markSent();
+			params.hasRepliedRef.value = replyReference.hasReplied();
+		}
+	};
+}
+async function deliverSlackSlashReplies(params) {
+	const deliveries = [];
+	const responseBudget = params.responseBudget ?? createSlackResponseUrlBudget(params.respond);
+	const chunkLimit = Math.max(1, Math.min(params.textLimit, SLACK_TEXT_LIMIT));
+	const createBlockMessagePlan = (input) => {
+		const plan = buildSlackNativeDataDeliveryPlan({
+			blocks: input.blocks,
+			baseText: input.baseText
+		});
+		return {
+			message: {
+				text: plan.accessibilityText,
+				blocks: input.blocks,
+				mrkdwn: false
+			},
+			nativeFallback: plan.fallbackMessages,
+			...plan.skipOriginalBlocks ? { skipOriginalBlocks: true } : {}
+		};
+	};
+	for (const payload of params.replies) {
+		if (payload.isReasoning === true) continue;
+		const reply = resolveSendableOutboundReplyParts(payload);
+		const textRaw = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
+		const { authoredTextPlacement, segments } = resolveSlackReplyBlockResolution(payload, { materializeAuthoredText: hasSlackReplyStructuredContent(payload) });
+		let outsideText = authoredTextPlacement === "outside-blocks" ? textRaw ?? "" : "";
+		const messages = [];
+		const hookParts = [];
+		for (const segment of segments) {
+			if (segment.kind === "text") {
+				const text = [outsideText, segment.text].filter(Boolean).join("\n\n");
+				outsideText = "";
+				if (text) {
+					hookParts.push(text);
+					messages.push(...chunkSlackTextAtHardLimit(text).map((chunk) => ({ message: {
+						text: chunk,
+						mrkdwn: false
+					} })));
+				}
+				continue;
+			}
+			const baseText = outsideText;
+			outsideText = "";
+			const accessibilityText = buildSlackNativeDataAccessibilityText(baseText, segment.blocks) || buildSlackBlocksFallbackText(segment.blocks);
+			hookParts.push(accessibilityText);
+			const blockPlan = createBlockMessagePlan({
+				blocks: segment.blocks,
+				baseText
+			});
+			messages.push(hasSlackNativeDataBlock(segment.blocks) || blockPlan.skipOriginalBlocks ? blockPlan : { message: {
+				text: accessibilityText,
+				blocks: segment.blocks,
+				mrkdwn: false
+			} });
+		}
+		if (outsideText) hookParts.push(outsideText);
+		if (reply.mediaUrls.length > 0) hookParts.push(...reply.mediaUrls);
+		if (segments.length > 0) {
+			const trailingText = [outsideText, ...reply.mediaUrls].filter(Boolean).join("\n");
+			if (trailingText) messages.push(...chunkSlackTextAtHardLimit(trailingText).map((text) => ({ message: {
+				text,
+				mrkdwn: false
+			} })));
+			if (messages.length > 0) deliveries.push({
+				hookContent: hookParts.filter(Boolean).join("\n\n"),
+				messages
+			});
+			continue;
+		}
+		const combined = [textRaw ?? "", ...reply.mediaUrls].filter(Boolean).join("\n");
+		if (!combined) continue;
+		const chunkMode = params.chunkMode ?? "length";
+		const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(combined, chunkLimit, chunkMode) : [combined]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode: params.tableMode }));
+		deliveries.push({
+			hookContent: textRaw ?? resolveSlackMediaHookSpokenText(payload) ?? combined,
+			messages: (chunks.length > 0 ? chunks : [combined]).map((text) => ({ message: { text } }))
+		});
+	}
+	if (deliveries.length === 0) return;
+	const responseType = params.ephemeral ? "ephemeral" : "in_channel";
+	const respond = async (message) => await responseBudget.respond({
+		text: message.text,
+		response_type: responseType,
+		...message.blocks ? { blocks: message.blocks } : {},
+		...message.mrkdwn === false ? { mrkdwn: false } : {}
+	});
+	const emitDeliveryFailure = (delivery, error) => {
+		if (!params.messageSentHookTarget) return;
+		emitSlackMessageSentHooks({
+			sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+			to: params.messageSentHookTarget,
+			accountId: params.accountId,
+			content: delivery.hookContent,
+			success: false,
+			error: formatErrorMessage(error),
+			isGroup: params.isGroup,
+			groupId: params.groupId
+		});
+	};
+	const minimumCalls = deliveries.flatMap((delivery) => delivery.messages).map((planned) => planned.nativeFallback?.length ?? 1);
+	const minimumRemainingCalls = Array.from({ length: minimumCalls.length + 1 }, () => 0);
+	for (let index = minimumCalls.length - 1; index >= 0; index -= 1) minimumRemainingCalls[index] = (minimumRemainingCalls[index + 1] ?? 0) + (minimumCalls[index] ?? 0);
+	const failOversizedDelivery = async () => {
+		const message = "Slack response exceeds the remaining response_url delivery budget.";
+		let failure = /* @__PURE__ */ new Error(message);
+		if (responseBudget.remaining() !== 0) try {
+			await responseBudget.respond({
+				text: "This Slack response is too large to deliver within the remaining response window.",
+				response_type: "ephemeral"
+			});
+			failure = new SlackResponseAlreadyReportedError(message);
+		} catch (error) {
+			failure = error;
+		}
+		for (const delivery of deliveries) emitDeliveryFailure(delivery, failure);
+		throw failure;
+	};
+	const initialRemaining = responseBudget.remaining();
+	const initialMinimumCalls = minimumCalls.reduce((total, calls) => total + calls, 0);
+	if (initialRemaining !== void 0 && initialMinimumCalls > initialRemaining) await failOversizedDelivery();
+	const deliverNativeFallback = async (messages) => {
+		for (const message of messages) if (isSlackInvalidBlocksError(await respond(message))) throw new Error("Slack rejected the native-data fallback blocks with invalid_blocks.");
+	};
+	let plannedIndex = 0;
+	for (const delivery of deliveries) {
+		try {
+			for (const planned of delivery.messages) {
+				const minimumAfter = minimumRemainingCalls[plannedIndex + 1] ?? 0;
+				plannedIndex += 1;
+				const fallback = planned.nativeFallback;
+				if (!fallback) {
+					await respond(planned.message);
+					continue;
+				}
+				const remaining = responseBudget.remaining();
+				if (!(!planned.skipOriginalBlocks && (remaining === void 0 || 1 + fallback.length + minimumAfter <= remaining))) {
+					await deliverNativeFallback(fallback);
+					continue;
+				}
+				let rejectedNativeBlocks = false;
+				try {
+					rejectedNativeBlocks = isSlackInvalidBlocksError(await respond(planned.message));
+				} catch (error) {
+					if (!isSlackInvalidBlocksError(error)) throw error;
+					rejectedNativeBlocks = true;
+				}
+				if (rejectedNativeBlocks) await deliverNativeFallback(fallback);
+			}
+		} catch (error) {
+			emitDeliveryFailure(delivery, error);
+			throw error;
+		}
+		if (params.messageSentHookTarget) emitSlackMessageSentHooks({
+			sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+			to: params.messageSentHookTarget,
+			accountId: params.accountId,
+			content: delivery.hookContent,
+			success: true,
+			isGroup: params.isGroup,
+			groupId: params.groupId
+		});
+	}
+}
+//#endregion
+export { resolveDeliveredSlackReplyThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, emitSlackMessageSentHooks as s, createSlackReplyDeliveryPlan as t };

package/dist/{resolve-channels-CstkChBE.js → resolve-channels-DOMgNCWb.js}

@@ -1,7 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { r as createSlackWebClient } from "./client-DGxwSL7f.js";
-import { n as resolveSlackAllowlistEntries, t as collectSlackCursorItems } from "./resolve-allowlist-common-CP8SH0Zf.js";
+import { n as createSlackLookupClient } from "./client-D2F6m8CP.js";
+import { t as collectSlackCursorPages } from "./cursor-pages-DSmTg0su.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";
 //#region extensions/slack/src/resolve-channels.ts
 var resolve_channels_exports = /* @__PURE__ */ __exportAll({ resolveSlackChannelAllowlist: () => resolveSlackChannelAllowlist });
 function parseSlackChannelMention(raw) {
@@ -18,8 +19,8 @@ function parseSlackChannelMention(raw) {
 	return name ? { name } : {};
 }
 async function listSlackChannels(client) {
-	return collectSlackCursorItems({
-		fetchPage: async (cursor) => await client.conversations.list({
+	return collectSlackCursorPages({
+		fetchPage: (cursor) => client.conversations.list({
 			types: "public_channel,private_channel",
 			exclude_archived: false,
 			limit: 1e3,
@@ -46,8 +47,18 @@ function resolveByName(name, channels) {
 	return matches.find((channel) => !channel.archived) ?? matches[0];
 }
 async function resolveSlackChannelAllowlist(params) {
-	const channels = await listSlackChannels(params.client ?? createSlackWebClient(params.token));
-	return resolveSlackAllowlistEntries({
+	const parsedEntries = params.entries.map((input) => ({
+		input,
+		parsed: parseSlackChannelMention(input)
+	}));
+	if (parsedEntries.every((entry) => Boolean(entry.parsed.id))) return parsedEntries.map(({ input, parsed }) => ({
+		input,
+		resolved: true,
+		id: parsed.id,
+		name: parsed.name
+	}));
+	const channels = await listSlackChannels(params.client ?? createSlackLookupClient(params.token));
+	return resolveDirectoryAllowlistEntries({
 		entries: params.entries,
 		lookup: channels,
 		parseInput: parseSlackChannelMention,

package/dist/{resolve-users-C3NP2c-Q.js → resolve-users-aL6-Ssee.js}

@@ -1,7 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { r as createSlackWebClient } from "./client-DGxwSL7f.js";
-import { n as resolveSlackAllowlistEntries, t as collectSlackCursorItems } from "./resolve-allowlist-common-CP8SH0Zf.js";
+import { n as createSlackLookupClient } from "./client-D2F6m8CP.js";
+import { t as collectSlackCursorPages } from "./cursor-pages-DSmTg0su.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";
 //#region extensions/slack/src/resolve-users.ts
 var resolve_users_exports = /* @__PURE__ */ __exportAll({ resolveSlackUserAllowlist: () => resolveSlackUserAllowlist });
 function parseSlackUserInput(raw) {
@@ -16,8 +17,8 @@ function parseSlackUserInput(raw) {
 	return name ? { name } : {};
 }
 async function listSlackUsers(client) {
-	return collectSlackCursorItems({
-		fetchPage: async (cursor) => await client.users.list({
+	return collectSlackCursorPages({
+		fetchPage: (cursor) => client.users.list({
 			limit: 200,
 			cursor
 		}),
@@ -59,6 +60,10 @@ function resolveSlackUserFromMatches(input, matches, parsed) {
 		user,
 		score: scoreSlackUser(user, parsed)
 	})).toSorted((a, b) => b.score - a.score)[0]?.user ?? matches[0];
+	if (!best) return {
+		input,
+		resolved: false
+	};
 	return {
 		input,
 		resolved: true,
@@ -71,8 +76,8 @@ function resolveSlackUserFromMatches(input, matches, parsed) {
 	};
 }
 async function resolveSlackUserAllowlist(params) {
-	const users = await listSlackUsers(params.client ?? createSlackWebClient(params.token));
-	return resolveSlackAllowlistEntries({
+	const users = await listSlackUsers(params.client ?? createSlackLookupClient(params.token));
+	return resolveDirectoryAllowlistEntries({
 		entries: params.entries,
 		lookup: users,
 		parseInput: parseSlackUserInput,

package/dist/{runtime-BOk7xkOl.js → runtime-CauEvswP.js}

@@ -1,6 +1,6 @@
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 //#region extensions/slack/src/runtime.ts
-const { setRuntime: setSlackRuntime, clearRuntime: clearSlackRuntime, tryGetRuntime: getOptionalSlackRuntime } = createPluginRuntimeStore({
+const { setRuntime: setSlackRuntime, tryGetRuntime: getOptionalSlackRuntime } = createPluginRuntimeStore({
 	pluginId: "slack",
 	errorMessage: "Slack runtime not initialized"
 });

package/dist/{runtime-api-CEmqYxR-.js → runtime-api-CVb6CQjX.js}

@@ -1,6 +1,6 @@
-import "./target-parsing-3jYH8LfB.js";
-import "./client-DGxwSL7f.js";
-import "./config-api-DnT9ohtE.js";
+import "./target-parsing-N6lHogYZ.js";
+import "./client-D2F6m8CP.js";
+import "./config-api-Df9a1B8C.js";
 import "openclaw/plugin-sdk/account-id";
 import { createActionGate as createActionGate$1, imageResultFromFile, jsonResult, readPositiveIntegerParam, readReactionParams, readStringParam, withNormalizedTimestamp } from "openclaw/plugin-sdk/channel-actions";
 import "openclaw/plugin-sdk/channel-status";

package/dist/runtime-api.js

@@ -1,14 +1,14 @@
 import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
 import { a as resolveSlackAccount, f as resolveSlackAppToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, p as resolveSlackBotToken, t as listEnabledSlackAccounts } from "./accounts-BOJJiHSr.js";
-import { o as resolveSlackGroupRequireMention, s as resolveSlackGroupToolPolicy } from "./reply-blocks-BGQ6zSqM.js";
-import { n as setSlackRuntime } from "./runtime-BOk7xkOl.js";
-import { r as sendMessageSlack } from "./send-DKDXoeoV.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, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-DMpDmKEA.js";
-import { t as probeSlack } from "./probe-CuwRDE5j.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-CstkChBE.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-C3NP2c-Q.js";
-import { t as monitorSlackProvider } from "./provider-C1-DFSpw.js";
-import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-DoQGk_8D.js";
-import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-BNsxCgqP.js";
-import "./monitor-Ux-wzUWI.js";
+import { n as resolveSlackGroupToolPolicy, t as resolveSlackGroupRequireMention } from "./group-policy-C-b2ZnSl.js";
+import { n as setSlackRuntime } from "./runtime-CauEvswP.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, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-DkTcWmpT.js";
+import { r as sendMessageSlack } from "./send-NEfJ0GvM.js";
+import { t as probeSlack } from "./probe-CfALk0l4.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-DOMgNCWb.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-aL6-Ssee.js";
+import { t as monitorSlackProvider } from "./provider-Ds-y-imP.js";
+import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-p6M2ULpv.js";
+import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-DX7yFsM-.js";
+import "./monitor-BN_uuvrQ.js";
 export { deleteSlackMessage, editSlackMessage, getSlackMemberInfo, handleSlackAction, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsLive, listSlackDirectoryPeersLive, listSlackEmojis, listSlackPins, listSlackReactions, monitorSlackProvider, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, registerSlackPluginHttpRoutes, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAppToken, resolveSlackBotToken, resolveSlackChannelAllowlist, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackUserAllowlist, sendMessageSlack, sendSlackMessage, setSlackRuntime, slackActionRuntime, unpinSlackMessage };

package/dist/runtime-setter-api.js

@@ -1,2 +1,2 @@
-import { n as setSlackRuntime } from "./runtime-BOk7xkOl.js";
+import { n as setSlackRuntime } from "./runtime-CauEvswP.js";
 export { setSlackRuntime };

package/dist/{scopes-DCWVD5-8.js → scopes-Dw8wbU0j.js}

@@ -1,5 +1,5 @@
-import { c as formatSlackError } from "./reply-blocks-BGQ6zSqM.js";
-import { r as createSlackWebClient } from "./client-DGxwSL7f.js";
+import { r as formatSlackError } from "./group-policy-C-b2ZnSl.js";
+import { i as createSlackWebClient } from "./client-D2F6m8CP.js";
 import { isRecord, normalizeOptionalString, normalizeStringEntries, sortUniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/scopes.ts
 function collectScopes(value, into) {