@openclaw/slack 2026.9.5 → 2026.9.7

package/dist/.setup/{send-6GCb3lBP.mjs → send-BOVLQi3n.mjs}

@@ -1,15 +1,16 @@
-import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-C1FspRF-.mjs";
-import { D as SLACK_MESSAGE_TEXT_HARD_LIMIT, E as SLACK_EDIT_TEXT_MAX_BYTES, J as markdownToSlackMrkdwnChunks, K as resolveSlackQuestionActionIds, M as truncateSlackTextByUtf8Bytes, O as SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT, R as SLACK_QUESTION_FINALIZATION_BLOCKS, S as stripSlackNativeDataBlocks, T as renderSlackBlockFallbackText, _ as createSlackNativeDataBaseTextConsumer, f as assertSlackDetachedTargetAllowed, g as buildSlackNativeDataAccessibilityText, h as appendSlackNativeDataPlainTextFallback, j as truncateSlackText, k as SLACK_TEXT_LIMIT, lt as validateSlackBlocksArray, q as chunkSlackMrkdwnText, v as hasSlackNativeDataBlock, w as buildSlackCompleteBlocksFallbackText, y as isSlackInvalidBlocksError } from "./session-status-BhG6pdiH.mjs";
-import { a as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-DEsPjngB.mjs";
-import { f as createSlackTokenCacheKey, g as getSlackWriteClient, m as createSlackWriteClient, o as formatSlackError, u as createSlackReadClient } from "./probe-64C6k3_Q.mjs";
-import { r as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-CukseRVL.mjs";
+import { r as __exportAll } from "./streaming-compat-C5Wut626.mjs";
+import { d as resolveSlackOperationToken, s as resolveSlackAccount } from "./accounts-D_N9IqNA.mjs";
+import { a as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-FFE26kOV.mjs";
+import { D as SLACK_MESSAGE_TEXT_HARD_LIMIT, E as SLACK_EDIT_TEXT_MAX_BYTES, K as resolveSlackQuestionActionIds, M as truncateSlackTextByUtf8Bytes, O as SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT, R as SLACK_QUESTION_FINALIZATION_BLOCKS, S as stripSlackNativeDataBlocks, T as renderSlackBlockFallbackText, X as chunkSlackMrkdwnText, Z as markdownToSlackMrkdwnChunks, _ as createSlackNativeDataBaseTextConsumer, f as assertSlackDetachedTargetAllowed, g as buildSlackNativeDataAccessibilityText, h as appendSlackNativeDataPlainTextFallback, j as truncateSlackText, k as SLACK_TEXT_LIMIT, v as hasSlackNativeDataBlock, vt as validateSlackBlocksArray, w as buildSlackCompleteBlocksFallbackText, y as isSlackInvalidBlocksError } from "./session-status-DscajIsd.mjs";
+import { _ as getSlackWriteClient, d as createSlackReadClient, h as createSlackWriteClient, o as formatSlackError, p as createSlackTokenCacheKey, s as getSlackWebApiErrorData } from "./probe-B2Y9qc_z.mjs";
+import { r as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-Cvt7WD6B.mjs";
 import { t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.mjs";
 import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { logVerbose, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
-import { sliceUtf16Safe, truncateCodePoints } from "openclaw/plugin-sdk/text-utility-runtime";
 import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
 import { createHash, createHmac } from "node:crypto";
@@ -122,20 +123,21 @@ function buildSlackNativeDataDeliveryPlan(params) {
 }
 //#endregion
 //#region extensions/slack/src/post-message-identity.ts
-function getSlackWebApiErrorData$1(err) {
-	if (!(err instanceof Error)) return;
-	const data = err.data;
-	return data && typeof data === "object" ? data : void 0;
+function buildSlackMessageIdentityPayload(identity) {
+	return {
+		...identity?.username ? { username: identity.username } : {},
+		...identity?.iconUrl ? { icon_url: identity.iconUrl } : identity?.iconEmoji ? { icon_emoji: identity.iconEmoji } : {}
+	};
 }
 function isSlackCustomizeScopeError(err) {
-	const data = getSlackWebApiErrorData$1(err);
+	const data = getSlackWebApiErrorData(err);
 	if (normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.error)) !== "missing_scope") return false;
 	if (normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.needed)).includes("chat:write.customize")) return true;
 	return [...normalizeTrimmedStringList(data?.response_metadata?.scopes), ...normalizeTrimmedStringList(data?.response_metadata?.acceptedScopes)].map((scope) => normalizeLowercaseStringOrEmpty(scope)).includes("chat:write.customize");
 }
 function isSlackCustomIdentityRejectedError(err) {
 	if (isSlackCustomizeScopeError(err)) return true;
-	const data = getSlackWebApiErrorData$1(err);
+	const data = getSlackWebApiErrorData(err);
 	const code = normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.error));
 	return code === "invalid_arguments" || code === "invalid_arg_name";
 }
@@ -147,19 +149,9 @@ 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 } : {},
-			icon_url: identity.iconUrl
-		}, identity);
-		if (identity?.iconEmoji) return await post({
-			...basePayload,
-			...identity.username ? { username: identity.username } : {},
-			icon_emoji: identity.iconEmoji
-		}, identity);
 		return await post({
 			...basePayload,
-			...identity?.username ? { username: identity.username } : {}
+			...buildSlackMessageIdentityPayload(identity)
 		}, identity);
 	} catch (err) {
 		if (!identity || !hasCustomIdentity$1(identity) || !isSlackCustomIdentityRejectedError(err)) throw err;
@@ -192,18 +184,10 @@ function buildSlackPostMessagePayload(params) {
 		reply_broadcast: true
 	} : params.threadTs ? { thread_ts: params.threadTs } : {};
 	const unfurlPayload = buildSlackUnfurlPayload(params.unfurl);
-	if (params.blocks?.length) return {
-		channel: params.channelId,
-		text: params.text,
-		blocks: params.blocks,
-		...params.metadata ? { metadata: params.metadata } : {},
-		...typeof params.mrkdwn === "boolean" ? { mrkdwn: params.mrkdwn } : {},
-		...threadPayload,
-		...unfurlPayload
-	};
 	return {
 		channel: params.channelId,
 		text: params.text,
+		...params.blocks?.length ? { blocks: params.blocks } : {},
 		...params.metadata ? { metadata: params.metadata } : {},
 		...typeof params.mrkdwn === "boolean" ? { mrkdwn: params.mrkdwn } : {},
 		...threadPayload,
@@ -509,10 +493,7 @@ function recordSlackThreadFailureNotice(params) {
 	if (threadFailureNotices.get(key) === fingerprint) return false;
 	threadFailureNotices.delete(key);
 	threadFailureNotices.set(key, fingerprint);
-	if (threadFailureNotices.size > MAX_FAILURE_NOTICES) {
-		const oldestKey = threadFailureNotices.keys().next().value;
-		if (oldestKey !== void 0) threadFailureNotices.delete(oldestKey);
-	}
+	pruneMapToMaxSize(threadFailureNotices, MAX_FAILURE_NOTICES);
 	return true;
 }
 /** Clears a thread or channel outage notice after a healthy model turn completes. */
@@ -545,15 +526,19 @@ function readCachedSlackDmChannelId(params) {
 function cacheSlackDmChannelId(params, channelId) {
 	const cache = getSlackDmChannelCache(params.cacheOwner);
 	const key = createSlackDmCacheKey(params);
-	if (cache.has(key)) cache.delete(key);
-	else if (cache.size >= SLACK_DM_CHANNEL_CACHE_MAX) {
-		const oldest = cache.keys().next().value;
-		if (oldest) cache.delete(oldest);
-	}
+	cache.delete(key);
 	cache.set(key, channelId);
+	pruneMapToMaxSize(cache, SLACK_DM_CHANNEL_CACHE_MAX);
 }
 //#endregion
 //#region extensions/slack/src/send.ts
+var send_exports = /* @__PURE__ */ __exportAll({
+	reconcileSlackUnknownSend: () => reconcileSlackUnknownSend,
+	resolveSlackDmChannelId: () => resolveSlackDmChannelId,
+	sendMessageSlack: () => sendMessageSlack,
+	setSlackDefaultSendIdentity: () => setSlackDefaultSendIdentity,
+	updateMessageSlack: () => updateMessageSlack
+});
 const SLACK_DELIVERY_METADATA_EVENT = "openclaw_delivery";
 const SLACK_DELIVERY_METADATA_KEY = "openclaw_delivery_id";
 const SLACK_DELIVERY_METADATA_PART_INDEX_KEY = "openclaw_delivery_part_index";
@@ -594,12 +579,6 @@ function getSlackDefaultSendIdentity(accountId) {
 function resolveSlackSendIdentity(params) {
 	return normalizeSlackSendIdentity(params.explicit) ?? getSlackDefaultSendIdentity(params.accountId);
 }
-function getSlackWebApiErrorData(err) {
-	if (!(err instanceof Error)) return;
-	const data = err.data;
-	if (!data || typeof data !== "object") return;
-	return data;
-}
 function formatSlackWebApiErrorMessage(err) {
 	if (!(err instanceof Error)) return;
 	const data = getSlackWebApiErrorData(err);
@@ -673,6 +652,19 @@ function createSlackSendReceiptFromResults(results, threadTs) {
 	});
 	return Object.assign(receipt, thread);
 }
+function createSlackSendResult(messageId, channelId, kind, threadTs) {
+	return {
+		messageId,
+		channelId,
+		threadTs,
+		receipt: createSlackSendReceipt({
+			platformMessageIds: [messageId],
+			channelId,
+			kind,
+			threadTs
+		})
+	};
+}
 function resolveToken(params) {
 	const explicit = normalizeOptionalString(params.explicit);
 	if (explicit) return explicit;
@@ -700,8 +692,7 @@ function parseEnterpriseEventRecipient(raw) {
 		id: canonicalizeSlackApiTargetId("channel", match[1])
 	};
 }
-function resolveSlackSendEventScope(params) {
-	const scope = params.opts.eventScope;
+function resolveSlackSendEventScope(scope) {
 	if (!scope) return;
 	if (!/^T[A-Z0-9]+$/i.test(scope.teamId) || !scope.client) throw new Error("invalid_enterprise_slack_listener_scope");
 	return scope;
@@ -746,53 +737,20 @@ function resolveSlackDelivery(params) {
 		}
 	});
 }
-function resolveSlackTextChunkLimit(params) {
-	const configuredLimit = params.textLimit ?? resolveTextChunkLimit(params.cfg, "slack", params.accountId, { fallbackLimit: 8e3 });
-	return Math.min(configuredLimit, SLACK_TEXT_LIMIT);
-}
-function resolveSlackTextChunks(params) {
-	const text = params.preservePlainText ? params.text : params.text.trim();
-	const chunkLimit = resolveSlackTextChunkLimit(params);
-	if (params.preservePlainText) {
-		const chunks = [];
-		let remaining = text;
-		while (remaining) {
-			const chunk = sliceUtf16Safe(remaining, 0, chunkLimit) || truncateCodePoints(remaining, 1);
-			chunks.push(chunk);
-			remaining = remaining.slice(chunk.length);
-		}
-		return chunks;
-	}
-	if (params.textIsSlackMrkdwn) return resolveTextChunksWithFallback(text, chunkSlackMrkdwnText(text, chunkLimit));
-	const tableMode = resolveMarkdownTableMode({
-		cfg: params.cfg,
-		channel: "slack",
-		...params.accountId ? { accountId: params.accountId } : {}
-	});
-	const chunkMode = resolveChunkMode(params.cfg, "slack", params.accountId);
-	const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(text, chunkLimit, chunkMode) : [text]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode }));
-	return resolveTextChunksWithFallback(text, chunks);
-}
 function createSlackSendQueueKey(params) {
 	const recipientKey = `${params.recipient.kind}:${params.recipient.id}`;
 	const workspaceScope = params.teamId ? `:${params.teamId}` : "";
 	return `${params.accountId}:${createSlackTokenCacheKey(params.token)}${workspaceScope}:${recipientKey}:${params.threadTs ?? ""}`;
 }
