@openclaw/slack 2026.7.2-beta.7 → 2026.8.1-beta.2

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

@@ -1,13 +1,14 @@
-import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-CHAeNZOX.js";
-import { i as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-N6lHogYZ.js";
-import { C as hasSlackNativeDataBlock, D as stripSlackNativeDataBlocks, F as SLACK_EDIT_TEXT_MAX_BYTES, H as truncateSlackText, I as SLACK_MESSAGE_TEXT_HARD_LIMIT, L as SLACK_TEXT_LIMIT, M as buildSlackCompleteBlocksFallbackText, N as renderSlackBlockFallbackText, O as chunkSlackMrkdwnText, S as createSlackNativeDataBaseTextConsumer, U as truncateSlackTextByUtf8Bytes, b as appendSlackNativeDataPlainTextFallback, i as assertSlackDirectSendAllowed, it as validateSlackBlocksArray, k as markdownToSlackMrkdwnChunks, w as isSlackInvalidBlocksError, x as buildSlackNativeDataAccessibilityText } from "./group-policy-NQZti9t-.js";
+import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-CK4AVI2_.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 { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
-import { c as createSlackTokenCacheKey, f as getSlackWriteClient, o as createSlackReadClient } from "./probe-CgDsSops.js";
+import { a as createSlackReadClient, d as getSlackWriteClient, r as formatSlackError, s as createSlackTokenCacheKey } from "./probe-HoEg_WxB.js";
 import { t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.js";
-import { i as loadOutboundMediaFromUrl } from "./runtime-api-QMb-Q5Ko.js";
+import { i as loadOutboundMediaFromUrl } from "./runtime-api-Cj9nxBNv.js";
 import { 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 { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash, createHmac } from "node:crypto";
 import { withTrustedEnvProxyGuardedFetchMode } from "openclaw/plugin-sdk/fetch-runtime";
@@ -19,25 +20,34 @@ import { chunkMarkdownTextWithMode, isSilentReplyText, resolveChunkMode, resolve
 import { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
 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 { 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(2, Math.floor(limit));
+	const effectiveLimit = Math.max(1, Math.floor(limit));
 	const chunks = [];
 	let offset = 0;
 	while (offset < text.length) {
-		const chunk = sliceUtf16Safe(text, offset, Math.min(text.length, offset + effectiveLimit));
+		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;
 }
-function buildPlainTextBlocks(text) {
-	return chunkSlackTextAtHardLimit(text, SLACK_SECTION_PLAIN_TEXT_MAX).map((chunk, index) => {
+function fitsSlackTextLimit(text, limit) {
+	if (text.length <= limit) return true;
+	return sliceSlackTextChunk(text, 0, limit).length === text.length;
+}
+function buildPlainTextBlocks(text, textLimit) {
+	return chunkSlackTextAtHardLimit(text, Math.min(textLimit, SLACK_SECTION_PLAIN_TEXT_MAX)).map((chunk, index) => {
 		const fallbackBlock = {
 			block: {
 				type: "section",
@@ -58,11 +68,11 @@ function renderNativeDataPlainText(block) {
 function buildOrderedFallbackBlocks(params) {
 	const entries = [];
 	const consumeFromBase = createSlackNativeDataBaseTextConsumer(params.baseText);
-	if (params.baseText) entries.push(...buildPlainTextBlocks(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));
+			if (!consumeFromBase(nativeText)) entries.push(...buildPlainTextBlocks(nativeText, params.textLimit));
 			continue;
 		}
 		const text = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
@@ -73,7 +83,7 @@ function buildOrderedFallbackBlocks(params) {
 	}
 	return entries;
 }
-function buildOrderedBlockMessages(entries) {
+function buildOrderedBlockMessages(entries, textLimit) {
 	const messages = [];
 	let blocks = [];
 	let text = "";
@@ -90,10 +100,10 @@ function buildOrderedBlockMessages(entries) {
 	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 > 4e4) flush();
+		if (blocks.length >= 50 || !fitsSlackTextLimit(nextText, textLimit)) flush();
 		const freshSeparator = text && entry.text && !entry.continuesText ? "\n\n" : "";
 		const freshText = entry.text ? `${text}${freshSeparator}${entry.text}` : text;
-		if (freshText.length > 4e4) throw new Error("One Slack fallback block exceeds the message text hard limit.");
+		if (!fitsSlackTextLimit(freshText, textLimit)) throw new Error("One Slack fallback block exceeds the resolved message text limit.");
 		blocks.push(entry.block);
 		text = freshText;
 	}
@@ -103,17 +113,19 @@ function buildOrderedBlockMessages(entries) {
 /** Build one complete, ordered retry plan after Slack rejects native data blocks. */
 function buildSlackNativeDataDeliveryPlan(params) {
 	const baseText = params.baseText?.trim() ?? "";
+	const textLimit = Math.min(SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT, SLACK_MESSAGE_TEXT_HARD_LIMIT, Math.max(1, Math.floor(params.textLimit ?? 4e4)));
 	const hasNativeData = hasSlackNativeDataBlock(params.blocks);
 	const accessibilityText = buildSlackNativeDataAccessibilityText(baseText, params.blocks) || (hasNativeData ? "Slack could not render this chart or table data." : SLACK_EMPTY_BLOCK_FALLBACK);
 	return {
 		accessibilityText,
-		fallbackMessages: stripSlackNativeDataBlocks(params.blocks).length === 0 ? chunkSlackTextAtHardLimit(accessibilityText).map((text) => ({
+		fallbackMessages: stripSlackNativeDataBlocks(params.blocks).length === 0 ? chunkSlackTextAtHardLimit(accessibilityText, textLimit).map((text) => ({
 			text,
 			mrkdwn: false
 		})) : buildOrderedBlockMessages(buildOrderedFallbackBlocks({
 			baseText,
-			blocks: params.blocks
-		})),
+			blocks: params.blocks,
+			textLimit
+		}), textLimit),
 		skipOriginalBlocks: accessibilityText.length > SLACK_MESSAGE_TEXT_HARD_LIMIT
 	};
 }
@@ -355,9 +367,10 @@ async function uploadSlackFile(params) {
 		maxBytes: params.maxBytes,
 		mediaAccess: params.mediaAccess,
 		mediaLocalRoots: params.mediaLocalRoots,
-		mediaReadFile: params.mediaReadFile
+		mediaReadFile: params.mediaReadFile,
+		...params.optimizeImages !== void 0 ? { optimizeImages: params.optimizeImages } : {}
 	});
-	const uploadFileName = params.uploadFileName ?? fileName ?? "upload";
+	const uploadFileName = params.uploadFileName ?? fileName ?? `upload${extensionForMime(contentType) ?? ""}`;
 	const uploadTitle = params.uploadTitle ?? uploadFileName;
 	const uploadUrlResp = await withSlackDnsRequestRetry("files.getUploadURLExternal", () => params.client.files.getUploadURLExternal({
 		filename: uploadFileName,
@@ -416,24 +429,32 @@ async function uploadSlackFile(params) {
 }
 //#endregion
 //#region extensions/slack/src/sent-thread-cache.ts
+/**
+* Cache of Slack threads the bot has participated in.
+* Used to auto-respond in threads without requiring @mention after the first reply.
+*/
+const MAX_ENTRIES = 5e3;
+const PERSISTENT_MAX_ENTRIES = 1e3;
+const MAX_FAILURE_NOTICES = 1e3;
+const PERSISTENT_NAMESPACE = "slack.thread-participation";
+/**
+* Keep Slack thread participation shared across bundled chunks so thread
+* auto-reply gating does not diverge between prepare/dispatch call paths.
+*/
+const SLACK_THREAD_PARTICIPATION_KEY = Symbol.for("openclaw.slackThreadParticipation");
+const SLACK_THREAD_FAILURE_NOTICES_KEY = Symbol.for("openclaw.slackThreadFailureNotices");
 const threadParticipation = createPersistentDedupeCache({
-	globalKey: Symbol.for("openclaw.slackThreadParticipation"),
-	ttlMs: 1440 * 60 * 1e3,
-	maxSize: 5e3,
+	globalKey: SLACK_THREAD_PARTICIPATION_KEY,
+	ttlMs: 0,
+	maxSize: MAX_ENTRIES,
 	persistent: {
-		namespace: "slack.thread-participation",
-		maxEntries: 1e3,
+		namespace: PERSISTENT_NAMESPACE,
+		maxEntries: PERSISTENT_MAX_ENTRIES,
 		openStore: (options) => getOptionalSlackRuntime()?.state.openKeyedStore(options),
-		logError: (error) => {
-			try {
-				getOptionalSlackRuntime()?.logging.getChildLogger({
-					plugin: "slack",
-					feature: "thread-participation-state"
-				}).warn("Slack persistent thread participation state failed", { error: String(error) });
-			} catch {}
-		}
+		logError: createPluginStateErrorReporter(getOptionalSlackRuntime, "slack", "thread-participation-state", "Slack persistent thread participation state failed")
 	}
 });
+const threadFailureNotices = resolveGlobalSingleton(SLACK_THREAD_FAILURE_NOTICES_KEY, () => /* @__PURE__ */ new Map(), (notices) => notices.clear());
 function makeKey(accountId, channelId, threadTs, teamId) {
 	return `${accountId}:${teamId ? `${teamId}:` : ""}${channelId}:${threadTs}`;
 }
@@ -452,8 +473,41 @@ async function hasSlackThreadParticipationWithPersistence(params) {
 	if (!params.accountId || !params.channelId || !params.threadTs) return false;
 	return await threadParticipation.lookup(makeKey(params.accountId, params.channelId, params.threadTs, params.teamId));
 }
+function makeFailureNoticeKey(params) {
+	const scope = params.threadTs ? `thread:${params.threadTs}` : "channel";
+	return makeKey(params.accountId, params.channelId, scope, params.teamId);
+}
+/** Returns whether this failure was already delivered in the thread or channel. */
+function hasSlackThreadFailureNotice(params) {
+	const { accountId, channelId, failureText } = params;
+	const fingerprint = failureText.trim().replace(/\s+/gu, " ");
+	if (!accountId || !channelId || !fingerprint) return false;
+	return threadFailureNotices.get(makeFailureNoticeKey(params)) === fingerprint;
+}
+/** Records a failure after it was delivered in the thread or channel. */
+function recordSlackThreadFailureNotice(params) {
+	const { accountId, channelId, failureText } = params;
+	const fingerprint = failureText.trim().replace(/\s+/gu, " ");
+	if (!accountId || !channelId || !fingerprint) return false;
+	const key = makeFailureNoticeKey(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);
+	}
+	return true;
+}
+/** Clears a thread or channel outage notice after a healthy model turn completes. */
+function clearSlackThreadFailureNotice(params) {
+	const { accountId, channelId } = params;
+	if (!accountId || !channelId) return;
+	threadFailureNotices.delete(makeFailureNoticeKey(params));
+}
 function clearSlackThreadParticipationCache() {
 	threadParticipation.clearForTest();
+	threadFailureNotices.clear();
 }
 //#endregion
 //#region extensions/slack/src/send.ts
@@ -537,11 +591,12 @@ async function updateMessageSlack(params) {
 		cfg: requireRuntimeConfig(params.cfg, "Slack update"),
 		accountId: params.accountId
 	});
+	assertSlackDetachedTargetAllowed(account.accountId, params.teamId);
 	await getSlackWriteClient(resolveToken({
 		accountId: account.accountId,
 		fallbackToken: account.botToken,
 		fallbackSource: account.botTokenSource
-	})).chat.update({
+	}), { teamId: params.teamId }).chat.update({
 		channel: params.channelId,
 		ts: params.messageTs,
 		text: truncateSlackTextByUtf8Bytes(params.text, SLACK_EDIT_TEXT_MAX_BYTES),
@@ -577,7 +632,8 @@ function parseRecipient(raw) {
 	if (!target) throw new Error("Recipient is required for Slack sends");
 	return {
 		kind: target.kind,
-		id: canonicalizeSlackApiTargetId(target.kind, target.id, raw)
+		id: canonicalizeSlackApiTargetId(target.kind, target.id, raw),
+		teamId: target.teamId
 	};
 }
 function parseEnterpriseEventRecipient(raw) {
@@ -588,20 +644,62 @@ function parseEnterpriseEventRecipient(raw) {
 		id: canonicalizeSlackApiTargetId("channel", match[1])
 	};
 }
-function resolveEnterpriseEventScope(params) {
-	const scope = params.opts.enterpriseEventScope;
-	if (!scope) {
-		assertSlackDirectSendAllowed(params.account);
-		return;
-	}
-	if (params.account.config.enterpriseOrgInstall !== true) throw new Error("unexpected_enterprise_slack_listener_scope");
-	if (!scope.isEnterpriseInstall || !normalizeOptionalString(scope.apiAppId) || !normalizeOptionalString(scope.enterpriseId) || !/^T[A-Z0-9]+$/i.test(scope.teamId) || !scope.client || params.opts.client !== scope.client) throw new Error("invalid_enterprise_slack_listener_scope");
+function resolveSlackSendEventScope(params) {
+	const scope = params.opts.eventScope;
+	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.opts.mediaUrl && !params.eventScope.uploadCompletionClient) throw new Error("missing_enterprise_slack_upload_completion_client");
+		return Object.freeze({
+			client: params.eventScope.client,
+			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({
+				completionClient: params.eventScope.uploadCompletionClient,
+				auditContext: "slack-enterprise-immediate-upload"
+			}) } : {}
+		});
+	}
+	const credential = resolveToken({
+		explicit: params.opts.token,
+		accountId: params.account.accountId,
+		fallbackToken: resolveSlackOperationToken(params.account, "write"),
+		fallbackSource: params.account.identity === "user" ? params.account.userTokenSource : params.account.botTokenSource
+	});
+	return Object.freeze({
+		client: params.recipient.teamId ? getSlackWriteClient(credential, { teamId: params.recipient.teamId }) : params.opts.client ?? getSlackWriteClient(credential),
+		credential,
+		identity: resolveSlackSendIdentity({
+			accountId: params.account.accountId,
+			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,
+			unfurlMedia: params.account.config.unfurlMedia
+		}
+	});
+}
+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);
+}
 function resolveSlackTextChunks(params) {
 	const text = params.preservePlainText ? params.text : params.text.trim();
-	const configuredLimit = params.textLimit ?? resolveTextChunkLimit(params.cfg, "slack", params.accountId, { fallbackLimit: 8e3 });
-	const chunkLimit = Math.min(configuredLimit, SLACK_TEXT_LIMIT);
+	const chunkLimit = resolveSlackTextChunkLimit(params);
 	if (params.preservePlainText) {
 		const chunks = [];
 		let remaining = text;
@@ -867,7 +965,7 @@ async function scanSlackConversationForDelivery(params) {
 		evidence: deliveryParts.size > 0 ? "partial" : "none"
 	};
 }
-async function reconcileSlackUnknownSend(ctx, opts) {
+async function reconcileSlackUnknownSend(ctx) {
 	const account = resolveSlackAccount({
 		cfg: requireRuntimeConfig(ctx.cfg, "Slack delivery reconciliation"),
 		accountId: ctx.accountId ?? void 0
@@ -878,13 +976,22 @@ async function reconcileSlackUnknownSend(ctx, opts) {
 		error: "Slack unknown-send reconciliation requires a durable delivery id",
 		retryable: 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
+		};
+	}
 	const readToken = resolveSlackOperationToken(account, "read");
 	if (!readToken) return {
 		status: "unresolved",
 		error: `Slack read token missing for account "${account.accountId}"`,
 		retryable: false
 	};
-	const recipient = parseRecipient(ctx.to);
 	const userRecipient = isSlackUserRecipient(recipient);
 	const writeToken = resolveSlackOperationToken(account, "write");
 	if (userRecipient && !writeToken) return {
@@ -892,8 +999,8 @@ async function reconcileSlackUnknownSend(ctx, opts) {
 		error: `Slack write token missing for direct-message reconciliation on account "${account.accountId}"`,
 		retryable: false
 	};
-	const readClient = opts?.client ?? createSlackReadClient(readToken);
-	const writeClient = opts?.client ?? (writeToken ? getSlackWriteClient(writeToken) : void 0);
+	const readClient = createSlackReadClient(readToken, { teamId: recipient.teamId });
+	const writeClient = writeToken ? getSlackWriteClient(writeToken, { teamId: recipient.teamId }) : void 0;
 	const payloadReplyToId = ctx.payloads[0]?.replyToId;
 	const threadTs = resolveSlackThreadTsValue({
 		replyToId: Object.hasOwn(ctx, "effectiveReplyToId") ? normalizeOptionalString(ctx.effectiveReplyToId) : payloadReplyToId != null ? normalizeOptionalString(payloadReplyToId) : ctx.replyToMode === "off" ? void 0 : normalizeOptionalString(ctx.replyToId),
@@ -910,7 +1017,7 @@ async function reconcileSlackUnknownSend(ctx, opts) {
 			accountId: account.accountId,
 			token: channelToken
 		});
-		const lookupClients = opts?.client ? [opts.client] : [readClient, ...writeClient && writeToken !== readToken ? [writeClient] : []];
+		const lookupClients = [readClient, ...writeClient && writeClient !== readClient && writeToken !== readToken ? [writeClient] : []];
 		let lookupError;
 		let bestUnresolvedScan;
 		for (const lookupClient of lookupClients) try {
@@ -947,15 +1054,9 @@ async function sendMessageSlack(to, message, opts) {
 		cfg,
 		accountId: opts.accountId
 	});
-	const enterpriseEventScope = resolveEnterpriseEventScope({
-		account,
-		opts
-	});
-	const enterpriseDelivery = enterpriseEventScope ? Object.freeze({
-		client: enterpriseEventScope.client,
-		teamId: enterpriseEventScope.teamId,
-		...enterpriseEventScope.uploadCompletionClient ? { uploadCompletionClient: enterpriseEventScope.uploadCompletionClient } : {}
-	}) : void 0;
+	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 {
@@ -969,37 +1070,29 @@ async function sendMessageSlack(to, message, opts) {
 	}
 	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 token = enterpriseDelivery ? SLACK_ENTERPRISE_LISTENER_QUEUE_CREDENTIAL : resolveToken({
-		explicit: opts.token,
-		accountId: account.accountId,
-		fallbackToken: resolveSlackOperationToken(account, "write"),
-		fallbackSource: account.identity === "user" ? account.userTokenSource : account.botTokenSource
+	const queuedOpts = Object.freeze({ ...opts });
+	const delivery = resolveSlackDelivery({
+		account,
+		eventScope,
+		opts: queuedOpts,
+		recipient
 	});
-	const recipient = enterpriseDelivery ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
-	const queueKey = createSlackSendQueueKey({
+	const result = await runQueuedSlackSend(createSlackSendQueueKey({
 		accountId: account.accountId,
-		token,
-		recipient,
+		token: delivery.credential,
+		recipient: delivery.recipient,
 		threadTs: opts.threadTs,
-		...enterpriseDelivery ? { teamId: enterpriseDelivery.teamId } : {}
-	});
-	const queuedOpts = enterpriseDelivery ? Object.freeze({
-		...opts,
-		client: enterpriseDelivery.client
-	}) : opts;
-	const result = await runQueuedSlackSend(queueKey, () => sendMessageSlackQueued({
+		teamId: delivery.teamId
+	}), () => sendMessageSlackQueued({
 		trimmedMessage,
 		opts: queuedOpts,
 		cfg,
 		account,
-		token,
-		recipient,
 		blocks,
-		...enterpriseDelivery ? { enterpriseDelivery } : {}
+		delivery
 	}));
 	const threadTs = result.threadTs ?? normalizeSlackThreadTsCandidate(queuedOpts.threadTs);
-	if (threadTs && result.channelId && account.accountId) if (enterpriseDelivery) recordSlackThreadParticipation(account.accountId, result.channelId, threadTs, { teamId: enterpriseDelivery.teamId });
-	else recordSlackThreadParticipation(account.accountId, result.channelId, threadTs);
+	if (threadTs && result.channelId && account.accountId) recordSlackThreadParticipation(account.accountId, result.channelId, threadTs, { teamId: delivery.teamId });
 	return result;
 }
 async function sendMessageSlackQueued(params) {
@@ -1010,17 +1103,9 @@ async function sendMessageSlackQueued(params) {
 	}
 }
 async function sendMessageSlackQueuedInner(params) {
-	const { opts, cfg, account, token, recipient, blocks, trimmedMessage, enterpriseDelivery } = params;
-	const client = enterpriseDelivery?.client ?? opts.client ?? getSlackWriteClient(token);
-	const identity = enterpriseDelivery ? normalizeSlackSendIdentity(opts.identity) : resolveSlackSendIdentity({
-		accountId: account.accountId,
-		explicit: opts.identity
-	});
+	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.");
-	const unfurl = enterpriseDelivery ? { unfurlMedia: account.config.unfurlMedia } : {
-		unfurlLinks: account.config.unfurlLinks,
-		unfurlMedia: account.config.unfurlMedia
-	};
 	const directUserPostChannelId = opts.deliveryQueueId ? void 0 : resolveDirectUserPostChannelId({
 		recipient,
 		hasMedia: Boolean(opts.mediaUrl),
@@ -1028,11 +1113,20 @@ async function sendMessageSlackQueuedInner(params) {
 	});
 	const { channelId } = directUserPostChannelId ? { channelId: directUserPostChannelId } : await resolveChannelId(client, recipient, {
 		accountId: account.accountId,
-		token
+		token: delivery.credential
 	});
-	const reportDelivery = async (result) => {
-		await opts.onDeliveryResult?.(result);
-		return result;
+	const reportDelivery = async (result, deliveredBlocks) => {
+		const slackQuestionActionIds = resolveSlackQuestionActionIds(deliveredBlocks);
+		const deliveryResult = slackQuestionActionIds.length ? {
+			...result,
+			meta: {
+				...result.meta,
+				slackQuestionActionIds,
+				[SLACK_QUESTION_FINALIZATION_BLOCKS]: deliveredBlocks.filter((block) => block.type !== "actions")
+			}
+		} : result;
+		await opts.onDeliveryResult?.(deliveryResult);
+		return deliveryResult;
 	};
 	let didDispatch = false;
 	const dispatchOnce = async () => {
@@ -1044,10 +1138,16 @@ async function sendMessageSlackQueuedInner(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 usesOrderedBlockAccessibility = Boolean(blocks && (hasNativeData || opts.authoredTextPlacement !== void 0));
 	const orderedBlockDeliveryPlan = blocks && usesOrderedBlockAccessibility ? buildSlackNativeDataDeliveryPlan({
 		baseText: nativeDataFallbackBase,
-		blocks
+		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) : "";
@@ -1085,7 +1185,7 @@ async function sendMessageSlackQueuedInner(params) {
 					...usesOrderedBlockAccessibility ? { mrkdwn: false } : {},
 					unfurl
 				});
-				if (enterpriseDelivery && (!response.ok || !response.ts)) throw new Error(response.ok ? "Slack chat.postMessage returned no message timestamp" : `Slack chat.postMessage failed: ${response.error ?? "unknown error"}`);
+				assertSlackPostMessageResponse(response, delivery.requireMessageTimestamp);
 				const messageId = response.ts ?? "unknown";
 				deliveredChannelId = resolvePostedMessageChannelId(response, channelId);
 				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
@@ -1099,7 +1199,7 @@ async function sendMessageSlackQueuedInner(params) {
 						kind: "card",
 						threadTs: deliveredThreadTs
 					})
-				});
+				}, blocks);
 			} catch (error) {
 				if (!hasNativeData || !isSlackInvalidBlocksError(error)) throw error;
 				logVerbose("slack send: native data rejected, delivering complete text fallback");
@@ -1108,6 +1208,7 @@ async function sendMessageSlackQueuedInner(params) {
 		}
 		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,
@@ -1130,7 +1231,7 @@ async function sendMessageSlackQueuedInner(params) {
 					unfurl
 				});
 				const response = posted.response;
-				if (enterpriseDelivery && (!response.ok || !response.ts)) throw new Error(response.ok ? "Slack chat.postMessage returned no message timestamp" : `Slack chat.postMessage failed: ${response.error ?? "unknown error"}`);
+				assertSlackPostMessageResponse(response, delivery.requireMessageTimestamp);
 				sendIdentity = posted.identity;
 				lastMessageId = response.ts ?? lastMessageId;
 				deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
@@ -1138,7 +1239,7 @@ async function sendMessageSlackQueuedInner(params) {
 				if (!response.ts) continue;
 				sentMessageIds.push(response.ts);
 				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
-				await reportDelivery({
+				const fallbackDelivery = await reportDelivery({
 					messageId: response.ts,
 					channelId: deliveredChannelId,
 					threadTs: deliveredThreadTs,
@@ -1148,7 +1249,8 @@ async function sendMessageSlackQueuedInner(params) {
 						kind: fallback.blocks ? "card" : "text",
 						threadTs: deliveredThreadTs
 					})
-				});
+				}, fallback.blocks);
+				if (fallbackDelivery.meta?.slackQuestionActionIds.length) questionDelivery = fallbackDelivery;
 			}
 			const messageId = lastMessageId || "unknown";
 			const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
@@ -1156,6 +1258,10 @@ async function sendMessageSlackQueuedInner(params) {
 				messageId,
 				channelId: deliveredChannelId,
 				threadTs: deliveredThreadTs,
+				...questionDelivery?.meta ? { meta: {
+					...questionDelivery.meta,
+					slackQuestionMessageId: questionDelivery.messageId
+				} } : {},
 				receipt: createSlackSendReceipt({
 					platformMessageIds: sentMessageIds.length ? sentMessageIds : [messageId],
 					channelId: deliveredChannelId,
@@ -1169,18 +1275,17 @@ async function sendMessageSlackQueuedInner(params) {
 		cfg,
 		accountId: account.accountId,
 		text: trimmedMessage,
-		...opts.textLimit !== void 0 ? { textLimit: opts.textLimit } : {},
+		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) {
-		if (enterpriseDelivery && !enterpriseDelivery.uploadCompletionClient) throw new Error("missing_enterprise_slack_upload_completion_client");
 		const [firstChunk, ...rest] = resolvedChunks;
 		lastMessageId = await uploadSlackFile({
 			client,
-			...enterpriseDelivery?.uploadCompletionClient ? { completionClient: enterpriseDelivery.uploadCompletionClient } : {},
+			...delivery.upload ? { completionClient: delivery.upload.completionClient } : {},
 			channelId,
 			mediaUrl: opts.mediaUrl,
 			mediaAccess: opts.mediaAccess,
@@ -1191,8 +1296,9 @@ async function sendMessageSlackQueuedInner(params) {
 			caption: firstChunk,
 			threadTs: opts.threadTs,
 			maxBytes: mediaMaxBytes,
+			...opts.forceDocument ? { optimizeImages: false } : {},
 			onPlatformSendDispatch: dispatchOnce,
-			...enterpriseDelivery ? { auditContext: "slack-enterprise-immediate-upload" } : {}
+			...delivery.upload ? { auditContext: delivery.upload.auditContext } : {}
 		});
 		sentMessageIds.push(lastMessageId);
 		await reportDelivery({
@@ -1231,7 +1337,7 @@ async function sendMessageSlackQueuedInner(params) {
 			unfurl
 		});
 		const response = posted.response;
-		if (enterpriseDelivery && (!response.ok || !response.ts)) throw new Error(response.ok ? "Slack chat.postMessage returned no message timestamp" : `Slack chat.postMessage failed: ${response.error ?? "unknown error"}`);
+		assertSlackPostMessageResponse(response, delivery.requireMessageTimestamp);
 		sendIdentity = posted.identity;
 		lastMessageId = response.ts ?? lastMessageId;
 		deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
@@ -1266,4 +1372,4 @@ async function sendMessageSlackQueuedInner(params) {
 	};
 }
 //#endregion
-export { updateMessageSlack as a, hasSlackThreadParticipationWithPersistence as c, chunkSlackTextAtHardLimit as d, setSlackDefaultSendIdentity as i, recordSlackThreadParticipation as l, resolveSlackDmChannelId as n, clearSlackThreadParticipationCache as o, sendMessageSlack as r, hasSlackThreadParticipation as s, reconcileSlackUnknownSend as t, buildSlackNativeDataDeliveryPlan as u };
+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 };

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

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

package/dist/setup-entry.js

@@ -1,5 +1,3 @@
-import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
-import "./http-routes-api.js";
 import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 //#region extensions/slack/setup-entry.ts
 var setup_entry_default = defineBundledChannelSetupEntry({
@@ -15,8 +13,7 @@ var setup_entry_default = defineBundledChannelSetupEntry({
 	runtime: {
 		specifier: "./runtime-setter-api.js",
 		exportName: "setSlackRuntime"
-	},
-	registerSetupRuntime: registerSlackPluginHttpRoutes
+	}
 });
 //#endregion
 export { setup_entry_default as default };

package/dist/setup-plugin-api.js

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

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

@@ -1,9 +1,9 @@
-import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom } from "./accounts-CHAeNZOX.js";
-import { t as inspectSlackAccount } from "./account-inspect-DEKpg9Ip.js";
-import "./shared-DgIN3Dcr.js";
-import { n as createSlackSetupWizardBase, o as SLACK_CHANNEL } from "./config-adapter-CxBQH8fq.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-yEqmM-3I.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-BOrt5K-5.js";
+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 { 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";