@openclaw/slack 2026.8.1-beta.3 → 2026.9.1-beta.1

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

@@ -1,5 +1,5 @@
-import { n as listSlackAccountIds } from "./accounts-BlzxuYle.js";
-import { t as inspectSlackAccount } from "./account-inspect-YJvFBbCR.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";
@@ -71,8 +71,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.";
@@ -119,7 +120,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-CqMr5Rmc.js";
+import { t as describeSlackMessageTool } from "./message-tool-api-CWosHSi5.js";
 export { describeSlackMessageTool as describeMessageTool };

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

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { C as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-CUUiwsg2.js";
-import { t as isSlackChannelAllowedByPolicy } from "./policy-BKXSxrIS.js";
-import { o as resolveSlackThreadTs } from "./replies-SnWyXcsL.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";
 //#region extensions/slack/src/monitor.ts
 var monitor_exports = /* @__PURE__ */ __exportAll({
 	buildSlackSlashCommandMatcher: () => buildSlackSlashCommandMatcher,

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

@@ -1,8 +1,8 @@
 import { a as parseSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import { U as SLACK_TEXT_LIMIT, X as SLACK_QUESTION_FINALIZATION_BLOCKS, ct as escapeSlackMrkdwn, dt as SLACK_PRESENTATION_CAPABILITIES, it as resolveSlackQuestionActionIds, v as parseSlackReplyBlockSegments, x as resolveSlackReplyDeliveryMessages, y as resolveSlackReplyBlockResolution, z as resolveSlackAuthoredTextPlacement } from "./group-policy-DyfB_ZIE.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 { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
+import { createMessageReceiptFromOutboundResults, 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 { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
@@ -49,7 +49,7 @@ function readSlackRenderedPresentation(slackData) {
 		return;
 	}
 }
-const loadSlackSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-kYctMHSd.js"));
+const loadSlackSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-DQeNKa2J.js"));
 function resolveSlackSendIdentity(identity) {
 	if (!identity) return;
 	const username = normalizeOptionalString(identity.name);
@@ -173,6 +173,7 @@ const slackOutbound = {
 			text: payload.text
 		});
 		const useSingleDeliveryMarker = mediaUrls.length === 0 && deliveryMessages.length === 1;
+		const sentResults = [];
 		return attachChannelToResult("slack", toSlackOutboundResult(await sendPayloadMediaSequenceAndFinalize({
 			text: "",
 			mediaUrls,
@@ -182,19 +183,39 @@ const slackOutbound = {
 				mediaUrl,
 				deliveryQueueId: useSingleDeliveryMarker ? ctx.deliveryQueueId : void 0
 			}),
+			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
-				});
+				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");
-				return lastResult;
+				if (sentResults.length === 1) return lastResult;
+				const receipt = createMessageReceiptFromOutboundResults({ results: sentResults });
+				receipt.parts = receipt.parts.map((part, index) => ({
+					...part,
+					index
+				}));
+				const questionResult = sentResults.find((result) => result.meta?.slackQuestionActionIds.length);
+				return {
+					...lastResult,
+					receipt,
+					...questionResult?.meta ? { meta: {
+						...questionResult.meta,
+						slackQuestionMessageId: questionResult.meta.slackQuestionMessageId ?? questionResult.messageId
+					} } : {}
+				};
 			}
 		})));
 	},

package/dist/{pipeline.runtime-Bbfd5VFW.js → pipeline.runtime-CRRng_Nw.js}