-async function runQueuedSlackSend(key, task) {
-	return await slackSendQueue.enqueue(key, task);
-}
-function isSlackUserRecipient(recipient) {
-	return recipient.kind === "user";
-}
 function resolveDirectUserPostChannelId(params) {
-	if (!isSlackUserRecipient(params.recipient) || params.hasMedia || params.threadTs) return;
+	if (params.recipient.kind !== "user" || params.hasMedia || params.threadTs) return;
 	return params.recipient.id;
 }
 function resolvePostedMessageChannelId(response, fallback) {
 	return (typeof response.channel === "string" ? normalizeOptionalString(response.channel) : null) ?? fallback;
 }
 async function resolveChannelId(client, recipient, params) {
-	if (!isSlackUserRecipient(recipient)) return { channelId: recipient.id };
+	if (recipient.kind !== "user") return { channelId: recipient.id };
 	const cacheParams = {
 		cacheOwner: params.dmCacheOwner ?? client,
 		accountId: params.accountId,
@@ -814,6 +772,24 @@ async function resolveChannelId(client, recipient, params) {
 		cacheHit: false
 	};
 }
+function resolveSlackTextChunkLimit(params) {
+	const configuredLimit = params.textLimit ?? resolveTextChunkLimit(params.cfg, "slack", params.accountId, { fallbackLimit: 8e3 });
+	return Math.min(configuredLimit, SLACK_TEXT_LIMIT);
+}
+function resolveSlackTextChunks(params) {
+	const text = params.preservePlainText ? params.text : params.text.trim();
+	const chunkLimit = resolveSlackTextChunkLimit(params);
+	if (params.preservePlainText) return text ? chunkTextForOutbound(text, chunkLimit, { preserveWhitespace: true }) : [];
+	if (params.textIsSlackMrkdwn) return resolveTextChunksWithFallback(text, chunkSlackMrkdwnText(text, chunkLimit));
+	const tableMode = resolveMarkdownTableMode({
+		cfg: params.cfg,
+		channel: "slack",
+		...params.accountId ? { accountId: params.accountId } : {}
+	});
+	const chunkMode = resolveChunkMode(params.cfg, "slack", params.accountId);
+	const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(text, chunkLimit, chunkMode) : [text]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode }));
+	return resolveTextChunksWithFallback(text, chunks);
+}
 async function resolveSlackDmChannelId(params) {
 	return (await resolveChannelId(params.client, {
 		kind: "user",
@@ -915,22 +891,18 @@ async function scanSlackConversationForDelivery(params) {
 	let expectedPartCount;
 	const deliveryParts = /* @__PURE__ */ new Map();
 	for (let page = 0; page < SLACK_RECONCILE_MAX_PAGES; page += 1) {
-		const response = threadTs ? await withSlackDnsRequestRetry("conversations.replies", () => params.client.conversations.replies({
-			channel: params.channelId,
-			ts: threadTs,
-			oldest: params.oldest,
-			latest: params.latest,
-			include_all_metadata: true,
-			limit: SLACK_RECONCILE_LIMIT,
-			...cursor ? { cursor } : {}
-		})) : await withSlackDnsRequestRetry("conversations.history", () => params.client.conversations.history({
+		const query = {
 			channel: params.channelId,
 			oldest: params.oldest,
 			latest: params.latest,
 			include_all_metadata: true,
 			limit: SLACK_RECONCILE_LIMIT,
 			...cursor ? { cursor } : {}
-		}));
+		};
+		const response = threadTs ? await withSlackDnsRequestRetry("conversations.replies", () => params.client.conversations.replies({
+			...query,
+			ts: threadTs
+		})) : await withSlackDnsRequestRetry("conversations.history", () => params.client.conversations.history(query));
 		const matches = findSlackConversationDeliveryParts({
 			messages: asSlackConversationMessages(response),
 			queueId: params.queueId,
@@ -952,16 +924,7 @@ async function scanSlackConversationForDelivery(params) {
 			deliveryParts.set(match.partIndex, match);
 		}
 		if (expectedPartCount !== void 0 && deliveryParts.size === expectedPartCount) {
-			const orderedParts = Array.from({ length: expectedPartCount }, (_, index) => deliveryParts.get(index));
-			if (orderedParts.some((part) => !part)) return {
-				reconciliation: {
-					status: "unresolved",
-					error: "Slack history contains an invalid durable delivery marker set",
-					retryable: false
-				},
-				evidence: "conflict"
-			};
-			const completeParts = orderedParts;
+			const completeParts = [...deliveryParts.values()].toSorted((a, b) => a.partIndex - b.partIndex);
 			const reconciledThreadTs = completeParts[0]?.threadTs ?? params.threadTs;
 			const platformMessageIds = completeParts.map((part) => part.messageId);
 			return {
@@ -1029,7 +992,7 @@ async function reconcileSlackUnknownSend(ctx) {
 		error: `Slack read token missing for account "${account.accountId}"`,
 		retryable: false
 	};
-	const userRecipient = isSlackUserRecipient(recipient);
+	const userRecipient = recipient.kind === "user";
 	const writeToken = resolveSlackOperationToken(account, "write");
 	if (userRecipient && !writeToken) return {
 		status: "unresolved",
@@ -1092,7 +1055,7 @@ async function sendMessageSlack(to, message, opts) {
 		cfg,
 		accountId: opts.accountId
 	});
-	const eventScope = resolveSlackSendEventScope({ opts });
+	const eventScope = resolveSlackSendEventScope(opts.eventScope);
 	const recipient = eventScope ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
 	if (!eventScope) assertSlackDetachedTargetAllowed(account.accountId, recipient.teamId);
 	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
@@ -1104,32 +1067,28 @@ async function sendMessageSlack(to, message, opts) {
 		opts: queuedOpts,
 		recipient
 	});
-	const result = await runQueuedSlackSend(createSlackSendQueueKey({
+	const queueKey = createSlackSendQueueKey({
 		accountId: account.accountId,
 		token: delivery.credential,
 		recipient: delivery.recipient,
 		threadTs: opts.threadTs,
 		teamId: delivery.teamId
-	}), () => sendMessageSlackQueued({
+	});
+	const result = await slackSendQueue.enqueue(queueKey, () => sendMessageSlackQueued({
 		trimmedMessage,
 		opts: queuedOpts,
 		cfg,
 		account,
 		blocks,
 		delivery
+	}).catch((err) => {
+		throw enrichSlackWebApiError(err);
 	}));
 	const threadTs = result.threadTs ?? normalizeSlackThreadTsCandidate(queuedOpts.threadTs);
 	if (threadTs && result.channelId && account.accountId) recordSlackThreadParticipation(account.accountId, result.channelId, threadTs, { teamId: delivery.teamId });
 	return result;
 }
 async function sendMessageSlackQueued(params) {
-	try {
-		return await sendMessageSlackQueuedInner(params);
-	} catch (err) {
-		throw enrichSlackWebApiError(err);
-	}
-}
-async function sendMessageSlackQueuedInner(params) {
 	const { opts, cfg, account, blocks, trimmedMessage, delivery } = params;
 	const { client, identity, recipient, unfurl } = delivery;
 	if (opts.replyBroadcast && opts.mediaUrl) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
@@ -1179,20 +1138,36 @@ async function sendMessageSlackQueuedInner(params) {
 		blocks,
 		textLimit: textChunkLimit
 	}) : void 0;
-	const orderedBlockAccessibilityText = blocks && usesOrderedBlockAccessibility ? orderedBlockDeliveryPlan?.accessibilityText ?? (buildSlackNativeDataAccessibilityText(nativeDataFallbackBase, blocks) || "Slack could not render this Block Kit message.") : void 0;
 	const completeBlockFallbackText = blocks ? buildSlackCompleteBlocksFallbackText(blocks) : "";
 	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 blockAccessibilityText = blocks ? orderedBlockDeliveryPlan?.accessibilityText ?? rawBlockAccessibilityText : void 0;
+	let pendingBlockFallback = orderedBlockDeliveryPlan?.skipOriginalBlocks ? orderedBlockDeliveryPlan : void 0;
 	let lastMessageId = "";
 	let deliveredChannelId = channelId;
 	let canonicalDeliveredThreadTs;
 	let sendIdentity = identity;
+	const postPart = async (part) => {
+		const posted = await postSlackMessageBestEffort({
+			client,
+			channelId,
+			threadTs: opts.threadTs,
+			identity: sendIdentity,
+			unfurl,
+			...part
+		});
+		const { response } = posted;
+		sendIdentity = posted.identity;
+		lastMessageId = response.ts;
+		deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
+		const responseThreadTs = resolvePostedMessageThreadTs(response);
+		canonicalDeliveredThreadTs ??= responseThreadTs;
+		return await reportDelivery(createSlackSendResult(response.ts, deliveredChannelId, part.blocks ? "card" : "text", responseThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs)), part.blocks);
+	};
 	if (blocks && opts.mediaUrl) throw new Error("Slack send does not support blocks with mediaUrl");
 	if (blocks) {
 		if (pendingBlockFallback) logVerbose("slack send: native data accessibility exceeds hard limit, using text fallback");
 		else {
-			const accessibilityText = hasNativeData ? blockAccessibilityText ?? "Slack could not render this Block Kit message." : usesOrderedBlockAccessibility ? blockAccessibilityText ?? "Slack could not render this Block Kit message." : truncateSlackText(blockAccessibilityText ?? "", SLACK_TEXT_LIMIT);
+			const accessibilityText = usesOrderedBlockAccessibility ? blockAccessibilityText ?? "Slack could not render this Block Kit message." : truncateSlackText(blockAccessibilityText ?? "", SLACK_TEXT_LIMIT);
 			const initialBlockMetadata = withSlackDeliveryMetadata(opts.metadata, {
 				queueId: opts.deliveryQueueId,
 				channelId,
@@ -1202,32 +1177,13 @@ async function sendMessageSlackQueuedInner(params) {
 			});
 			await dispatchOnce();
 			try {
-				const { response } = await postSlackMessageBestEffort({
-					client,
-					channelId,
+				return await postPart({
 					text: accessibilityText,
-					threadTs: opts.threadTs,
 					replyBroadcast: opts.replyBroadcast,
-					identity,
 					blocks,
 					metadata: initialBlockMetadata,
-					...usesOrderedBlockAccessibility ? { mrkdwn: false } : {},
-					unfurl
+					...usesOrderedBlockAccessibility ? { mrkdwn: false } : {}
 				});
-				const messageId = response.ts;
-				deliveredChannelId = resolvePostedMessageChannelId(response, channelId);
-				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
-				return await reportDelivery({
-					messageId,
-					channelId: deliveredChannelId,
-					threadTs: deliveredThreadTs,
-					receipt: createSlackSendReceipt({
-						platformMessageIds: [messageId],
-						channelId: deliveredChannelId,
-						kind: "card",
-						threadTs: deliveredThreadTs
-					})
-				}, blocks);
 			} catch (error) {
 				if (!hasNativeData || !isSlackInvalidBlocksError(error)) throw error;
 				logVerbose("slack send: native data rejected, delivering complete text fallback");
@@ -1246,35 +1202,13 @@ async function sendMessageSlackQueuedInner(params) {
 					partCount: fallbackMessages.length
 				});
 				if (partIndex === 0) await dispatchOnce();
-				const posted = await postSlackMessageBestEffort({
-					client,
-					channelId,
+				const fallbackDelivery = await postPart({
 					text: fallback.text,
-					threadTs: opts.threadTs,
 					replyBroadcast: partIndex === 0 ? opts.replyBroadcast : void 0,
-					identity: sendIdentity,
 					...fallback.blocks ? { blocks: fallback.blocks } : {},
 					metadata,
-					mrkdwn: false,
-					unfurl
+					mrkdwn: false
 				});
-				const response = posted.response;
-				sendIdentity = posted.identity;
-				lastMessageId = response.ts;
-				deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
-				canonicalDeliveredThreadTs ??= resolvePostedMessageThreadTs(response);
-				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
-				const fallbackDelivery = await reportDelivery({
-					messageId: response.ts,
-					channelId: deliveredChannelId,
-					threadTs: deliveredThreadTs,
-					receipt: createSlackSendReceipt({
-						platformMessageIds: [response.ts],
-						channelId: deliveredChannelId,
-						kind: fallback.blocks ? "card" : "text",
-						threadTs: deliveredThreadTs
-					})
-				}, fallback.blocks);
 				if (fallbackDelivery.meta?.slackQuestionActionIds.length) questionDelivery = fallbackDelivery;
 			}
 			const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
@@ -1320,17 +1254,7 @@ async function sendMessageSlackQueuedInner(params) {
 			assertDirectAdapterHandoff: opts.assertDirectAdapterHandoff,
 			...delivery.upload ? { auditContext: delivery.upload.auditContext } : {}
 		});
-		await reportDelivery({
-			messageId: lastMessageId,
-			channelId,
-			threadTs: normalizeSlackThreadTsCandidate(opts.threadTs),
-			receipt: createSlackSendReceipt({
-				platformMessageIds: [lastMessageId],
-				channelId,
-				kind: "media",
-				threadTs: normalizeSlackThreadTsCandidate(opts.threadTs)
-			})
-		});
+		await reportDelivery(createSlackSendResult(lastMessageId, channelId, "media", normalizeSlackThreadTsCandidate(opts.threadTs)));
 		chunksToPost = rest;
 	} else chunksToPost = resolvedChunks.length ? resolvedChunks : [""];
 	for (const [partIndex, chunk] of chunksToPost.entries()) {
@@ -1344,32 +1268,11 @@ async function sendMessageSlackQueuedInner(params) {
 			partCount: chunksToPost.length
 		});
 		if (partIndex === 0 && !opts.mediaUrl) await dispatchOnce();
-		const posted = await postSlackMessageBestEffort({
-			client,
-			channelId,
+		await postPart({
 			text: chunk,
-			threadTs: opts.threadTs,
 			replyBroadcast: carriesPrimaryMessageOptions ? opts.replyBroadcast : void 0,
-			identity: sendIdentity,
 			metadata,
-			...opts.textIsSlackPlainText ? { mrkdwn: false } : {},
-			unfurl
-		});
-		const response = posted.response;
-		sendIdentity = posted.identity;
-		lastMessageId = response.ts;
-		deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
-		canonicalDeliveredThreadTs ??= resolvePostedMessageThreadTs(response);
-		await reportDelivery({
-			messageId: 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)
-			})
+			...opts.textIsSlackPlainText ? { mrkdwn: false } : {}
 		});
 	}
 	const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
@@ -1381,4 +1284,4 @@ async function sendMessageSlackQueuedInner(params) {
 	};
 }
 //#endregion
-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 };
+export { clearSlackThreadParticipationCache as a, hasSlackThreadParticipationWithPersistence as c, requireSlackPostMessageTimestamp as d, buildSlackMessageIdentityPayload as f, clearSlackThreadFailureNotice as i, recordSlackThreadFailureNotice as l, chunkSlackTextAtHardLimit as m, send_exports as n, hasSlackThreadFailureNotice as o, buildSlackNativeDataDeliveryPlan as p, setSlackDefaultSendIdentity as r, hasSlackThreadParticipation as s, sendMessageSlack as t, recordSlackThreadParticipation as u };