@openclaw/slack 2026.8.1-beta.2 → 2026.8.1

package/dist/{relay-source-C9leF11u.js → relay-source-BNGpsdwV.js}

@@ -1,4 +1,4 @@
-import { f as SLACK_SOCKET_RECONNECT_POLICY, p as formatUnknownError } from "./provider-CDNvBXUi.js";
+import { h as formatUnknownError, m as SLACK_SOCKET_RECONNECT_POLICY } from "./provider-CN_8hFv2.js";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { isIP } from "node:net";

package/dist/{replies-CeOfv82I.js → replies-BSiRQOJ1.js}

@@ -1,10 +1,12 @@
-import { B as SLACK_TEXT_LIMIT, C as buildSlackNativeDataAccessibilityText, D as isSlackInvalidBlocksResponse, N as buildSlackBlocksFallbackText, O as isSlackNativeResponseUrlRejection, T as hasSlackNativeDataBlock, _ as resolveSlackReplyBlocks, g as resolveSlackReplyBlockResolution, j as markdownToSlackMrkdwnChunks, m as hasSlackReplyStructuredContent } from "./group-policy-c4RP9bjc.js";
-import { m as chunkSlackTextAtHardLimit, p as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-Nor0iBwY.js";
-import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-CDNvBXUi.js";
+import { C as isSlackNativeResponseUrlRejection, M as SLACK_TEXT_LIMIT, S as isSlackInvalidBlocksResponse, T as buildSlackBlocksFallbackText, Z as markdownToSlackMrkdwnChunks, b as hasSlackNativeDataBlock, d as resolveSlackReplyBlockResolution, f as resolveSlackReplyBlocks, l as hasSlackReplyStructuredContent, v as buildSlackNativeDataAccessibilityText } from "./group-policy-BdwszjYn.js";
+import { h as chunkSlackTextAtHardLimit, m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-DS9ICrBI.js";
+import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-CN_8hFv2.js";
+import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
+import { deliverTextOrMediaReply, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 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 { createChannelPartialDeliveryError } from "openclaw/plugin-sdk/channel-inbound";
 import { buildCanonicalSentMessageHookContext, createInternalHookEvent, fireAndForgetHook, toInternalMessageSentContext, toPluginMessageContext, toPluginMessageSentEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
@@ -113,6 +115,15 @@ function compactSlackResponseUrlFallback(messages) {
 function readSlackReplyBlocks(payload) {
 	return resolveSlackReplyBlocks(payload);
 }
+function sanitizeSlackMonitorReplyPayload(payload) {
+	if (payload.isReasoning === true || typeof payload.text !== "string") return payload.isReasoning === true ? null : payload;
+	const text = sanitizeAssistantVisibleText(payload.text);
+	if (text === payload.text) return payload;
+	return text || resolveSendableOutboundReplyParts(payload).hasMedia || hasSlackReplyStructuredContent(payload) ? {
+		...payload,
+		text: text || void 0
+	} : null;
+}
 function resolveSlackMediaHookSpokenText(payload) {
 	return (getReplyPayloadTtsSupplement(payload)?.spokenText ?? payload.spokenText)?.trim() || void 0;
 }
@@ -121,27 +132,6 @@ function resolveDeliveredSlackReplyThreadTs(params) {
 }
 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 ? {
-				eventScope: 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({
@@ -153,6 +143,31 @@ async function deliverReplies(params) {
 		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 acceptedResults = [];
+		const sendReply = async (input) => {
+			return await sendMessageSlack(params.target, input.text, {
+				cfg: params.cfg,
+				token: params.token,
+				threadTs: input.threadTs,
+				accountId: params.accountId,
+				onDeliveryResult: (result) => {
+					acceptedResults.push(result);
+				},
+				...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 ? {
+					eventScope: params.eventScope,
+					textLimit: params.textLimit,
+					...params.mediaMaxBytes !== void 0 ? { mediaMaxBytes: params.mediaMaxBytes } : {}
+				} : {},
+				...params.identity ? { identity: params.identity } : {},
+				...params.metadata ? { metadata: params.metadata } : {}
+			});
+		};
 		const emitSent = (content, result) => {
 			if (params.deferMessageSentHooks) return;
 			emitSlackMessageSentHooks({
@@ -250,7 +265,13 @@ async function deliverReplies(params) {
 			}
 		} catch (error) {
 			emitFailed(hookParts.join("\n\n") || textRaw || spokenText || "", error);
-			throw error;
+			if (acceptedResults.length === 0) throw error;
+			const receipt = createMessageReceiptFromOutboundResults({ results: acceptedResults });
+			throw createChannelPartialDeliveryError(error, {
+				messageIds: receipt.platformMessageIds,
+				receipt,
+				visibleReplySent: true
+			});
 		}
 		if (delivered) {
 			emitSent(hookParts.join("\n\n") || textRaw || spokenText || "", reply.hasMedia ? void 0 : lastResult);
@@ -500,4 +521,4 @@ async function deliverSlackSlashReplies(params) {
 	}
 }
 //#endregion
-export { resolveDeliveredSlackReplyThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, emitSlackMessageSentHooks as s, createSlackReplyDeliveryPlan as t };
+export { resolveDeliveredSlackReplyThreadTs as a, emitSlackMessageSentHooks as c, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, sanitizeSlackMonitorReplyPayload as s, createSlackReplyDeliveryPlan as t };

package/dist/{resolve-channels-CNPrxaXY.js → resolve-channels-Czheznc8.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import { i as createSlackLookupClient } from "./probe-HoEg_WxB.js";
+import { h as createSlackLookupClient } from "./probe-0usmAb0i.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";

package/dist/{resolve-users-Dzomuwnr.js → resolve-users-BAOlNimr.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import { i as createSlackLookupClient } from "./probe-HoEg_WxB.js";
+import { h as createSlackLookupClient } from "./probe-0usmAb0i.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";

package/dist/runtime-api.js

@@ -1,14 +1,14 @@
 import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
-import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, t as listEnabledSlackAccounts } from "./accounts-CK4AVI2_.js";
-import { i as resolveSlackGroupToolPolicy, r as resolveSlackGroupRequireMention } from "./group-policy-c4RP9bjc.js";
-import { t as probeSlack } from "./probe-HoEg_WxB.js";
+import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, t as listEnabledSlackAccounts } from "./accounts-Dm_H77gH.js";
+import { i as resolveSlackGroupToolPolicy, r as resolveSlackGroupRequireMention } from "./group-policy-BdwszjYn.js";
+import { t as probeSlack } from "./probe-0usmAb0i.js";
 import { r as setSlackRuntime } from "./runtime-JSVZSWAj.js";
-import { a as getSlackMemberInfo, c as listSlackReactions, d as readSlackMessages, f as removeOwnSlackReactions, g as unpinSlackMessage, h as sendSlackMessage, l as pinSlackMessage, o as listSlackEmojis, p as removeSlackReaction, r as editSlackMessage, s as listSlackPins, t as deleteSlackMessage, u as reactSlackMessage } from "./actions-BTDXwwE3.js";
-import { r as sendMessageSlack } from "./send-Nor0iBwY.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-CNPrxaXY.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-Dzomuwnr.js";
-import { t as monitorSlackProvider } from "./provider-CDNvBXUi.js";
-import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-BkGe7ny_.js";
-import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-CFKUtW9E.js";
-import "./monitor-1nF1NtqT.js";
+import { c as listSlackPins, d as reactSlackMessage, f as readSlackMessages, g as unpinSlackMessage, h as sendSlackMessage, i as editSlackMessage, l as listSlackReactions, m as removeSlackReaction, n as deleteSlackMessage, o as getSlackMemberInfo, p as removeOwnSlackReactions, s as listSlackEmojis, u as pinSlackMessage } from "./actions-BI7JkfVm.js";
+import { r as sendMessageSlack } from "./send-DS9ICrBI.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-Czheznc8.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-BAOlNimr.js";
+import { t as monitorSlackProvider } from "./provider-CN_8hFv2.js";
+import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-044ldvNL.js";
+import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-BPaNHjmP.js";
+import "./monitor-Dq5Cmrvp.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/{scopes-cYXKkrRD.js → scopes-COSlmhnH.js}

@@ -1,4 +1,4 @@
-import { a as createSlackReadClient, r as formatSlackError } from "./probe-HoEg_WxB.js";
+import { g as createSlackReadClient, o as formatSlackError } from "./probe-0usmAb0i.js";
 import { isRecord, normalizeOptionalString, normalizeStringEntries, sortUniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/scopes.ts
 function collectScopes(value, into) {

package/dist/security-contract-api.js

@@ -1,2 +1,2 @@
-import { t as collectSlackSecurityAuditFindings } from "./security-audit-DR097212.js";
+import { t as collectSlackSecurityAuditFindings } from "./security-audit-B_yKr7MW.js";
 export { collectSlackSecurityAuditFindings };

package/dist/{send-Nor0iBwY.js → send-DS9ICrBI.js}

@@ -1,50 +1,41 @@
-import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-CK4AVI2_.js";
+import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-Dm_H77gH.js";
 import { a as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-BnMD2ZqZ.js";
-import { A as chunkSlackMrkdwnText, B as SLACK_TEXT_LIMIT, C as buildSlackNativeDataAccessibilityText, E as isSlackInvalidBlocksError, F as renderSlackBlockFallbackText, G as truncateSlackText, K as truncateSlackTextByUtf8Bytes, L as SLACK_EDIT_TEXT_MAX_BYTES, P as buildSlackCompleteBlocksFallbackText, R as SLACK_MESSAGE_TEXT_HARD_LIMIT, S as appendSlackNativeDataPlainTextFallback, T as hasSlackNativeDataBlock, j as markdownToSlackMrkdwnChunks, k as stripSlackNativeDataBlocks, p as assertSlackDetachedTargetAllowed, q as SLACK_QUESTION_FINALIZATION_BLOCKS, tt as resolveSlackQuestionActionIds, ut as validateSlackBlocksArray, w as createSlackNativeDataBaseTextConsumer, z as SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT } from "./group-policy-c4RP9bjc.js";
+import { A as SLACK_MESSAGE_TEXT_HARD_LIMIT, D as renderSlackBlockFallbackText, E as buildSlackCompleteBlocksFallbackText, L as truncateSlackText, M as SLACK_TEXT_LIMIT, R as truncateSlackTextByUtf8Bytes, X as chunkSlackMrkdwnText, Z as markdownToSlackMrkdwnChunks, _ as appendSlackNativeDataPlainTextFallback, b as hasSlackNativeDataBlock, c as assertSlackDetachedTargetAllowed, j as SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT, k as SLACK_EDIT_TEXT_MAX_BYTES, q as resolveSlackQuestionActionIds, st as validateSlackBlocksArray, v as buildSlackNativeDataAccessibilityText, w as stripSlackNativeDataBlocks, x as isSlackInvalidBlocksError, y as createSlackNativeDataBaseTextConsumer, z as SLACK_QUESTION_FINALIZATION_BLOCKS } from "./group-policy-BdwszjYn.js";
 import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
-import { a as createSlackReadClient, d as getSlackWriteClient, r as formatSlackError, s as createSlackTokenCacheKey } from "./probe-HoEg_WxB.js";
+import { S as getSlackWriteClient, g as createSlackReadClient, o as formatSlackError, v as createSlackTokenCacheKey } from "./probe-0usmAb0i.js";
 import { t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.js";
-import { i as loadOutboundMediaFromUrl } from "./runtime-api-Cj9nxBNv.js";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
-import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { logVerbose, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
 import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
-import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
+import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash, createHmac } from "node:crypto";
 import { withTrustedEnvProxyGuardedFetchMode } from "openclaw/plugin-sdk/fetch-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { PlatformMessageNotDispatchedError, extractErrorCode, readErrorName } from "openclaw/plugin-sdk/error-runtime";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
-import { chunkMarkdownTextWithMode, isSilentReplyText, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
-import { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
+import { chunkMarkdownTextWithMode, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 import { buildTimeoutAbortSignal } from "openclaw/plugin-sdk/extension-shared";
 import { extensionForMime } from "openclaw/plugin-sdk/media-mime";
+import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
+import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
 import { createPersistentDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 import { createPluginStateErrorReporter } from "openclaw/plugin-sdk/plugin-state-runtime";
 //#region extensions/slack/src/native-data-fallback.ts
 const SLACK_SECTION_PLAIN_TEXT_MAX = 3e3;
 const SLACK_EMPTY_BLOCK_FALLBACK = "Shared a Block Kit message";
-function sliceSlackTextChunk(text, start, limit) {
-	return sliceUtf16Safe(text, start, Math.min(text.length, start + limit)) || Array.from(text.slice(start))[0] || "";
-}
 function chunkSlackTextAtHardLimit(text, limit = SLACK_MESSAGE_TEXT_HARD_LIMIT) {
-	const effectiveLimit = Math.max(1, Math.floor(limit));
-	const chunks = [];
-	let offset = 0;
-	while (offset < text.length) {
-		const chunk = sliceSlackTextChunk(text, offset, effectiveLimit);
-		if (!chunk) throw new Error("Slack plain-text fallback chunking made no progress.");
-		chunks.push(chunk);
-		offset += chunk.length;
-	}
-	return chunks;
+	if (!text) return [];
+	return chunkTextForOutbound(text, Math.max(1, Math.floor(limit)), { preserveWhitespace: true });
 }
 function fitsSlackTextLimit(text, limit) {
 	if (text.length <= limit) return true;
-	return sliceSlackTextChunk(text, 0, limit).length === text.length;
+	return truncateUtf16Safe(text, limit).length === text.length;
 }
 function buildPlainTextBlocks(text, textLimit) {
 	return chunkSlackTextAtHardLimit(text, Math.min(textLimit, SLACK_SECTION_PLAIN_TEXT_MAX)).map((chunk, index) => {
@@ -154,6 +145,7 @@ function hasCustomIdentity$1(identity) {
 async function postSlackMessageWithIdentityFallback(params) {
 	const { basePayload, identity, post } = params;
 	try {
+		if (!identity) return await post(basePayload);
 		if (identity?.iconUrl) return await post({
 			...basePayload,
 			...identity.username ? { username: identity.username } : {},
@@ -239,6 +231,16 @@ const SLACK_DNS_RETRY_CODES = /* @__PURE__ */ new Set([
 ]);
 const SLACK_DNS_RETRY_ATTEMPTS = 2;
 const SLACK_DNS_RETRY_BASE_DELAY_MS = 250;
+function rethrowSlackPermanentOutboundApiRejection(err) {
+	const rawData = isRecord(err) && err.code === "slack_webapi_platform_error" ? err.data : void 0;
+	const data = isRecord(rawData) ? rawData : void 0;
+	const code = data?.error;
+	if (data?.ok === false && (code === "messages_tab_disabled" || code === "account_inactive")) throw new PlatformMessageNotDispatchedError(`Slack outbound delivery rejected: ${code}`, {
+		cause: err,
+		retryable: false
+	});
+	throw err;
+}
 function readSlackRequestErrorCode(value) {
 	if (!value || typeof value !== "object") return;
 	const code = value.code;
@@ -262,11 +264,6 @@ function hasSlackDnsRequestSignal(err) {
 	}
 	return false;
 }
-function delaySlackDnsRetry(attempt) {
-	return new Promise((resolve) => {
-		setTimeout(resolve, SLACK_DNS_RETRY_BASE_DELAY_MS * Math.max(1, attempt));
-	});
-}
 function resolveSlackUploadTimeoutLogUrl(url) {
 	try {
 		return new URL(url).origin;
@@ -340,27 +337,43 @@ function resolveSlackUploadTransportPolicy(params) {
 	};
 }
 async function withSlackDnsRequestRetry(operation, fn) {
-	for (const attempt of Array.from({ length: 3 }, (_, index) => index)) try {
-		return await fn();
-	} catch (err) {
-		if (attempt >= SLACK_DNS_RETRY_ATTEMPTS || !hasSlackDnsRequestSignal(err)) throw err;
-		logVerbose(`slack send: retrying ${operation} after transient DNS request error (${attempt + 1}/${SLACK_DNS_RETRY_ATTEMPTS})`);
-		await delaySlackDnsRetry(attempt + 1);
-	}
-	throw new Error("unreachable Slack DNS retry loop exit");
+	return await retryAsync(fn, {
+		attempts: 3,
+		minDelayMs: 0,
+		shouldRetry: hasSlackDnsRequestSignal,
+		delayMs: ({ attempt }) => SLACK_DNS_RETRY_BASE_DELAY_MS * Math.max(1, attempt),
+		onRetry: ({ attempt }) => {
+			logVerbose(`slack send: retrying ${operation} after transient DNS request error (${attempt}/${SLACK_DNS_RETRY_ATTEMPTS})`);
+		},
+		sleep: (delayMs) => sleepWithAbort(delayMs)
+	});
+}
+function requireSlackPostMessageTimestamp(response) {
+	if (response.ok === false) throw new Error(`Slack chat.postMessage failed: ${formatSlackError(response.error, "unknown error")}`);
+	const timestamp = response.ts?.trim();
+	if (!timestamp) throw new Error("Slack chat.postMessage returned no message timestamp");
+	return timestamp;
 }
 async function postSlackMessageBestEffort(params) {
 	const basePayload = buildSlackPostMessagePayload(params);
 	const postChatMessage = params.client.chat.postMessage.bind(params.client.chat);
 	const post = async (payload, identity) => ({
-		response: await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage(payload)),
+		response: await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage(payload)).catch(rethrowSlackPermanentOutboundApiRejection),
 		identity
 	});
-	return await postSlackMessageWithIdentityFallback({
+	const posted = await postSlackMessageWithIdentityFallback({
 		basePayload,
 		identity: params.identity,
 		post
 	});
+	const timestamp = requireSlackPostMessageTimestamp(posted.response);
+	return {
+		...posted,
+		response: {
+			...posted.response,
+			ts: timestamp
+		}
+	};
 }
 async function uploadSlackFile(params) {
 	const { buffer, contentType, fileName } = await loadOutboundMediaFromUrl(params.mediaUrl, {
@@ -375,7 +388,7 @@ async function uploadSlackFile(params) {
 	const uploadUrlResp = await withSlackDnsRequestRetry("files.getUploadURLExternal", () => params.client.files.getUploadURLExternal({
 		filename: uploadFileName,
 		length: buffer.length
-	}));
+	})).catch(rethrowSlackPermanentOutboundApiRejection);
 	if (!uploadUrlResp.ok || !uploadUrlResp.upload_url || !uploadUrlResp.file_id) throw new Error(`Failed to get upload URL: ${uploadUrlResp.error ?? "unknown error"}`);
 	const uploadFileId = uploadUrlResp.file_id;
 	const uploadTransport = resolveSlackUploadTransportPolicy({
@@ -605,7 +618,7 @@ async function updateMessageSlack(params) {
 }
 function createSlackSendReceipt(params) {
 	return createMessageReceiptFromOutboundResults({
-		results: params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown" && messageId !== "suppressed").map((messageId) => {
+		results: params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown").map((messageId) => {
 			const result = {
 				channel: "slack",
 				messageId
@@ -617,6 +630,18 @@ function createSlackSendReceipt(params) {
 		threadId: params.threadTs
 	});
 }
+function createSlackSendReceiptFromResults(results, threadTs) {
+	const receipt = createMessageReceiptFromOutboundResults({
+		results,
+		threadId: threadTs
+	});
+	const thread = threadTs ? { threadId: threadTs } : {};
+	for (const [index, part] of receipt.parts.entries()) Object.assign(part, {
+		index,
+		...thread
+	});
+	return Object.assign(receipt, thread);
+}
 function resolveToken(params) {
 	const explicit = normalizeOptionalString(params.explicit);
 	if (explicit) return explicit;
@@ -658,7 +683,6 @@ function resolveSlackDelivery(params) {
 			credential: SLACK_ENTERPRISE_LISTENER_QUEUE_CREDENTIAL,
 			identity: normalizeSlackSendIdentity(params.opts.identity),
 			recipient: params.recipient,
-			requireMessageTimestamp: true,
 			teamId: params.eventScope.teamId,
 			unfurl: { unfurlMedia: params.account.config.unfurlMedia },
 			...params.eventScope.uploadCompletionClient ? { upload: Object.freeze({
@@ -681,7 +705,6 @@ function resolveSlackDelivery(params) {
 			explicit: params.opts.identity
 		}),
 		recipient: params.recipient,
-		requireMessageTimestamp: false,
 		teamId: params.recipient.teamId,
 		unfurl: params.recipient.teamId ? { unfurlMedia: params.account.config.unfurlMedia } : {
 			unfurlLinks: params.account.config.unfurlLinks,
@@ -689,10 +712,6 @@ function resolveSlackDelivery(params) {
 		}
 	});
 }
-function assertSlackPostMessageResponse(response, required) {
-	if (!required || response.ok && response.ts) return;
-	throw new Error(response.ok ? "Slack chat.postMessage returned no message timestamp" : `Slack chat.postMessage failed: ${formatSlackError(response.error, "unknown error")}`);
-}
 function resolveSlackTextChunkLimit(params) {
 	const configuredLimit = params.textLimit ?? resolveTextChunkLimit(params.cfg, "slack", params.accountId, { fallbackLimit: 8e3 });
 	return Math.min(configuredLimit, SLACK_TEXT_LIMIT);
@@ -769,7 +788,7 @@ async function resolveChannelId(client, recipient, params) {
 		isDm: true,
 		cacheHit: true
 	};
-	const channelId = (await withSlackDnsRequestRetry("conversations.open", () => client.conversations.open({ users: recipient.id }))).channel?.id;
+	const channelId = (await withSlackDnsRequestRetry("conversations.open", () => client.conversations.open({ users: recipient.id })).catch(rethrowSlackPermanentOutboundApiRejection)).channel?.id;
 	if (!channelId) throw new Error("Failed to open Slack DM channel");
 	setSlackDmChannelCache(cache, cacheKey, channelId);
 	return {
@@ -1057,17 +1076,6 @@ async function sendMessageSlack(to, message, opts) {
 	const eventScope = resolveSlackSendEventScope({ opts });
 	const recipient = eventScope ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
 	if (!eventScope) assertSlackDetachedTargetAllowed(account.accountId, recipient.teamId);
-	if (isSilentReplyText(normalizedMessage) && !opts.mediaUrl && !opts.blocks) {
-		logVerbose("slack send: suppressed NO_REPLY token before API call");
-		return {
-			messageId: "suppressed",
-			channelId: "",
-			receipt: createSlackSendReceipt({
-				platformMessageIds: [],
-				kind: "unknown"
-			})
-		};
-	}
 	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
 	if (!normalizedMessage && !opts.mediaUrl && !blocks) throw new Error("Slack send requires text, blocks, or media");
 	const queuedOpts = Object.freeze({ ...opts });
@@ -1115,6 +1123,7 @@ async function sendMessageSlackQueuedInner(params) {
 		accountId: account.accountId,
 		token: delivery.credential
 	});
+	const deliveredResults = [];
 	const reportDelivery = async (result, deliveredBlocks) => {
 		const slackQuestionActionIds = resolveSlackQuestionActionIds(deliveredBlocks);
 		const deliveryResult = slackQuestionActionIds.length ? {
@@ -1125,6 +1134,7 @@ async function sendMessageSlackQueuedInner(params) {
 				[SLACK_QUESTION_FINALIZATION_BLOCKS]: deliveredBlocks.filter((block) => block.type !== "actions")
 			}
 		} : result;
+		deliveredResults.push(deliveryResult);
 		await opts.onDeliveryResult?.(deliveryResult);
 		return deliveryResult;
 	};
@@ -1154,7 +1164,6 @@ async function sendMessageSlackQueuedInner(params) {
 	const rawBlockAccessibilityText = trimmedMessage ? [trimmedMessage, ...completeBlockFallbackText.includes(trimmedMessage) ? [] : [completeBlockFallbackText]].join("\n\n") : completeBlockFallbackText;
 	const blockAccessibilityText = blocks ? orderedBlockAccessibilityText ?? rawBlockAccessibilityText : void 0;
 	let pendingBlockFallback = (hasNativeData || opts.authoredTextPlacement !== void 0) && orderedBlockDeliveryPlan?.skipOriginalBlocks ? orderedBlockDeliveryPlan : void 0;
-	const sentMessageIds = [];
 	let lastMessageId = "";
 	let deliveredChannelId = channelId;
 	let canonicalDeliveredThreadTs;
@@ -1185,8 +1194,7 @@ async function sendMessageSlackQueuedInner(params) {
 					...usesOrderedBlockAccessibility ? { mrkdwn: false } : {},
 					unfurl
 				});
-				assertSlackPostMessageResponse(response, delivery.requireMessageTimestamp);
-				const messageId = response.ts ?? "unknown";
+				const messageId = response.ts;
 				deliveredChannelId = resolvePostedMessageChannelId(response, channelId);
 				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
 				return await reportDelivery({
@@ -1231,13 +1239,10 @@ async function sendMessageSlackQueuedInner(params) {
 					unfurl
 				});
 				const response = posted.response;
-				assertSlackPostMessageResponse(response, delivery.requireMessageTimestamp);
 				sendIdentity = posted.identity;
-				lastMessageId = response.ts ?? lastMessageId;
+				lastMessageId = response.ts;
 				deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
 				canonicalDeliveredThreadTs ??= resolvePostedMessageThreadTs(response);
-				if (!response.ts) continue;
-				sentMessageIds.push(response.ts);
 				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
 				const fallbackDelivery = await reportDelivery({
 					messageId: response.ts,
@@ -1252,22 +1257,16 @@ async function sendMessageSlackQueuedInner(params) {
 				}, fallback.blocks);
 				if (fallbackDelivery.meta?.slackQuestionActionIds.length) questionDelivery = fallbackDelivery;
 			}
-			const messageId = lastMessageId || "unknown";
 			const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
 			return {
-				messageId,
+				messageId: lastMessageId,
 				channelId: deliveredChannelId,
 				threadTs: deliveredThreadTs,
 				...questionDelivery?.meta ? { meta: {
 					...questionDelivery.meta,
 					slackQuestionMessageId: questionDelivery.messageId
 				} } : {},
-				receipt: createSlackSendReceipt({
-					platformMessageIds: sentMessageIds.length ? sentMessageIds : [messageId],
-					channelId: deliveredChannelId,
-					kind: fallbackMessages.some((message) => message.blocks) ? "card" : "text",
-					threadTs: deliveredThreadTs
-				})
+				receipt: createSlackSendReceiptFromResults(deliveredResults, deliveredThreadTs)
 			};
 		}
 	}
@@ -1300,7 +1299,6 @@ async function sendMessageSlackQueuedInner(params) {
 			onPlatformSendDispatch: dispatchOnce,
 			...delivery.upload ? { auditContext: delivery.upload.auditContext } : {}
 		});
-		sentMessageIds.push(lastMessageId);
 		await reportDelivery({
 			messageId: lastMessageId,
 			channelId,
@@ -1315,7 +1313,7 @@ async function sendMessageSlackQueuedInner(params) {
 		chunksToPost = rest;
 	} else chunksToPost = resolvedChunks.length ? resolvedChunks : [""];
 	for (const [partIndex, chunk] of chunksToPost.entries()) {
-		const carriesPrimaryMessageOptions = partIndex === 0 && !opts.mediaUrl && sentMessageIds.length === 0;
+		const carriesPrimaryMessageOptions = partIndex === 0 && !opts.mediaUrl;
 		const baseMetadata = carriesPrimaryMessageOptions ? opts.metadata : void 0;
 		const metadata = opts.mediaUrl ? baseMetadata : withSlackDeliveryMetadata(baseMetadata, {
 			queueId: opts.deliveryQueueId,
@@ -1337,39 +1335,29 @@ async function sendMessageSlackQueuedInner(params) {
 			unfurl
 		});
 		const response = posted.response;
-		assertSlackPostMessageResponse(response, delivery.requireMessageTimestamp);
 		sendIdentity = posted.identity;
-		lastMessageId = response.ts ?? lastMessageId;
+		lastMessageId = response.ts;
 		deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
 		canonicalDeliveredThreadTs ??= resolvePostedMessageThreadTs(response);
-		if (response.ts) {
-			sentMessageIds.push(response.ts);
-			await reportDelivery({
-				messageId: response.ts,
+		await reportDelivery({
+			messageId: response.ts,
+			channelId: deliveredChannelId,
+			threadTs: resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs),
+			receipt: createSlackSendReceipt({
+				platformMessageIds: [response.ts],
 				channelId: deliveredChannelId,
-				threadTs: resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs),
-				receipt: createSlackSendReceipt({
-					platformMessageIds: [response.ts],
-					channelId: deliveredChannelId,
-					kind: "text",
-					threadTs: resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs)
-				})
-			});
-		}
+				kind: "text",
+				threadTs: resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs)
+			})
+		});
 	}
-	const messageId = lastMessageId || "unknown";
 	const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
 	return {
-		messageId,
+		messageId: lastMessageId,
 		channelId: deliveredChannelId,
 		threadTs: deliveredThreadTs,
-		receipt: createSlackSendReceipt({
-			platformMessageIds: sentMessageIds.length ? sentMessageIds : [messageId],
-			channelId: deliveredChannelId,
-			kind: opts.mediaUrl ? "media" : "text",
-			threadTs: deliveredThreadTs
-		})
+		receipt: createSlackSendReceiptFromResults(deliveredResults, deliveredThreadTs)
 	};
 }
 //#endregion
-export { updateMessageSlack as a, hasSlackThreadFailureNotice as c, recordSlackThreadFailureNotice as d, recordSlackThreadParticipation as f, setSlackDefaultSendIdentity as i, hasSlackThreadParticipation as l, chunkSlackTextAtHardLimit as m, resolveSlackDmChannelId as n, clearSlackThreadFailureNotice as o, buildSlackNativeDataDeliveryPlan as p, sendMessageSlack as r, clearSlackThreadParticipationCache as s, reconcileSlackUnknownSend as t, hasSlackThreadParticipationWithPersistence as u };
+export { updateMessageSlack as a, hasSlackThreadFailureNotice as c, recordSlackThreadFailureNotice as d, recordSlackThreadParticipation as f, chunkSlackTextAtHardLimit as h, setSlackDefaultSendIdentity as i, hasSlackThreadParticipation as l, buildSlackNativeDataDeliveryPlan as m, resolveSlackDmChannelId as n, clearSlackThreadFailureNotice as o, requireSlackPostMessageTimestamp as p, sendMessageSlack as r, clearSlackThreadParticipationCache as s, reconcileSlackUnknownSend as t, hasSlackThreadParticipationWithPersistence as u };

package/dist/send-results-eeOu_HYm.js

@@ -0,0 +1,23 @@
+import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+//#region extensions/slack/src/send-results.ts
+function mergeSlackSendResults(results) {
+	const lastResult = results.at(-1);
+	if (!lastResult) throw new Error("Slack send plan produced no delivery.");
+	if (results.length === 1) return lastResult;
+	const receipt = createMessageReceiptFromOutboundResults({ results });
+	receipt.parts = receipt.parts.map((part, index) => ({
+		...part,
+		index
+	}));
+	const questionResult = results.find((result) => result.meta?.slackQuestionActionIds.length);
+	return {
+		...lastResult,
+		receipt,
+		...questionResult?.meta ? { meta: {
+			...questionResult.meta,
+			slackQuestionMessageId: questionResult.meta.slackQuestionMessageId ?? questionResult.messageId
+		} } : {}
+	};
+}
+//#endregion
+export { mergeSlackSendResults as t };

package/dist/{send.runtime-BmgNe6S9.js → send.runtime-D_Bb6IuH.js}

@@ -1,2 +1,2 @@
-import { a as updateMessageSlack, n as resolveSlackDmChannelId, r as sendMessageSlack, t as reconcileSlackUnknownSend } from "./send-Nor0iBwY.js";
+import { a as updateMessageSlack, n as resolveSlackDmChannelId, r as sendMessageSlack, t as reconcileSlackUnknownSend } from "./send-DS9ICrBI.js";
 export { reconcileSlackUnknownSend, resolveSlackDmChannelId, sendMessageSlack, updateMessageSlack };

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as slackSetupPlugin } from "./channel.setup-Bch9dYmA.js";
+import { t as slackSetupPlugin } from "./channel.setup-ofDi3_Pu.js";
 export { slackSetupPlugin };

package/dist/{setup-surface-CbX1-Knh.js → setup-surface-BGnd2pSe.js}

@@ -1,9 +1,9 @@
-import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom } from "./accounts-CK4AVI2_.js";
-import { t as inspectSlackAccount } from "./account-inspect-Drw2gAiN.js";
-import "./shared-zdT5AMp-.js";
-import { o as SLACK_CHANNEL, r as createSlackSetupWizardBase } from "./channel.setup-Bch9dYmA.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-CNPrxaXY.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-Dzomuwnr.js";
+import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom } from "./accounts-Dm_H77gH.js";
+import { t as inspectSlackAccount } from "./account-inspect-CN2hBsim.js";
+import "./shared-D5B-5hBg.js";
+import { o as SLACK_CHANNEL, r as createSlackSetupWizardBase } from "./channel.setup-ofDi3_Pu.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-Czheznc8.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-BAOlNimr.js";
 import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveBasicAllowFromEntries } from "openclaw/plugin-sdk/allow-from";
 import { createSetupTranslator, noteChannelLookupFailure, noteChannelLookupSummary, parseMentionOrPrefixedId, patchChannelConfigForAccount, promptResolvedAllowFrom, resolveEntriesWithOptionalToken, resolveSetupAccountId, splitSetupEntries } from "openclaw/plugin-sdk/setup-runtime";