@openclaw/slack 2026.10.1 → 2026.10.5-beta.1

package/dist/.setup/{send-CgPI3Zj8.mjs → send-CLmsR42r.mjs}

@@ -1,16 +1,15 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { d as resolveSlackOperationToken, s as resolveSlackAccount } from "./accounts-CDgkV7Cm.mjs";
+import { d as resolveSlackOperationToken, s as resolveSlackAccount } from "./accounts-BMg9YLIv.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, J as markdownToSlackMrkdwnChunks, M as truncateSlackTextByUtf8Bytes, O as SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT, P as SLACK_QUESTION_FINALIZATION_BLOCKS, S as stripSlackNativeDataBlocks, T as renderSlackBlockFallbackText, U as resolveSlackQuestionActionIds, _ as createSlackNativeDataBaseTextConsumer, f as assertSlackDetachedTargetAllowed, g as buildSlackNativeDataAccessibilityText, h as appendSlackNativeDataPlainTextFallback, ht as validateSlackBlocksArray, j as truncateSlackText, k as SLACK_TEXT_LIMIT, q as chunkSlackMrkdwnText, v as hasSlackNativeDataBlock, w as buildSlackCompleteBlocksFallbackText, y as isSlackInvalidBlocksError } from "./session-status-D46GHwOV.mjs";
-import { _ as getSlackWriteClient, d as createSlackReadClient, h as createSlackWriteClient, o as formatSlackError, p as createSlackTokenCacheKey, s as getSlackWebApiErrorData } from "./probe-BVlJ3dp0.mjs";
+import { A as SLACK_TEXT_LIMIT, C as stripSlackNativeDataBlocks, D as SLACK_EDIT_TEXT_MAX_BYTES, E as renderSlackBlockFallbackText, F as SLACK_QUESTION_FINALIZATION_BLOCKS, J as chunkSlackMrkdwnText, M as truncateSlackText, N as truncateSlackTextByUtf8Bytes, O as SLACK_MESSAGE_TEXT_HARD_LIMIT, S as renderSlackNativeDataPlainTextBlock, T as buildSlackCompleteBlocksFallbackText, W as resolveSlackQuestionActionIds, Y as markdownToSlackMrkdwnChunks, _ as createSlackNativeDataBaseTextConsumer, f as assertSlackDetachedTargetAllowed, g as buildSlackNativeDataAccessibilityText, k as SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT, mt as validateSlackBlocksArray, v as hasSlackNativeDataBlock, y as isSlackInvalidBlocksError } from "./session-status-CcXe10zN.mjs";
+import { _ as getSlackWriteClient, b as writeLruMapEntry, d as createSlackReadClient, h as createSlackWriteClient, o as formatSlackError, p as createSlackTokenCacheKey, s as getSlackWebApiErrorData } from "./probe-CyX52GtD.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 { asOptionalObjectRecord, asOptionalRecord, 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 { 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";
@@ -35,47 +34,7 @@ function chunkSlackTextAtHardLimit(text, limit = SLACK_MESSAGE_TEXT_HARD_LIMIT)
 	if (!text) return [];
 	return chunkTextForOutbound(text, Math.max(1, Math.floor(limit)), { preserveWhitespace: true });
 }