@@ -1,19 +1,20 @@
 import { n as resolveSlackConversationBindingRoute, r as resolveSlackReplyToMode, t as normalizeSlackRouteBindingConfig } from "./conversation-binding-route-DFVLUdYF.js";
 import { n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import { B as SLACK_EDIT_TEXT_MAX_BYTES, F as normalizeSlackOutboundText, I as buildSlackBlocksFallbackText, J as truncateSlackText, O as hasSlackNativeDataBlock, S as resolveSlackReplyRenderPlan, U as SLACK_TEXT_LIMIT, Y as truncateSlackTextByUtf8Bytes, a as qualifySlackConversationId, ct as escapeSlackMrkdwn, d as normalizeSlackAllowOwnerEntry, et as SLACK_SESSION_LINK_ACTION_ID, o as qualifySlackRoutePeerId, p as resolveSlackAllowListMatch, q as countSlackTextUtf8Bytes, s as resolveSlackEnterpriseMainDmSessionKey, u as normalizeAllowListLower } from "./group-policy-DyfB_ZIE.js";
-import { r as formatSlackError } from "./probe-BVA65leh.js";
+import { B as SLACK_TEXT_LIMIT, G as truncateSlackText, K as truncateSlackTextByUtf8Bytes, L as SLACK_EDIT_TEXT_MAX_BYTES, N as buildSlackBlocksFallbackText, O as hasSlackNativeDataBlock, S as resolveSlackReplyRenderPlan, W as countSlackTextUtf8Bytes, Z as SLACK_SESSION_LINK_ACTION_ID, a as qualifySlackConversationId, ct as escapeSlackMrkdwn, d as normalizeSlackAllowOwnerEntry, o as qualifySlackRoutePeerId, ot as normalizeSlackOutboundText, p as resolveSlackAllowListMatch, s as resolveSlackEnterpriseMainDmSessionKey, u as normalizeAllowListLower } from "./group-policy-CU1tEGpS.js";
+import { r as formatSlackError } from "./probe-4_aHtVT3.js";
 import { n as resolveSlackStreamingMode, t as resolveSlackNativeStreaming } from "./streaming-compat-B-e0mqM0.js";
-import { b as formatSlackFileReferenceList, i as editSlackRenderedMessage, p as removeSlackReaction, r as editSlackMessage, t as deleteSlackMessage, u as reactSlackMessage, v as logVerbose$1, x as buildSlackEditTextPayload, y as formatSlackFileReference } from "./actions-DFk0ANVB.js";
-import { a as hasSlackTableBlock, c as resolveSlackMessageText$1, o as isSlackUnfurlAttachment, s as resolveSlackBlocksText } from "./slack-client-kind-BXyOOICI.js";
-import { c as hasSlackThreadFailureNotice, d as recordSlackThreadFailureNotice, f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, m as buildSlackNativeDataDeliveryPlan, o as clearSlackThreadFailureNotice, r as sendMessageSlack, u as hasSlackThreadParticipationWithPersistence } from "./send-CtnOxKCc.js";
-import { S as updateLastRoute, _ as parseSlackAssistantThreadMetadata, b as resolveChannelResetConfig, c as resolveConversationLabel$1, d as resolveSlackEffectiveAllowFrom, g as buildSlackAssistantThreadMetadata, h as resolveSlackChatType, l as authorizeSlackBotRoomMessage, m as normalizeSlackChannelType, o as authorizeSlackDirectMessage, r as resolveSlackRoomContextHints, s as trackSlackDraftMessage, u as resolveSlackCommandIngress, v as readSessionUpdatedAt, w as stripSlackMentionsForCommandDetection, x as resolveStorePath, y as resolveChannelContextVisibilityMode } from "./provider-CUUiwsg2.js";
-import { n as resolveSlackChannelConfig } from "./policy-BKXSxrIS.js";
-import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-SnWyXcsL.js";
+import { a as editSlackRenderedMessage, b as formatSlackFileReferenceList, d as reactSlackMessage, i as editSlackMessage, m as removeSlackReaction, n as deleteSlackMessage, v as logVerbose$1, x as buildSlackEditTextPayload, y as formatSlackFileReference } from "./actions-XdQyjG_p.js";
+import { a as hasSlackTableBlock, c as resolveSlackMessageText$1, o as isSlackUnfurlAttachment, s as resolveSlackBlocksText } from "./slack-client-kind-hSfjXyUM.js";
+import { c as hasSlackThreadFailureNotice, d as recordSlackThreadFailureNotice, f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, m as buildSlackNativeDataDeliveryPlan, o as clearSlackThreadFailureNotice, r as sendMessageSlack, u as hasSlackThreadParticipationWithPersistence } from "./send-DtjEnlLh.js";
+import { C as resolveStorePath, E as stripSlackMentionsForCommandDetection, S as resolveChannelResetConfig, _ as resolveSlackChatType, b as readSessionUpdatedAt, c as resolveSlackThreadTargets, d as authorizeSlackBotRoomMessage, f as resolveSlackCommandIngress, g as normalizeSlackChannelType, l as trackSlackDraftMessage, o as authorizeSlackDirectMessage, p as resolveSlackEffectiveAllowFrom, r as resolveSlackRoomContextHints, s as resolveSlackThreadContext, u as resolveConversationLabel$1, v as buildSlackAssistantThreadMetadata, w as updateLastRoute, x as resolveChannelContextVisibilityMode, y as parseSlackAssistantThreadMetadata } from "./provider-D4nDgxCh.js";
+import { n as resolveSlackChannelConfig } from "./policy-BoP6t88v.js";
+import { a as resolveDeliveredSlackReplyThreadTs, c as emitSlackMessageSentHooks, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as sanitizeSlackMonitorReplyPayload, t as createSlackReplyDeliveryPlan } from "./replies-D9XMM_S0.js";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
 import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createChannelProgressWorkCounter, createFinalizableDraftStreamControlsForState, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, formatPlanChecklistLines, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { danger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash } from "node:crypto";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
@@ -384,12 +385,12 @@ function createSlackDraftStream(params) {
 	const send = params.send ?? sendMessageSlack;
 	const edit = params.edit ?? editSlackMessage;
 	const remove = params.remove ?? deleteSlackMessage;
-	let streamMessageId;
-	let streamChannelId;
+	let streamMessage;
 	let untrackConversationBoundary;
 	let lastVisibleUpdate;
 	let lastSentKey = "";
-	const detachedMessages = [];
+	const pendingCleanupMessages = [];
+	let cleanupTail = Promise.resolve();
 	const finalizedMessageIds = /* @__PURE__ */ new Set();
 	const streamState = {
 		stopped: false,
@@ -411,8 +412,8 @@ function createSlackDraftStream(params) {
 		if (sentKey === lastSentKey) return;
 		lastSentKey = sentKey;
 		try {
-			if (streamChannelId && streamMessageId) {
-				await edit(streamChannelId, streamMessageId, trimmed, {
+			if (streamMessage) {
+				await edit(streamMessage.channelId, streamMessage.messageId, trimmed, {
 					cfg: params.cfg,
 					token: params.token,
 					accountId: params.accountId,
@@ -444,27 +445,29 @@ function createSlackDraftStream(params) {
 				...params.metadata ? { metadata: params.metadata } : {},
 				...blocks ? { blocks } : {}
 			});
-			streamChannelId = sent.channelId || streamChannelId;
-			streamMessageId = sent.messageId || streamMessageId;
-			if (!streamChannelId || !streamMessageId) {
+			if (!sent.channelId || !sent.messageId) {
 				stopTrackingConversationBoundary();
 				streamState.stopped = true;
 				params.warn?.("slack stream preview stopped (missing identifiers from sendMessage)");
 				return;
 			}
+			streamMessage = {
+				channelId: sent.channelId,
+				messageId: sent.messageId
+			};
 			lastVisibleUpdate = {
 				text: trimmed,
 				...blocks ? { blocks } : {}
 			};
-			if (pendingBoundary && params.conversationChannelId === streamChannelId) pendingBoundary.setMessageTs(streamMessageId);
+			if (pendingBoundary && params.conversationChannelId === streamMessage.channelId) pendingBoundary.setMessageTs(streamMessage.messageId);
 			else {
 				stopTrackingConversationBoundary();
 				untrackConversationBoundary = trackSlackDraftMessage({
 					accountId: params.accountId,
 					teamId: params.eventScope?.teamId,
-					channelId: streamChannelId,
+					channelId: streamMessage.channelId,
 					threadTs,
-					messageTs: streamMessageId,
+					messageTs: streamMessage.messageId,
 					onInterveningMessage: forceNewMessage
 				}).stop;
 			}
@@ -485,60 +488,58 @@ function createSlackDraftStream(params) {
 		untrackConversationBoundary?.();
 		untrackConversationBoundary = void 0;
 	};
-	const removeMessage = async (channelId, messageId) => {
-		try {
-			await remove(channelId, messageId, {
-				token: params.token,
-				accountId: params.accountId,
-				...params.eventScope ? { client: params.eventScope.client } : {}
-			});
-		} catch (err) {
-			params.warn?.(`slack stream preview cleanup failed: ${formatSlackError(err)}`);
-		}
+	const dropDetachedMessages = () => {
+		cleanupTail = cleanupTail.then(async () => {
+			for (let index = 0; index < pendingCleanupMessages.length;) {
+				const message = pendingCleanupMessages[index];
+				if (!message) return;
+				try {
+					await remove(message.channelId, message.messageId, {
+						token: params.token,
+						accountId: params.accountId,
+						...params.eventScope ? { client: params.eventScope.client } : {}
+					});
+					pendingCleanupMessages.splice(index, 1);
+				} catch (err) {
+					params.warn?.(`slack stream preview cleanup failed: ${formatSlackError(err)}`);
+					index += 1;
+				}
+			}
+		});
+		return cleanupTail;
 	};
 	const clear = async () => {
 		stopTrackingConversationBoundary();
 		await discardPending();
-		const channelId = streamChannelId;
-		const messageId = streamMessageId;
-		streamChannelId = void 0;
-		streamMessageId = void 0;
+		if (streamMessage) {
+			pendingCleanupMessages.push(streamMessage);
+			streamMessage = void 0;
+		}
 		lastVisibleUpdate = void 0;
 		lastSentKey = "";
-		if (!channelId || !messageId) return;
-		await removeMessage(channelId, messageId);
+		await dropDetachedMessages();
 	};
 	const forceNewMessage = () => {
 		stopTrackingConversationBoundary();
 		streamState.stopped = false;
 		streamState.final = false;
-		if (streamChannelId && streamMessageId && !finalizedMessageIds.has(streamMessageId)) detachedMessages.push({
-			channelId: streamChannelId,
-			messageId: streamMessageId
-		});
-		streamMessageId = void 0;
-		streamChannelId = void 0;
+		if (streamMessage && !finalizedMessageIds.has(streamMessage.messageId)) pendingCleanupMessages.push(streamMessage);
+		streamMessage = void 0;
 		lastVisibleUpdate = void 0;
 		lastSentKey = "";
 		loop.resetPending();
 	};
-	const dropDetachedMessages = async () => {
-		let message;
-		while ((message = detachedMessages.shift()) !== void 0) {
-			const { channelId, messageId } = message;
-			await removeMessage(channelId, messageId);
-		}
-	};
 	const discardPendingAndStopTracking = async () => {
 		stopTrackingConversationBoundary();
 		await discardPending();
 	};
 	const finalizeMessage = async (messageId, editFinal) => {
-		const channelId = streamChannelId;
+		const currentMessage = streamMessage;
 		const previousUpdate = lastVisibleUpdate;
-		if (!channelId || streamMessageId !== messageId || !previousUpdate) return false;
+		if (!currentMessage || currentMessage.messageId !== messageId || !previousUpdate) return false;
+		const { channelId } = currentMessage;
 		await editFinal();
-		if (streamChannelId === channelId && streamMessageId === messageId) {
+		if (streamMessage?.channelId === channelId && streamMessage.messageId === messageId) {
 			finalizedMessageIds.add(messageId);
 			stopTrackingConversationBoundary();
 			return true;
@@ -566,8 +567,8 @@ function createSlackDraftStream(params) {
 		forceNewMessage,
 		dropDetachedMessages,
 		finalizeMessage,
-		messageId: () => streamMessageId,
-		channelId: () => streamChannelId
+		messageId: () => streamMessage?.messageId,
+		channelId: () => streamMessage?.channelId
 	};
 }
 //#endregion
@@ -1336,7 +1337,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		log: logVerbose,
 		warn: logVerbose
 	}) : void 0;
-	let hasStreamedMessage = false;
+	let hasStreamedAnswer = false;
 	const isProgressMode = slackStreaming.mode === "progress";
 	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
 	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
@@ -1513,7 +1514,6 @@ function createSlackProgressRuntime(runtimeParams) {
 				text: previewText,
 				blocks: progressCard.resolvePresentation(snapshot, "working")
 			} : previewText);
-			hasStreamedMessage = true;
 			if (options?.flush) await draftStream.flush();
 			return Boolean(draftStream.messageId() && draftStream.channelId());
 		}
@@ -1595,10 +1595,7 @@ function createSlackProgressRuntime(runtimeParams) {
 			narration: explanation,
 			plan: steps
 		});
-		if (text) {
-			draftStream.update(text);
-			hasStreamedMessage = true;
-		}
+		if (text) draftStream.update(text);
 		return false;
 	};
 	const pushPreviewProgress = async (line, options) => {
@@ -1613,7 +1610,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		return await progressDraft.pushToolProgress(line, options);
 	};
 	const updateDraftFromPartial = (text) => {
-		const trimmed = text?.trimEnd();
+		const trimmed = text && sanitizeAssistantVisibleText(text).trimEnd();
 		if (!trimmed) return false;
 		if (slackStreaming.mode === "block") {
 			previewToolProgressSuppressed = true;
@@ -1627,14 +1624,14 @@ function createSlackProgressRuntime(runtimeParams) {
 			appendSourceText = next.source;
 			if (!next.changed) return false;
 			draftStream?.update(next.rendered);
-			hasStreamedMessage = true;
+			hasStreamedAnswer = true;
 			return false;
 		}
 		if (isProgressMode) return false;
 		previewToolProgressSuppressed = true;
 		progressDraft.suppress();
 		draftStream?.update(trimmed);
-		hasStreamedMessage = true;
+		hasStreamedAnswer = true;
 		return false;
 	};
 	const pushReasoningProgress = async (payload) => {
@@ -1654,7 +1651,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		return await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
 	};
 	const resetDraftDeliveryState = () => {
-		hasStreamedMessage = false;
+		hasStreamedAnswer = false;
 		appendRenderedText = "";
 		appendSourceText = "";
 	};
@@ -1687,7 +1684,7 @@ function createSlackProgressRuntime(runtimeParams) {
 			await beginNewProgressTurn();
 			return;
 		}
-		if (hasStreamedMessage) draftStream?.forceNewMessage();
+		if (hasStreamedAnswer) draftStream?.forceNewMessage();
 		resetDraftDeliveryState();
 		resetDraftProgressState();
 	};
@@ -1742,41 +1739,6 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 }
 //#endregion
-//#region extensions/slack/src/threading.ts
-function resolveSlackThreadContext(params) {
-	const incomingThreadTs = params.message.thread_ts;
-	const eventTs = params.message.event_ts;
-	const messageTs = params.message.ts ?? eventTs;
-	const hasThreadTs = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0;
-	const isThreadReply = hasThreadTs && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
-	const replyToId = isThreadReply ? incomingThreadTs : void 0;
-	const isAssistantDmThreadRoot = hasThreadTs && !isThreadReply && params.isDirectMessage === true;
-	return {
-		incomingThreadTs,
-		messageTs,
-		isThreadReply,
-		replyToId,
-		messageThreadId: isThreadReply || isAssistantDmThreadRoot ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0
-	};
-}
-/**
-* Resolves Slack thread targeting for replies and status indicators.
-*
-* @returns replyThreadTs - Thread timestamp for reply messages
-* @returns statusThreadTs - Thread timestamp for status indicators (typing, etc.)
-* @returns isThreadReply - true if this is a genuine user reply in a thread,
-*                          false if thread_ts comes from a bot status message (e.g. typing indicator)
-*/
-function resolveSlackThreadTargets(params) {
-	const { incomingThreadTs, messageTs, isThreadReply } = resolveSlackThreadContext(params);
-	const replyThreadTs = isThreadReply ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0;
-	return {
-		replyThreadTs,
-		statusThreadTs: replyThreadTs,
-		isThreadReply
-	};
-}
-//#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-setup.ts
 async function createSlackDispatchSetup(prepared) {
 	const { ctx, account, message, route } = prepared;
@@ -1898,10 +1860,7 @@ async function createSlackDispatchSetup(prepared) {
 		agentId: route.agentId,
 		channel: "slack",
 		accountId: route.accountId,
-		transformReplyPayload: (payload) => {
-			if (payload.isReasoning === true) return null;
-			return payload;
-		},
+		transformReplyPayload: sanitizeSlackMonitorReplyPayload,
 		typing: {
 			start: async () => {
 				if (!threadStatusGate.hasVisibleOutput()) {
@@ -2187,7 +2146,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		}
 	};
 	const deliverNormally = async (params) => {
-		if (params.payload.isReasoning === true) return;
 		const replyThreadTs = resolveDeliveryThreadTs(params);
 		const deliveryReplyThreadTs = replyDeliveryMode === "off" && !forcedReplyThreadTs && !isThreadReply ? void 0 : replyThreadTs;
 		if (deliveryTracker.hasDelivered({
@@ -2250,7 +2208,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		return !state.streamFailed && !reply.hasMedia && renderPlan.mode !== "split" && !plannedBlocks?.length && !readSlackReplyBlocks(payload)?.length && reply.hasText && (!options?.maxTextBytes || countSlackTextUtf8Bytes(reply.trimmedText) <= options.maxTextBytes);
 	};
 	const deliverWithStreaming = async (params) => {
-		if (params.payload.isReasoning === true) return;
 		const reply = resolveSendableOutboundReplyParts(params.payload);
 		if (!isStreamingEligible(params.payload)) {
 			await deliverNormally({
@@ -2452,7 +2409,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 		return payload;
 	};
 	const deliverSlackPayload = async (payload, info) => {
-		if (payload.isReasoning === true) return { visibleReplySent: false };
 		if (info.kind === "final" && slackStreaming.mode === "progress" && progress.isProgressMode) {
 			if (progress.useNativeProgressStreaming) {
 				await progress.deliverNativeFinal(payload, info.kind);
@@ -2619,6 +2575,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				sessionKey: route.sessionKey
 			},
 			ctxPayload: prepared.ctxPayload,
+			dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
 			dispatcherOptions: {
 				...replyPipeline,
 				transformReplyPayload: (payload) => {
@@ -3008,7 +2965,7 @@ async function discardSlackPreflightMedia(media) {
 const SLACK_MENTION_RESOLUTION_CONCURRENCY = 4;
 const SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE = 20;
 const SLACK_USER_MENTION_RE$1 = /<@([A-Z0-9]+)(?:\|[^>]+)?>/gi;
-const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-DFk0ANVB.js").then((n) => n._));
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-XdQyjG_p.js").then((n) => n._));
 function collectUniqueSlackMentionIds$1(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	const mentionIds = [];
@@ -3046,8 +3003,9 @@ async function resolveSlackMessageContent(params) {
 		isThreadReply: params.isThreadReply,
 		threadStarter: params.threadStarter
 	});
-	const mediaPromise = ownFiles && ownFiles.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackMedia }) => resolveSlackMedia({
+	const attachmentContent = ownFiles?.length || params.message.attachments?.length ? await loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
 		files: ownFiles,
+		attachments: params.message.attachments,
 		client: params.client,
 		token: params.botToken,
 		maxBytes: params.mediaMaxBytes,
@@ -3055,30 +3013,10 @@ async function resolveSlackMessageContent(params) {
 		totalTimeoutMs: params.mediaTotalTimeoutMs,
 		abortSignal: params.abortSignal,
 		preloadedMedia: params.preloadedMedia
-	})) : Promise.resolve(null);
-	const attachmentContentPromise = params.message.attachments && params.message.attachments.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
-		attachments: params.message.attachments,
-		client: params.client,
-		token: params.botToken,
-		maxBytes: params.mediaMaxBytes,
-		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
-		totalTimeoutMs: params.mediaTotalTimeoutMs,
-		abortSignal: params.abortSignal
-	})) : Promise.resolve(null);
-	const [media, attachmentContent] = await Promise.all([mediaPromise, attachmentContentPromise]);
-	const mergedMedia = [...media ?? [], ...attachmentContent?.media ?? []];
-	const effectiveDirectMedia = mergedMedia.length > 0 ? mergedMedia : null;
-	const mediaPlaceholder = effectiveDirectMedia ? effectiveDirectMedia.map((item) => item.placeholder).join(" ") : void 0;
-	const fallbackFileIds = /* @__PURE__ */ new Set();
-	const fallbackFiles = [...ownFiles ?? [], ...attachmentContent?.files ?? []].filter((file) => {
-		const fileId = normalizeOptionalString(file.id);
-		if (!fileId) return true;
-		if (fallbackFileIds.has(fileId)) return false;
-		fallbackFileIds.add(fileId);
-		return true;
-	});
-	const fileOnlyFallback = !mediaPlaceholder && fallbackFiles.length > 0 ? fallbackFiles.slice(0, 8).map((file) => formatSlackFileReference(file)).join(", ") : void 0;
-	const fileOnlyPlaceholder = fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : void 0;
+	})) : null;
+	const effectiveDirectMedia = attachmentContent?.media.length ? attachmentContent.media : null;
+	const mediaPlaceholder = effectiveDirectMedia?.map((item) => item.placeholder).join(" ");
+	const fileOnlyFallback = attachmentContent?.files?.map(formatSlackFileReference).join(", ");
 	let botAttachmentText;
 	if (params.isBotMessage && !attachmentContent?.text) {
 		const botAttachmentTextParts = [];
@@ -3120,18 +3058,17 @@ async function resolveSlackMessageContent(params) {
 		renderSlackUserMentions(textParts[1], renderedMentions),
 		renderSlackUserMentions(textParts[2], renderedMentions),
 		mediaPlaceholder,
-		fileOnlyPlaceholder
+		fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : void 0
 	].filter(Boolean).join("\n") || "";
 	const unavailableImageCount = attachmentContent?.unavailableImageCount ?? 0;
 	if (unavailableImageCount > 0) rawBody = formatInboundMediaUnavailableText({
 		body: rawBody,
 		notice: `[slack ${unavailableImageCount > 1 ? `${unavailableImageCount} forwarded images` : "forwarded image"} unavailable]`
 	});
-	if (!rawBody) return null;
-	return {
+	return rawBody ? {
 		rawBody,
 		effectiveDirectMedia
-	};
+	} : null;
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-dm-history.ts
@@ -3359,7 +3296,7 @@ function formatSlackThreadLabelSnippet(text) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-DFk0ANVB.js").then((n) => n._));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-XdQyjG_p.js").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({

package/dist/{policy-BKXSxrIS.js → policy-BoP6t88v.js}

@@ -1,4 +1,4 @@
-import { f as normalizeSlackSlug, m as resolveSlackUserAllowListForTeam, n as buildSlackChannelPolicyScope, t as buildSlackChannelIdCandidates } from "./group-policy-DyfB_ZIE.js";
+import { f as normalizeSlackSlug, m as resolveSlackUserAllowListForTeam, n as buildSlackChannelPolicyScope, t as buildSlackChannelIdCandidates } from "./group-policy-CU1tEGpS.js";
 import { applyChannelMatchMeta, buildChannelKeyCandidates } from "openclaw/plugin-sdk/channel-targets";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
 //#region extensions/slack/src/monitor/channel-config.ts

package/dist/{probe-BVA65leh.js → probe-4_aHtVT3.js}

@@ -1,32 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { u as formatSlackBotTokenIdentityWarning } from "./accounts-BlzxuYle.js";
-import "./target-parsing-BnMD2ZqZ.js";
+import { u as formatSlackBotTokenIdentityWarning } from "./accounts-Dm_H77gH.js";
 import { createRequire } from "node:module";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "openclaw/plugin-sdk/account-id";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { runChannelProbe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { PAIRING_APPROVED_MESSAGE, projectCredentialSnapshotFields, resolveConfiguredFromRequiredCredentialStatuses } from "openclaw/plugin-sdk/channel-status";
 import { createHash } from "node:crypto";
 import { WebClient } from "@slack/web-api";
 import { addActiveManagedProxyTlsOptions, resolveEnvHttpProxyAgentOptions, resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { isDebugProxyGlobalFetchPatchInstalled } from "openclaw/plugin-sdk/proxy-capture";
 import { redactSensitiveText } from "openclaw/plugin-sdk/logging-core";
-//#region extensions/slack/src/channel-api.ts
-const SLACK_CHANNEL_META = {
-	id: "slack",
-	label: "Slack",
-	selectionLabel: "Slack",
-	docsPath: "/channels/slack",
-	docsLabel: "slack",
-	blurb: "supports bot + app tokens, channels, threads, and interactive replies.",
-	systemImage: "number.square",
-	markdownCapable: true
-};
-function getChatChannelMeta(id) {
-	if (id !== SLACK_CHANNEL_META.id) throw new Error(`Unsupported Slack channel meta lookup: ${id}`);
-	return SLACK_CHANNEL_META;
-}
-//#endregion
 //#region extensions/slack/src/client-options.ts
 const requireFromSlackSocketMode = (() => {
 	return createRequire(createRequire(import.meta.url).resolve("@slack/socket-mode/package.json"));
@@ -362,4 +343,4 @@ async function probeSlack(token, timeoutMs = 2500, opts) {
 	}));
 }
 //#endregion
-export { resolveConfiguredFromRequiredCredentialStatuses as S, resolveSlackWriteClientOptions as _, createSlackReadClient as a, getChatChannelMeta as b, createSlackWebClient as c, getSlackWriteClient as d, SLACK_DEFAULT_RETRY_OPTIONS as f, resolveSlackWebClientOptions as g, resolveSlackProxyDispatcher as h, createSlackLookupClient as i, createSlackWriteClient as l, resolveSlackLookupClientOptions as m, probe_exports as n, createSlackStartupAuthClient as o, SLACK_WRITE_RETRY_OPTIONS as p, formatSlackError as r, createSlackTokenCacheKey as s, probeSlack as t, getSlackListenerUploadCompletionClient as u, DEFAULT_ACCOUNT_ID$1 as v, projectCredentialSnapshotFields as x, PAIRING_APPROVED_MESSAGE as y };
+export { resolveSlackWriteClientOptions as _, createSlackReadClient as a, createSlackWebClient as c, getSlackWriteClient as d, SLACK_DEFAULT_RETRY_OPTIONS as f, resolveSlackWebClientOptions as g, resolveSlackProxyDispatcher as h, createSlackLookupClient as i, createSlackWriteClient as l, resolveSlackLookupClientOptions as m, probe_exports as n, createSlackStartupAuthClient as o, SLACK_WRITE_RETRY_OPTIONS as p, formatSlackError as r, createSlackTokenCacheKey as s, probeSlack as t, getSlackListenerUploadCompletionClient as u };