-function buildPlainTextBlocks(text, textLimit) {
-	return chunkSlackTextAtHardLimit(text, Math.min(textLimit, SLACK_SECTION_PLAIN_TEXT_MAX)).map((chunk, index) => {
-		const fallbackBlock = {
-			block: {
-				type: "section",
-				text: {
-					type: "plain_text",
-					text: chunk
-				}
-			},
-			text: chunk
-		};
-		if (index > 0) fallbackBlock.continuesText = true;
-		return fallbackBlock;
-	});
-}
-function renderNativeDataPlainText(block) {
-	return appendSlackNativeDataPlainTextFallback("", [block]).trim() || "Slack could not render this chart or table data.";
-}
-function buildOrderedFallbackBlocks(params) {
-	const entries = [];
-	const consumeFromBase = createSlackNativeDataBaseTextConsumer(params.baseText);
-	if (params.baseText) entries.push(...buildPlainTextBlocks(params.baseText, params.textLimit));
-	for (const block of params.blocks) {
-		if (hasSlackNativeDataBlock([block])) {
-			const nativeText = renderNativeDataPlainText(block);
-			if (!consumeFromBase(nativeText)) entries.push(...buildPlainTextBlocks(nativeText, params.textLimit));
-			continue;
-		}
-		const text = truncateSlackText(renderSlackBlockFallbackText(block, {
-			nativeDataFormat: "plain",
-			includeSelectOptions: true
-		}) ?? "", SLACK_MESSAGE_TEXT_HARD_LIMIT);
-		entries.push({
-			block,
-			...text ? { text } : {}
-		});
-	}
-	return entries;
-}
-function buildOrderedBlockMessages(entries, textLimit) {
+function buildOrderedBlockMessages(params) {
 	const messages = [];
 	let blocks = [];
 	let text = "";
@@ -89,14 +48,38 @@ function buildOrderedBlockMessages(entries, textLimit) {
 		blocks = [];
 		text = "";
 	};
-	for (const entry of entries) {
-		const separator = text && entry.text && !entry.continuesText ? "\n\n" : "";
-		const nextText = entry.text ? `${text}${separator}${entry.text}` : text;
-		if (blocks.length >= 50 || nextText.length > textLimit) flush();
-		const freshSeparator = text && entry.text && !entry.continuesText ? "\n\n" : "";
-		const freshText = entry.text ? `${text}${freshSeparator}${entry.text}` : text;
-		blocks.push(entry.block);
-		text = freshText;
+	const append = (block, entryText = "", continuesText = false) => {
+		let nextText = entryText ? `${text}${text && entryText && !continuesText ? "\n\n" : ""}${entryText}` : text;
+		if (blocks.length >= 50 || nextText.length > params.textLimit) {
+			flush();
+			nextText = entryText;
+		}
+		blocks.push(block);
+		text = nextText;
+	};
+	const appendPlainText = (value) => {
+		chunkSlackTextAtHardLimit(value, Math.min(params.textLimit, SLACK_SECTION_PLAIN_TEXT_MAX)).forEach((chunk, index) => {
+			append({
+				type: "section",
+				text: {
+					type: "plain_text",
+					text: chunk
+				}
+			}, chunk, index > 0);
+		});
+	};
+	const consumeFromBase = createSlackNativeDataBaseTextConsumer(params.baseText);
+	appendPlainText(params.baseText);
+	for (const block of params.blocks) {
+		if (hasSlackNativeDataBlock([block])) {
+			const nativeText = renderSlackNativeDataPlainTextBlock(block)?.trim() || "Slack could not render this chart or table data.";
+			if (!consumeFromBase(nativeText)) appendPlainText(nativeText);
+			continue;
+		}
+		append(block, truncateSlackText(renderSlackBlockFallbackText(block, {
+			nativeDataFormat: "plain",
+			includeSelectOptions: true
+		}) ?? "", SLACK_MESSAGE_TEXT_HARD_LIMIT));
 	}
 	flush();
 	return messages;
@@ -110,11 +93,11 @@ function buildSlackNativeDataDeliveryPlan(params) {
 	const fallbackMessages = stripSlackNativeDataBlocks(params.blocks).length === 0 ? chunkSlackTextAtHardLimit(accessibilityText, textLimit).map((text) => ({
 		text,
 		mrkdwn: false
-	})) : buildOrderedBlockMessages(buildOrderedFallbackBlocks({
+	})) : buildOrderedBlockMessages({
 		baseText,
 		blocks: params.blocks,
 		textLimit
-	}), textLimit);
+	});
 	return {
 		accessibilityText: truncateSlackText(accessibilityText, SLACK_MESSAGE_TEXT_HARD_LIMIT),
 		fallbackMessages,
@@ -131,10 +114,10 @@ function buildSlackMessageIdentityPayload(identity) {
 }
 function classifySlackCustomIdentityError(err) {
 	const data = getSlackWebApiErrorData(err);
-	const code = normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.error));
+	const code = normalizeLowercaseStringOrEmpty(data?.error);
 	if (code === "invalid_arguments" || code === "invalid_arg_name") return "argument";
 	if (code !== "missing_scope") return;
-	if (normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.needed)).includes("chat:write.customize")) return "scope";
+	if (normalizeLowercaseStringOrEmpty(data?.needed).includes("chat:write.customize")) return "scope";
 	return [...normalizeTrimmedStringList(data?.response_metadata?.scopes), ...normalizeTrimmedStringList(data?.response_metadata?.acceptedScopes)].map((scope) => normalizeLowercaseStringOrEmpty(scope)).includes("chat:write.customize") ? "scope" : void 0;
 }
 function hasSlackMessageIdentity(identity) {
@@ -170,18 +153,11 @@ async function postSlackMessageWithIdentityFallback(params) {
 }
 //#endregion
 //#region extensions/slack/src/post-message-payload.ts
-function buildSlackUnfurlPayload(options) {
-	return {
-		unfurl_links: options?.unfurlLinks ?? false,
-		...typeof options?.unfurlMedia === "boolean" ? { unfurl_media: options.unfurlMedia } : {}
-	};
-}
 function buildSlackPostMessagePayload(params) {
 	const threadPayload = params.replyBroadcast && params.threadTs ? {
 		thread_ts: params.threadTs,
 		reply_broadcast: true
 	} : params.threadTs ? { thread_ts: params.threadTs } : {};
-	const unfurlPayload = buildSlackUnfurlPayload(params.unfurl);
 	return {
 		channel: params.channelId,
 		text: params.text,
@@ -189,7 +165,8 @@ function buildSlackPostMessagePayload(params) {
 		...params.metadata ? { metadata: params.metadata } : {},
 		...typeof params.mrkdwn === "boolean" ? { mrkdwn: params.mrkdwn } : {},
 		...threadPayload,
-		...unfurlPayload
+		unfurl_links: params.unfurl?.unfurlLinks ?? false,
+		...typeof params.unfurl?.unfurlMedia === "boolean" ? { unfurl_media: params.unfurl.unfurlMedia } : {}
 	};
 }
 //#endregion
@@ -224,31 +201,23 @@ function rethrowSlackPermanentOutboundApiRejection(err) {
 	});
 	throw err;
 }
-function readSlackRequestErrorCode(value) {
-	if (!value || typeof value !== "object") return;
-	const code = value.code;
-	return typeof code === "string" ? code.toUpperCase() : void 0;
-}
 function hasSlackDnsRequestSignal(err) {
-	let current = err;
+	let current = asOptionalObjectRecord(err);
 	const seen = /* @__PURE__ */ new Set();
-	for (let depth = 0; current && typeof current === "object" && depth < 6; depth += 1) {
+	for (let depth = 0; current && depth < 6; depth += 1) {
 		if (seen.has(current)) return false;
 		seen.add(current);
-		const code = readSlackRequestErrorCode(current);
+		const rawCode = current.code;
+		const code = typeof rawCode === "string" ? rawCode.toUpperCase() : void 0;
 		if (code && SLACK_DNS_RETRY_CODES.has(code)) return true;
 		const message = current instanceof Error ? current.message : "";
 		if (/\b(EAI_AGAIN|ENOTFOUND|UND_ERR_DNS_RESOLVE_FAILED)\b/i.test(message)) return true;
-		current = current.original ?? current.cause;
+		current = asOptionalObjectRecord(current.original ?? current.cause);
 	}
 	return false;
 }
 function resolveSlackUploadTimeoutLogUrl(url) {
-	try {
-		return new URL(url).origin;
-	} catch {
-		return;
-	}
+	return URL.parse(url)?.origin;
 }
 function buildSlackUploadFailureCause(error) {
 	const httpStatus = error instanceof Error ? /^Failed to upload file: HTTP (\d{3})$/u.exec(error.message)?.[1] : void 0;
@@ -259,30 +228,19 @@ function buildSlackUploadFailureCause(error) {
 	return cause;
 }
 function parseSlackUploadHttpUrl(value, label) {
-	try {
-		const parsed = new URL(value);
-		if (parsed.protocol === "http:" || parsed.protocol === "https:") return parsed;
-	} catch {}
+	const parsed = URL.parse(value);
+	if (parsed && (parsed.protocol === "http:" || parsed.protocol === "https:")) return parsed;
 	throw new Error(`${label} must use a valid HTTP or HTTPS URL`);
 }
 function normalizeSlackHostname(hostname) {
 	return hostname.trim().toLowerCase().replace(/\.$/, "");
 }
-function resolveSlackOwnedUploadPolicy(url) {
-	if (url.protocol !== "https:") return;
-	switch (normalizeSlackHostname(url.hostname)) {
-		case SLACK_COMMERCIAL_UPLOAD_HOSTNAME: return SLACK_COMMERCIAL_UPLOAD_SSRF_POLICY;
-		case SLACK_GOV_UPLOAD_HOSTNAME: return SLACK_GOV_UPLOAD_SSRF_POLICY;
-		default: return;
-	}
-}
-function resolveOfficialSlackApiUploadPolicy(url) {
-	if (url.protocol !== "https:" || url.port) return;
-	switch (normalizeSlackHostname(url.hostname)) {
-		case SLACK_COMMERCIAL_API_HOSTNAME: return SLACK_COMMERCIAL_UPLOAD_SSRF_POLICY;
-		case SLACK_GOV_API_HOSTNAME: return SLACK_GOV_UPLOAD_SSRF_POLICY;
-		default: return;
-	}
+function resolveSlackUploadPolicy(url, source) {
+	if (url.protocol !== "https:" || source === "api" && url.port) return;
+	const hostname = normalizeSlackHostname(url.hostname);
+	const [commercial, government] = source === "api" ? [SLACK_COMMERCIAL_API_HOSTNAME, SLACK_GOV_API_HOSTNAME] : [SLACK_COMMERCIAL_UPLOAD_HOSTNAME, SLACK_GOV_UPLOAD_HOSTNAME];
+	if (hostname === commercial) return SLACK_COMMERCIAL_UPLOAD_SSRF_POLICY;
+	if (hostname === government) return SLACK_GOV_UPLOAD_SSRF_POLICY;
 }
 function normalizeSlackOrigin(url) {
 	const port = url.port ? `:${url.port}` : "";
@@ -294,13 +252,13 @@ function resolveSlackUploadTransportPolicy(params) {
 		policy: SLACK_COMMERCIAL_UPLOAD_SSRF_POLICY
 	};
 	const apiUrl = parseSlackUploadHttpUrl(params.slackApiUrl, "Configured Slack API URL");
-	const officialApiPolicy = resolveOfficialSlackApiUploadPolicy(apiUrl);
+	const officialApiPolicy = resolveSlackUploadPolicy(apiUrl, "api");
 	if (officialApiPolicy) return {
 		requireHttps: true,
 		policy: officialApiPolicy
 	};
 	const uploadUrl = parseSlackUploadHttpUrl(params.uploadUrl, "Slack external upload URL");
-	const slackOwnedUploadPolicy = resolveSlackOwnedUploadPolicy(uploadUrl);
+	const slackOwnedUploadPolicy = resolveSlackUploadPolicy(uploadUrl, "upload");
 	if (slackOwnedUploadPolicy) return {
 		requireHttps: true,
 		policy: slackOwnedUploadPolicy
@@ -485,9 +443,7 @@ function recordSlackThreadFailureNotice(params) {
 	if (!accountId || !channelId || !fingerprint) return false;
 	const key = makeFailureNoticeKey(params);
 	if (threadFailureNotices.get(key) === fingerprint) return false;
-	threadFailureNotices.delete(key);
-	threadFailureNotices.set(key, fingerprint);
-	pruneMapToMaxSize(threadFailureNotices, MAX_FAILURE_NOTICES);
+	writeLruMapEntry(threadFailureNotices, key, fingerprint, MAX_FAILURE_NOTICES);
 	return true;
 }
 /** Clears a thread or channel outage notice after a healthy model turn completes. */
@@ -520,9 +476,7 @@ function readCachedSlackDmChannelId(params) {
 function cacheSlackDmChannelId(params, channelId) {
 	const cache = getSlackDmChannelCache(params.cacheOwner);
 	const key = createSlackDmCacheKey(params);
-	cache.delete(key);
-	cache.set(key, channelId);
-	pruneMapToMaxSize(cache, SLACK_DM_CHANNEL_CACHE_MAX);
+	writeLruMapEntry(cache, key, channelId, SLACK_DM_CHANNEL_CACHE_MAX);
 }
 //#endregion
 //#region extensions/slack/src/send.ts
@@ -563,15 +517,11 @@ function setSlackDefaultSendIdentity(accountId, identity) {
 	if (normalizedIdentity) slackDefaultSendIdentities.set(normalizedAccountId, normalizedIdentity);
 	else slackDefaultSendIdentities.delete(normalizedAccountId);
 }
-function getSlackDefaultSendIdentity(accountId) {
-	const normalizedAccountId = normalizeOptionalString(accountId);
-	return normalizedAccountId ? slackDefaultSendIdentities.get(normalizedAccountId) : void 0;
-}
-function formatSlackWebApiErrorMessage(err) {
-	if (!(err instanceof Error)) return;
+function enrichSlackWebApiError(err) {
+	if (!(err instanceof Error)) return err;
 	const data = getSlackWebApiErrorData(err);
 	const code = normalizeOptionalString(data?.error);
-	if (!code) return;
+	if (!code) return err;
 	const details = [];
 	const needed = normalizeOptionalString(data?.needed);
 	if (needed) details.push(`needed: ${needed}`);
@@ -579,12 +529,8 @@ function formatSlackWebApiErrorMessage(err) {
 	if (scopes.length) details.push(`granted: ${scopes.join(", ")}`);
 	const acceptedScopes = normalizeTrimmedStringList(data?.response_metadata?.acceptedScopes);
 	if (acceptedScopes.length) details.push(`accepted: ${acceptedScopes.join(", ")}`);
-	return `${err.message || `An API error occurred: ${code}`}${details.length ? ` (${details.join("; ")})` : ""}`;
-}
-function enrichSlackWebApiError(err) {
-	const message = formatSlackWebApiErrorMessage(err);
-	if (!message || !(err instanceof Error) || message === err.message) return err;
-	return new Error(message);
+	const message = `${err.message || `An API error occurred: ${code}`}${details.length ? ` (${details.join("; ")})` : ""}`;
+	return message === err.message ? err : new Error(message);
 }
 function readSlackRequestErrorMessage(value) {
 	if (value instanceof Error) return value.message;
@@ -616,13 +562,13 @@ async function updateMessageSlack(params) {
 function createSlackSendReceipt(params) {
 	const platformMessageIds = params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown");
 	return createMessageReceiptFromOutboundResults({
-		results: platformMessageIds.map((messageId) => {
-			const result = {
-				channel: "slack",
-				messageId
-			};
-			if (params.channelId) result.channelId = params.channelId;
-			return result;
+		results: platformMessageIds.map((messageId) => params.channelId ? {
+			channel: "slack",
+			messageId,
+			channelId: params.channelId
+		} : {
+			channel: "slack",
+			messageId
 		}),
 		kind: params.kind,
 		threadId: params.threadTs
@@ -680,11 +626,6 @@ function parseEnterpriseEventRecipient(raw) {
 		id: canonicalizeSlackApiTargetId("channel", match[1])
 	};
 }
-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;
-}
 function resolveSlackDelivery(params) {
 	if (params.eventScope) {
 		if (!params.eventScope.writeClient) throw new Error("missing_enterprise_slack_write_client");
@@ -713,7 +654,7 @@ function resolveSlackDelivery(params) {
 		client,
 		...client !== cachedClient ? { dmCacheOwner: cachedClient } : {},
 		credential,
-		identity: normalizeSlackSendIdentity(params.opts.identity) ?? getSlackDefaultSendIdentity(params.account.accountId),
+		identity: normalizeSlackSendIdentity(params.opts.identity) ?? slackDefaultSendIdentities.get(params.account.accountId),
 		recipient: params.recipient,
 		teamId: params.recipient.teamId,
 		unfurl: params.recipient.teamId ? { unfurlMedia: params.account.config.unfurlMedia } : {
@@ -722,16 +663,8 @@ function resolveSlackDelivery(params) {
 		}
 	});
 }
-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 ?? ""}`;
-}
-function resolvePostedMessageChannelId(response, fallback) {
-	return (typeof response.channel === "string" ? normalizeOptionalString(response.channel) : null) ?? fallback;
-}
 async function resolveChannelId(client, recipient, params) {
-	if (recipient.kind !== "user") return { channelId: recipient.id };
+	if (recipient.kind !== "user") return recipient.id;
 	const cacheParams = {
 		cacheOwner: params.dmCacheOwner ?? client,
 		accountId: params.accountId,
@@ -739,19 +672,15 @@ async function resolveChannelId(client, recipient, params) {
 		recipientId: recipient.id
 	};
 	const cachedChannelId = readCachedSlackDmChannelId(cacheParams);
-	if (cachedChannelId) return { channelId: cachedChannelId };
+	if (cachedChannelId) return cachedChannelId;
 	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");
 	cacheSlackDmChannelId(cacheParams, channelId);
-	return { channelId };
-}
-function resolveSlackTextChunkLimit(params) {
-	const configuredLimit = params.textLimit ?? resolveTextChunkLimit(params.cfg, "slack", params.accountId, { fallbackLimit: 8e3 });
-	return Math.min(configuredLimit, SLACK_TEXT_LIMIT);
+	return channelId;
 }
 function resolveSlackTextChunks(params) {
-	const text = params.preservePlainText ? params.text : params.text.trim();
-	const chunkLimit = resolveSlackTextChunkLimit(params);
+	const text = params.text;
+	const chunkLimit = params.chunkLimit;
 	if (params.preservePlainText) return text ? chunkTextForOutbound(text, chunkLimit, { preserveWhitespace: true }) : [];
 	if (params.textIsSlackMrkdwn) return resolveTextChunksWithFallback(text, chunkSlackMrkdwnText(text, chunkLimit));
 	const tableMode = resolveMarkdownTableMode({
@@ -764,13 +693,13 @@ function resolveSlackTextChunks(params) {
 	return resolveTextChunksWithFallback(text, chunks);
 }
 async function resolveSlackDmChannelId(params) {
-	return (await resolveChannelId(params.client, {
+	return await resolveChannelId(params.client, {
 		kind: "user",
 		id: params.userId
 	}, {
 		accountId: params.accountId,
 		token: params.token
-	})).channelId;
+	});
 }
 function createSlackDeliveryMetadataId(queueId) {
 	const normalized = normalizeOptionalString(queueId);
@@ -820,6 +749,13 @@ function formatSlackTimestampFromMs(ms) {
 function asSlackConversationMessages(response) {
 	return Array.isArray(response.messages) ? response.messages.filter((message) => typeof message === "object" && message !== null && !Array.isArray(message)) : [];
 }
+function unresolvedSlackDelivery(error, retryable) {
+	return {
+		status: "unresolved",
+		error,
+		retryable
+	};
+}
 const SLACK_RECONCILIATION_EVIDENCE_RANK = {
 	none: 0,
 	partial: 1,
@@ -829,11 +765,8 @@ const SLACK_RECONCILIATION_EVIDENCE_RANK = {
 function findSlackConversationDeliveryParts(params) {
 	const matches = [];
 	for (const message of params.messages) {
-		if (!message.metadata || typeof message.metadata !== "object" || Array.isArray(message.metadata)) continue;
-		const eventPayload = message.metadata.event_payload;
-		if (!eventPayload || typeof eventPayload !== "object" || Array.isArray(eventPayload)) continue;
-		const marker = eventPayload;
-		if (marker[SLACK_DELIVERY_METADATA_KEY] !== params.deliveryId) continue;
+		const marker = asOptionalRecord(asOptionalRecord(message.metadata)?.event_payload);
+		if (!marker || marker[SLACK_DELIVERY_METADATA_KEY] !== params.deliveryId) continue;
 		const partIndex = marker[SLACK_DELIVERY_METADATA_PART_INDEX_KEY];
 		const partCount = marker[SLACK_DELIVERY_METADATA_PART_COUNT_KEY];
 		if (typeof partIndex !== "number" || !Number.isInteger(partIndex) || typeof partCount !== "number" || !Number.isInteger(partCount) || partIndex < 0 || partCount <= 0 || partIndex >= partCount) continue;
@@ -887,11 +820,7 @@ async function scanSlackConversationForDelivery(params) {
 			expectedPartCount ??= match.partCount;
 			const existing = deliveryParts.get(match.partIndex);
 			if (expectedPartCount !== match.partCount || existing && existing.messageId !== match.messageId) return {
-				reconciliation: {
-					status: "unresolved",
-					error: "Slack history contains conflicting durable delivery markers",
-					retryable: false
-				},
+				reconciliation: unresolvedSlackDelivery("Slack history contains conflicting durable delivery markers", false),
 				evidence: "conflict"
 			};
 			deliveryParts.set(match.partIndex, match);
@@ -918,22 +847,14 @@ async function scanSlackConversationForDelivery(params) {
 		if (!nextCursor) {
 			if (response.has_more === true) break;
 			return {
-				reconciliation: {
-					status: "unresolved",
-					error: deliveryParts.size > 0 ? "Slack history contains an incomplete durable delivery marker set" : "Slack history contains no exact durable delivery marker",
-					retryable: params.retryCount < 2
-				},
+				reconciliation: unresolvedSlackDelivery(deliveryParts.size > 0 ? "Slack history contains an incomplete durable delivery marker set" : "Slack history contains no exact durable delivery marker", params.retryCount < 2),
 				evidence: deliveryParts.size > 0 ? "partial" : "none"
 			};
 		}
 		cursor = nextCursor;
 	}
 	return {
-		reconciliation: {
-			status: "unresolved",
-			error: "Slack unknown-send reconciliation exceeded its history page budget",
-			retryable: params.retryCount < 2
-		},
+		reconciliation: unresolvedSlackDelivery("Slack unknown-send reconciliation exceeded its history page budget", params.retryCount < 2),
 		evidence: deliveryParts.size > 0 ? "partial" : "none"
 	};
 }
@@ -944,34 +865,18 @@ async function reconcileSlackUnknownSend(ctx) {
 		accountId: ctx.accountId ?? void 0
 	});
 	const deliveryId = createSlackDeliveryMetadataId(ctx.queueId);
-	if (!deliveryId) return {
-		status: "unresolved",
-		error: "Slack unknown-send reconciliation requires a durable delivery id",
-		retryable: false
-	};
+	if (!deliveryId) return unresolvedSlackDelivery("Slack unknown-send reconciliation requires a durable delivery id", false);
 	const recipient = parseRecipient(ctx.to);
 	try {
 		assertSlackDetachedTargetAllowed(account.accountId, recipient.teamId);
 	} catch (error) {
-		return {
-			status: "unresolved",
-			error: error instanceof Error ? error.message : String(error),
-			retryable: false
-		};
+		return unresolvedSlackDelivery(error instanceof Error ? error.message : String(error), false);
 	}
 	const readToken = resolveSlackOperationToken(account, "read");
-	if (!readToken) return {
-		status: "unresolved",
-		error: `Slack read token missing for account "${account.accountId}"`,
-		retryable: false
-	};
+	if (!readToken) return unresolvedSlackDelivery(`Slack read token missing for account "${account.accountId}"`, false);
 	const userRecipient = recipient.kind === "user";
 	const writeToken = resolveSlackOperationToken(account, "write");
-	if (userRecipient && !writeToken) return {
-		status: "unresolved",
-		error: `Slack write token missing for direct-message reconciliation on account "${account.accountId}"`,
-		retryable: false
-	};
+	if (userRecipient && !writeToken) return unresolvedSlackDelivery(`Slack write token missing for direct-message reconciliation on account "${account.accountId}"`, false);
 	const readClient = createSlackReadClient(readToken, { teamId: recipient.teamId });
 	const writeClient = writeToken ? getSlackWriteClient(writeToken, { teamId: recipient.teamId }) : void 0;
 	const payloadReplyToId = ctx.payloads[0]?.replyToId;
@@ -987,7 +892,7 @@ async function reconcileSlackUnknownSend(ctx) {
 		const channelClient = userRecipient ? writeClient : readClient;
 		const channelToken = userRecipient ? writeToken : readToken;
 		if (!channelClient || !channelToken) throw new Error(`Slack channel resolution token missing for account "${account.accountId}"`);
-		const { channelId } = await resolveChannelId(channelClient, recipient, {
+		const channelId = await resolveChannelId(channelClient, recipient, {
 			accountId: account.accountId,
 			token: channelToken
 		});
@@ -1013,11 +918,7 @@ async function reconcileSlackUnknownSend(ctx) {
 		if (bestUnresolvedScan) return bestUnresolvedScan.reconciliation;
 		throw lookupError;
 	} catch (err) {
-		return {
-			status: "unresolved",
-			error: readSlackRequestErrorMessage(enrichSlackWebApiError(err)),
-			retryable: ctx.retryCount < 3
-		};
+		return unresolvedSlackDelivery(readSlackRequestErrorMessage(enrichSlackWebApiError(err)), ctx.retryCount < 3);
 	}
 }
 async function sendMessageSlack(to, message, opts) {
@@ -1028,7 +929,8 @@ async function sendMessageSlack(to, message, opts) {
 		cfg,
 		accountId: opts.accountId
 	});
-	const eventScope = resolveSlackSendEventScope(opts.eventScope);
+	const eventScope = opts.eventScope;
+	if (eventScope && (!/^T[A-Z0-9]+$/i.test(eventScope.teamId) || !eventScope.client)) throw new Error("invalid_enterprise_slack_listener_scope");
 	const recipient = eventScope ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
 	if (!eventScope) assertSlackDetachedTargetAllowed(account.accountId, recipient.teamId);
 	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
@@ -1040,13 +942,8 @@ async function sendMessageSlack(to, message, opts) {
 		opts: queuedOpts,
 		recipient
 	});
-	const queueKey = createSlackSendQueueKey({
-		accountId: account.accountId,
-		token: delivery.credential,
-		recipient: delivery.recipient,
-		threadTs: opts.threadTs,
-		teamId: delivery.teamId
-	});
+	const workspaceScope = delivery.teamId ? `:${delivery.teamId}` : "";
+	const queueKey = `${account.accountId}:${createSlackTokenCacheKey(delivery.credential)}${workspaceScope}:${delivery.recipient.kind}:${delivery.recipient.id}:${opts.threadTs ?? ""}`;
 	const result = await slackSendQueue.enqueue(queueKey, () => sendMessageSlackQueued({
 		trimmedMessage,
 		opts: queuedOpts,
@@ -1066,7 +963,7 @@ async function sendMessageSlackQueued(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.");
 	const directUserPostChannelId = !opts.deliveryQueueId && recipient.kind === "user" && !opts.mediaUrl && !opts.threadTs ? recipient.id : void 0;
-	const { channelId } = directUserPostChannelId ? { channelId: directUserPostChannelId } : await resolveChannelId(client, recipient, {
+	const channelId = directUserPostChannelId ? directUserPostChannelId : await resolveChannelId(client, recipient, {
 		accountId: account.accountId,
 		token: delivery.credential,
 		...delivery.dmCacheOwner ? { dmCacheOwner: delivery.dmCacheOwner } : {}
@@ -1096,11 +993,7 @@ async function sendMessageSlackQueued(params) {
 	const authoredTextPlacement = opts.authoredTextPlacement ?? "outside-blocks";
 	const nativeDataFallbackBase = blocks && authoredTextPlacement === "outside-blocks" ? explicitNativeDataFallbackBase ?? trimmedMessage : "";
 	const hasNativeData = Boolean(blocks && hasSlackNativeDataBlock(blocks));
-	const textChunkLimit = resolveSlackTextChunkLimit({
-		cfg,
-		accountId: account.accountId,
-		...opts.textLimit !== void 0 ? { textLimit: opts.textLimit } : {}
-	});
+	const textChunkLimit = Math.min(opts.textLimit ?? resolveTextChunkLimit(cfg, "slack", account.accountId, { fallbackLimit: 8e3 }), SLACK_TEXT_LIMIT);
 	const usesOrderedBlockAccessibility = Boolean(blocks && (hasNativeData || opts.authoredTextPlacement !== void 0));
 	const orderedBlockDeliveryPlan = blocks && usesOrderedBlockAccessibility ? buildSlackNativeDataDeliveryPlan({
 		baseText: nativeDataFallbackBase,
@@ -1127,7 +1020,7 @@ async function sendMessageSlackQueued(params) {
 		const { response } = posted;
 		sendIdentity = posted.identity;
 		lastMessageId = response.ts;
-		deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
+		deliveredChannelId = (typeof response.channel === "string" ? normalizeOptionalString(response.channel) : null) ?? deliveredChannelId;
 		const responseThreadTs = resolvePostedMessageThreadTs(response);
 		canonicalDeliveredThreadTs ??= responseThreadTs;
 		return await reportDelivery(createSlackSendResult(response.ts, deliveredChannelId, part.blocks ? "card" : "text", responseThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs)), part.blocks);
@@ -1159,74 +1052,50 @@ async function sendMessageSlackQueued(params) {
 				pendingBlockFallback = orderedBlockDeliveryPlan;
 			}
 		}
-		if (pendingBlockFallback) {
-			const fallbackMessages = pendingBlockFallback.fallbackMessages;
-			let questionDelivery;
-			for (const [partIndex, fallback] of fallbackMessages.entries()) {
-				const metadata = withSlackDeliveryMetadata(partIndex === 0 ? opts.metadata : void 0, {
-					queueId: opts.deliveryQueueId,
-					channelId,
-					threadTs: opts.threadTs,
-					partIndex,
-					partCount: fallbackMessages.length
-				});
-				if (partIndex === 0) await dispatchOnce();
-				const fallbackDelivery = await postPart({
-					text: fallback.text,
-					replyBroadcast: partIndex === 0 ? opts.replyBroadcast : void 0,
-					...fallback.blocks ? { blocks: fallback.blocks } : {},
-					metadata,
-					mrkdwn: false
-				});
-				if (fallbackDelivery.meta?.slackQuestionActionIds.length) questionDelivery = fallbackDelivery;
-			}
-			const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
-			return {
-				messageId: lastMessageId,
-				channelId: deliveredChannelId,
-				threadTs: deliveredThreadTs,
-				...questionDelivery?.meta ? { meta: {
-					...questionDelivery.meta,
-					slackQuestionMessageId: questionDelivery.messageId
-				} } : {},
-				receipt: createSlackSendReceiptFromResults(deliveredResults, deliveredThreadTs)
-			};
-		}
 	}
-	const resolvedChunks = resolveSlackTextChunks({
-		cfg,
-		accountId: account.accountId,
-		text: trimmedMessage,
-		textLimit: textChunkLimit,
-		...opts.textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
-		...opts.textIsSlackPlainText ? { preservePlainText: true } : {}
-	});
-	const mediaMaxBytes = opts.mediaMaxBytes ?? (typeof account.config.mediaMaxMb === "number" ? account.config.mediaMaxMb * 1024 * 1024 : void 0);
-	let chunksToPost;
-	if (opts.mediaUrl) {
-		const [firstChunk, ...rest] = resolvedChunks;
-		lastMessageId = await uploadSlackFile({
-			client: delivery.upload?.client ?? client,
-			completionClient: client,
-			channelId,
-			mediaUrl: opts.mediaUrl,
-			mediaAccess: opts.mediaAccess,
-			uploadFileName: opts.uploadFileName,
-			uploadTitle: opts.uploadTitle,
-			mediaLocalRoots: opts.mediaLocalRoots,
-			mediaReadFile: opts.mediaReadFile,
-			caption: firstChunk,
-			threadTs: opts.threadTs,
-			maxBytes: mediaMaxBytes,
-			...opts.forceDocument ? { optimizeImages: false } : {},
-			onPlatformSendDispatch: dispatchOnce,
-			assertDirectAdapterHandoff: opts.assertDirectAdapterHandoff,
-			...delivery.upload ? { auditContext: delivery.upload.auditContext } : {}
+	let messages;
+	if (pendingBlockFallback) messages = pendingBlockFallback.fallbackMessages;
+	else {
+		const resolvedChunks = resolveSlackTextChunks({
+			cfg,
+			accountId: account.accountId,
+			text: trimmedMessage,
+			chunkLimit: textChunkLimit,
+			...opts.textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
+			...opts.textIsSlackPlainText ? { preservePlainText: true } : {}
 		});
-		await reportDelivery(createSlackSendResult(lastMessageId, channelId, "media", normalizeSlackThreadTsCandidate(opts.threadTs)));
-		chunksToPost = rest;
-	} else chunksToPost = resolvedChunks.length ? resolvedChunks : [""];
-	for (const [partIndex, chunk] of chunksToPost.entries()) {
+		const mediaMaxBytes = opts.mediaMaxBytes ?? (typeof account.config.mediaMaxMb === "number" ? account.config.mediaMaxMb * 1024 * 1024 : void 0);
+		let chunksToPost;
+		if (opts.mediaUrl) {
+			const [firstChunk, ...rest] = resolvedChunks;
+			lastMessageId = await uploadSlackFile({
+				client: delivery.upload?.client ?? client,
+				completionClient: client,
+				channelId,
+				mediaUrl: opts.mediaUrl,
+				mediaAccess: opts.mediaAccess,
+				uploadFileName: opts.uploadFileName,
+				uploadTitle: opts.uploadTitle,
+				mediaLocalRoots: opts.mediaLocalRoots,
+				mediaReadFile: opts.mediaReadFile,
+				caption: firstChunk,
+				threadTs: opts.threadTs,
+				maxBytes: mediaMaxBytes,
+				...opts.forceDocument ? { optimizeImages: false } : {},
+				onPlatformSendDispatch: dispatchOnce,
+				assertDirectAdapterHandoff: opts.assertDirectAdapterHandoff,
+				...delivery.upload ? { auditContext: delivery.upload.auditContext } : {}
+			});
+			await reportDelivery(createSlackSendResult(lastMessageId, channelId, "media", normalizeSlackThreadTsCandidate(opts.threadTs)));
+			chunksToPost = rest;
+		} else chunksToPost = resolvedChunks.length ? resolvedChunks : [""];
+		messages = chunksToPost.map((text) => opts.textIsSlackPlainText ? {
+			text,
+			mrkdwn: false
+		} : { text });
+	}
+	let questionDelivery;
+	for (const [partIndex, part] of messages.entries()) {
 		const carriesPrimaryMessageOptions = partIndex === 0 && !opts.mediaUrl;
 		const baseMetadata = carriesPrimaryMessageOptions ? opts.metadata : void 0;
 		const metadata = opts.mediaUrl ? baseMetadata : withSlackDeliveryMetadata(baseMetadata, {
@@ -1234,21 +1103,25 @@ async function sendMessageSlackQueued(params) {
 			channelId,
 			threadTs: opts.threadTs,
 			partIndex,
-			partCount: chunksToPost.length
+			partCount: messages.length
 		});
 		if (partIndex === 0 && !opts.mediaUrl) await dispatchOnce();
-		await postPart({
-			text: chunk,
+		const partDelivery = await postPart({
+			...part,
 			replyBroadcast: carriesPrimaryMessageOptions ? opts.replyBroadcast : void 0,
-			metadata,
-			...opts.textIsSlackPlainText ? { mrkdwn: false } : {}
+			metadata
 		});
+		if (pendingBlockFallback && partDelivery.meta?.slackQuestionActionIds.length) questionDelivery = partDelivery;
 	}
 	const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
 	return {
 		messageId: lastMessageId,
 		channelId: deliveredChannelId,
 		threadTs: deliveredThreadTs,
+		...questionDelivery?.meta ? { meta: {
+			...questionDelivery.meta,
+			slackQuestionMessageId: questionDelivery.messageId
+		} } : {},
 		receipt: createSlackSendReceiptFromResults(deliveredResults, deliveredThreadTs)
 	};
 }