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

package/dist/send-Nor0iBwY.js

@@ -0,0 +1,1375 @@
+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 { 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-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";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { PlatformMessageNotDispatchedError, extractErrorCode, readErrorName } from "openclaw/plugin-sdk/error-runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { chunkMarkdownTextWithMode, isSilentReplyText, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
+import { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
+import { 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(1, Math.floor(limit));
+	const chunks = [];
+	let offset = 0;
+	while (offset < text.length) {
+		const chunk = sliceSlackTextChunk(text, offset, effectiveLimit);
+		if (!chunk) throw new Error("Slack plain-text fallback chunking made no progress.");
+		chunks.push(chunk);
+		offset += chunk.length;
+	}
+	return chunks;
+}
+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",
+				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 = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
+		entries.push({
+			block,
+			...text ? { text } : {}
+		});
+	}
+	return entries;
+}
+function buildOrderedBlockMessages(entries, textLimit) {
+	const messages = [];
+	let blocks = [];
+	let text = "";
+	const flush = () => {
+		if (blocks.length === 0) return;
+		messages.push({
+			text: text || SLACK_EMPTY_BLOCK_FALLBACK,
+			blocks,
+			mrkdwn: false
+		});
+		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 || !fitsSlackTextLimit(nextText, textLimit)) flush();
+		const freshSeparator = text && entry.text && !entry.continuesText ? "\n\n" : "";
+		const freshText = entry.text ? `${text}${freshSeparator}${entry.text}` : text;
+		if (!fitsSlackTextLimit(freshText, textLimit)) throw new Error("One Slack fallback block exceeds the resolved message text limit.");
+		blocks.push(entry.block);
+		text = freshText;
+	}
+	flush();
+	return messages;
+}
+/** 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, textLimit).map((text) => ({
+			text,
+			mrkdwn: false
+		})) : buildOrderedBlockMessages(buildOrderedFallbackBlocks({
+			baseText,
+			blocks: params.blocks,
+			textLimit
+		}), textLimit),
+		skipOriginalBlocks: accessibilityText.length > SLACK_MESSAGE_TEXT_HARD_LIMIT
+	};
+}
+//#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 isSlackCustomizeScopeError(err) {
+	const data = getSlackWebApiErrorData$1(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 code = normalizeLowercaseStringOrEmpty(normalizeOptionalString(getSlackWebApiErrorData$1(err)?.error));
+	return code === "invalid_arguments" || code === "invalid_arg_name";
+}
+function hasCustomIdentity$1(identity) {
+	return Boolean(identity?.username || identity?.iconUrl || identity?.iconEmoji);
+}
+/** Post with the requested identity, degrading only on Slack identity-specific errors. */
+async function postSlackMessageWithIdentityFallback(params) {
+	const { basePayload, identity, post } = params;
+	try {
+		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 } : {}
+		}, identity);
+	} catch (err) {
+		if (!identity || !hasCustomIdentity$1(identity) || !isSlackCustomIdentityRejectedError(err)) throw err;
+		if (!isSlackCustomizeScopeError(err) && identity.username && (identity.iconUrl || identity.iconEmoji)) {
+			logVerbose("slack send: custom icon rejected, retrying with username only");
+			try {
+				return await post({
+					...basePayload,
+					username: identity.username
+				}, { username: identity.username });
+			} catch (retryError) {
+				if (!isSlackCustomIdentityRejectedError(retryError)) throw retryError;
+			}
+		}
+		logVerbose("slack send: custom identity rejected, retrying without custom identity");
+		return post(basePayload);
+	}
+}
+//#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);
+	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.metadata ? { metadata: params.metadata } : {},
+		...typeof params.mrkdwn === "boolean" ? { mrkdwn: params.mrkdwn } : {},
+		...threadPayload,
+		...unfurlPayload
+	};
+}
+//#endregion
+//#region extensions/slack/src/client-delivery.ts
+const SLACK_COMMERCIAL_API_HOSTNAME = "slack.com";
+const SLACK_COMMERCIAL_UPLOAD_HOSTNAME = "files.slack.com";
+const SLACK_GOV_API_HOSTNAME = "slack-gov.com";
+const SLACK_GOV_UPLOAD_HOSTNAME = "files.slack-gov.com";
+const SLACK_COMMERCIAL_UPLOAD_SSRF_POLICY = {
+	hostnameAllowlist: [SLACK_COMMERCIAL_UPLOAD_HOSTNAME],
+	allowRfc2544BenchmarkRange: true
+};
+const SLACK_GOV_UPLOAD_SSRF_POLICY = {
+	hostnameAllowlist: [SLACK_GOV_UPLOAD_HOSTNAME],
+	allowRfc2544BenchmarkRange: true
+};
+const SLACK_UPLOAD_POST_TIMEOUT_MS = 12e4;
+const SLACK_DNS_RETRY_CODES = /* @__PURE__ */ new Set([
+	"EAI_AGAIN",
+	"ENOTFOUND",
+	"UND_ERR_DNS_RESOLVE_FAILED"
+]);
+const SLACK_DNS_RETRY_ATTEMPTS = 2;
+const SLACK_DNS_RETRY_BASE_DELAY_MS = 250;
+function readSlackRequestErrorCode(value) {
+	if (!value || typeof value !== "object") return;
+	const code = value.code;
+	return typeof code === "string" ? code.toUpperCase() : void 0;
+}
+function readSlackRequestErrorMessage$1(value) {
+	if (value instanceof Error) return value.message;
+	return typeof value === "string" ? value : "";
+}
+function hasSlackDnsRequestSignal(err) {
+	let current = err;
+	const seen = /* @__PURE__ */ new Set();
+	for (let depth = 0; current && typeof current === "object" && depth < 6; depth += 1) {
+		if (seen.has(current)) return false;
+		seen.add(current);
+		const code = readSlackRequestErrorCode(current);
+		if (code && SLACK_DNS_RETRY_CODES.has(code)) return true;
+		const message = readSlackRequestErrorMessage$1(current);
+		if (/\b(EAI_AGAIN|ENOTFOUND|UND_ERR_DNS_RESOLVE_FAILED)\b/i.test(message)) return true;
+		current = current.original ?? current.cause;
+	}
+	return false;
+}
+function delaySlackDnsRetry(attempt) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, SLACK_DNS_RETRY_BASE_DELAY_MS * Math.max(1, attempt));
+	});
+}
+function resolveSlackUploadTimeoutLogUrl(url) {
+	try {
+		return new URL(url).origin;
+	} catch {
+		return;
+	}
+}
+function buildSlackUploadFailureCause(error) {
+	const httpStatus = error instanceof Error ? /^Failed to upload file: HTTP (\d{3})$/u.exec(error.message)?.[1] : void 0;
+	const cause = /* @__PURE__ */ new Error(httpStatus ? `Slack external upload returned HTTP ${httpStatus}` : "Slack external upload transfer failed");
+	cause.name = readErrorName(error) || cause.name;
+	const code = extractErrorCode(error) ?? (httpStatus ? `HTTP_${httpStatus}` : void 0);
+	if (code) cause.code = code;
+	return cause;
+}
+function parseSlackUploadHttpUrl(value, label) {
+	try {
+		const parsed = new URL(value);
+		if (parsed.protocol === "http:" || parsed.protocol === "https:") return parsed;
+	} catch {}
+	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 normalizeSlackOrigin(url) {
+	const port = url.port ? `:${url.port}` : "";
+	return `${url.protocol}//${normalizeSlackHostname(url.hostname)}${port}`;
+}
+function resolveSlackUploadTransportPolicy(params) {
+	if (!params.slackApiUrl) return {
+		requireHttps: true,
+		policy: SLACK_COMMERCIAL_UPLOAD_SSRF_POLICY
+	};
+	const apiUrl = parseSlackUploadHttpUrl(params.slackApiUrl, "Configured Slack API URL");
+	const officialApiPolicy = resolveOfficialSlackApiUploadPolicy(apiUrl);
+	if (officialApiPolicy) return {
+		requireHttps: true,
+		policy: officialApiPolicy
+	};
+	const uploadUrl = parseSlackUploadHttpUrl(params.uploadUrl, "Slack external upload URL");
+	const slackOwnedUploadPolicy = resolveSlackOwnedUploadPolicy(uploadUrl);
+	if (slackOwnedUploadPolicy) return {
+		requireHttps: true,
+		policy: slackOwnedUploadPolicy
+	};
+	if (normalizeSlackOrigin(uploadUrl) !== normalizeSlackOrigin(apiUrl)) throw new Error("Slack external upload URL must match the configured Slack API origin");
+	return {
+		requireHttps: apiUrl.protocol === "https:",
+		policy: {
+			hostnameAllowlist: [uploadUrl.hostname],
+			allowedOrigins: [uploadUrl.origin],
+			allowRfc2544BenchmarkRange: true
+		}
+	};
+}
+async function withSlackDnsRequestRetry(operation, fn) {
+	for (const attempt of Array.from({ length: 3 }, (_, index) => index)) try {
+		return await fn();
+	} catch (err) {
+		if (attempt >= SLACK_DNS_RETRY_ATTEMPTS || !hasSlackDnsRequestSignal(err)) throw err;
+		logVerbose(`slack send: retrying ${operation} after transient DNS request error (${attempt + 1}/${SLACK_DNS_RETRY_ATTEMPTS})`);
+		await delaySlackDnsRetry(attempt + 1);
+	}
+	throw new Error("unreachable Slack DNS retry loop exit");
+}
+async function postSlackMessageBestEffort(params) {
+	const basePayload = buildSlackPostMessagePayload(params);
+	const postChatMessage = params.client.chat.postMessage.bind(params.client.chat);
+	const post = async (payload, identity) => ({
+		response: await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage(payload)),
+		identity
+	});
+	return await postSlackMessageWithIdentityFallback({
+		basePayload,
+		identity: params.identity,
+		post
+	});
+}
+async function uploadSlackFile(params) {
+	const { buffer, contentType, fileName } = await loadOutboundMediaFromUrl(params.mediaUrl, {
+		maxBytes: params.maxBytes,
+		mediaAccess: params.mediaAccess,
+		mediaLocalRoots: params.mediaLocalRoots,
+		mediaReadFile: params.mediaReadFile,
+		...params.optimizeImages !== void 0 ? { optimizeImages: params.optimizeImages } : {}
+	});
+	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,
+		length: buffer.length
+	}));
+	if (!uploadUrlResp.ok || !uploadUrlResp.upload_url || !uploadUrlResp.file_id) throw new Error(`Failed to get upload URL: ${uploadUrlResp.error ?? "unknown error"}`);
+	const uploadFileId = uploadUrlResp.file_id;
+	const uploadTransport = resolveSlackUploadTransportPolicy({
+		uploadUrl: uploadUrlResp.upload_url,
+		slackApiUrl: params.client.slackApiUrl
+	});
+	const { signal: uploadTimeoutSignal, cleanup: cleanupUploadTimeout } = buildTimeoutAbortSignal({
+		timeoutMs: SLACK_UPLOAD_POST_TIMEOUT_MS,
+		operation: "slack-upload-file",
+		url: resolveSlackUploadTimeoutLogUrl(uploadUrlResp.upload_url)
+	});
+	try {
+		const { response: uploadResp, release } = await fetchWithSsrFGuard(withTrustedEnvProxyGuardedFetchMode({
+			url: uploadUrlResp.upload_url,
+			init: {
+				method: "POST",
+				...contentType ? { headers: { "Content-Type": contentType } } : {},
+				body: new Uint8Array(buffer)
+			},
+			timeoutMs: SLACK_UPLOAD_POST_TIMEOUT_MS,
+			signal: uploadTimeoutSignal,
+			requireHttps: uploadTransport.requireHttps,
+			policy: uploadTransport.policy,
+			capture: false,
+			auditContext: params.auditContext ?? "slack-upload-file"
+		}));
+		try {
+			if (uploadResp.status !== 200) throw new Error(`Failed to upload file: HTTP ${uploadResp.status}`);
+		} finally {
+			await uploadResp.body?.cancel().catch(() => void 0);
+			await release();
+		}
+	} catch (error) {
+		throw new PlatformMessageNotDispatchedError(`Slack external upload ${uploadTimeoutSignal?.aborted ? "timed out" : "failed"} before completion dispatch`, { cause: buildSlackUploadFailureCause(error) });
+	} finally {
+		cleanupUploadTimeout();
+	}
+	await params.onPlatformSendDispatch?.();
+	const completionClient = params.completionClient ?? params.client;
+	const completeResp = await withSlackDnsRequestRetry("files.completeUploadExternal", () => completionClient.files.completeUploadExternal({
+		files: [{
+			id: uploadFileId,
+			title: uploadTitle
+		}],
+		channel_id: params.channelId,
+		...params.caption ? { initial_comment: params.caption } : {},
+		...params.threadTs ? { thread_ts: params.threadTs } : {}
+	}));
+	if (!completeResp.ok) throw new Error(`Failed to complete upload: ${completeResp.error ?? "unknown error"}`);
+	return uploadFileId;
+}
+//#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: SLACK_THREAD_PARTICIPATION_KEY,
+	ttlMs: 0,
+	maxSize: MAX_ENTRIES,
+	persistent: {
+		namespace: PERSISTENT_NAMESPACE,
+		maxEntries: PERSISTENT_MAX_ENTRIES,
+		openStore: (options) => getOptionalSlackRuntime()?.state.openKeyedStore(options),
+		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}`;
+}
+function recordSlackThreadParticipation(accountId, channelId, threadTs, opts) {
+	if (!accountId || !channelId || !threadTs) return;
+	threadParticipation.register(makeKey(accountId, channelId, threadTs, opts?.teamId), {
+		...opts?.agentId ? { agentId: opts.agentId } : {},
+		repliedAt: Date.now()
+	});
+}
+function hasSlackThreadParticipation(accountId, channelId, threadTs, teamId) {
+	if (!accountId || !channelId || !threadTs) return false;
+	return threadParticipation.peek(makeKey(accountId, channelId, threadTs, teamId));
+}
+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
+const SLACK_DM_CHANNEL_CACHE_MAX = 1024;
+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";
+const SLACK_DELIVERY_METADATA_PART_COUNT_KEY = "openclaw_delivery_part_count";
+const SLACK_DELIVERY_METADATA_SIGNATURE_KEY = "openclaw_delivery_signature";
+const SLACK_RECONCILE_LOOKBACK_MS = 3e4;
+const SLACK_RECONCILE_CLOCK_SKEW_MS = 5 * 6e4;
+const SLACK_RECONCILE_LIMIT = 100;
+const SLACK_RECONCILE_MAX_PAGES = 10;
+const SLACK_ENTERPRISE_LISTENER_QUEUE_CREDENTIAL = "listener-scoped-enterprise";
+const slackDmChannelCaches = /* @__PURE__ */ new WeakMap();
+const slackSendQueue = new KeyedAsyncQueue();
+const slackDefaultSendIdentities = /* @__PURE__ */ new Map();
+function hasCustomIdentity(identity) {
+	return Boolean(identity?.username || identity?.iconUrl || identity?.iconEmoji);
+}
+function normalizeSlackSendIdentity(identity) {
+	const username = normalizeOptionalString(identity?.username);
+	const iconUrl = normalizeOptionalString(identity?.iconUrl);
+	const iconEmoji = normalizeOptionalString(identity?.iconEmoji);
+	const normalized = {
+		...username ? { username } : {},
+		...iconUrl ? { iconUrl } : {},
+		...iconEmoji ? { iconEmoji } : {}
+	};
+	return hasCustomIdentity(normalized) ? normalized : void 0;
+}
+function setSlackDefaultSendIdentity(accountId, identity) {
+	const normalizedAccountId = normalizeOptionalString(accountId);
+	if (!normalizedAccountId) return;
+	const normalizedIdentity = normalizeSlackSendIdentity(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 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);
+	const code = normalizeOptionalString(data?.error);
+	if (!code) return;
+	const details = [];
+	const needed = normalizeOptionalString(data?.needed);
+	if (needed) details.push(`needed: ${needed}`);
+	const scopes = normalizeTrimmedStringList(data?.response_metadata?.scopes);
+	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);
+}
+function readSlackRequestErrorMessage(value) {
+	if (value instanceof Error) return value.message;
+	return typeof value === "string" ? value : "";
+}
+function resolvePostedMessageThreadTs(response) {
+	const threadTs = response.message?.thread_ts;
+	return typeof threadTs === "string" ? normalizeSlackThreadTsCandidate(threadTs) : void 0;
+}
+async function updateMessageSlack(params) {
+	const account = resolveSlackAccount({
+		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
+	}), { teamId: params.teamId }).chat.update({
+		channel: params.channelId,
+		ts: params.messageTs,
+		text: truncateSlackTextByUtf8Bytes(params.text, SLACK_EDIT_TEXT_MAX_BYTES),
+		blocks: validateSlackBlocksArray(params.blocks)
+	});
+}
+function createSlackSendReceipt(params) {
+	return createMessageReceiptFromOutboundResults({
+		results: params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown" && messageId !== "suppressed").map((messageId) => {
+			const result = {
+				channel: "slack",
+				messageId
+			};
+			if (params.channelId) result.channelId = params.channelId;
+			return result;
+		}),
+		kind: params.kind,
+		threadId: params.threadTs
+	});
+}
+function resolveToken(params) {
+	const explicit = normalizeOptionalString(params.explicit);
+	if (explicit) return explicit;
+	const fallback = normalizeOptionalString(params.fallbackToken);
+	if (!fallback) {
+		logVerbose(`slack send: missing write token for account=${params.accountId} explicit=${Boolean(params.explicit)} source=${params.fallbackSource ?? "unknown"}`);
+		throw new Error(`Slack write token missing for account "${params.accountId}".`);
+	}
+	return fallback;
+}
+function parseRecipient(raw) {
+	const target = parseSlackTarget(raw);
+	if (!target) throw new Error("Recipient is required for Slack sends");
+	return {
+		kind: target.kind,
+		id: canonicalizeSlackApiTargetId(target.kind, target.id, raw),
+		teamId: target.teamId
+	};
+}
+function parseEnterpriseEventRecipient(raw) {
+	const match = /^(?:channel:)?([CDG][A-Z0-9]+)$/i.exec(raw.trim());
+	if (!match?.[1]) throw new Error("unsupported_enterprise_slack_delivery_target");
+	return {
+		kind: "channel",
+		id: canonicalizeSlackApiTargetId("channel", match[1])
+	};
+}
+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 chunkLimit = resolveSlackTextChunkLimit(params);
+	if (params.preservePlainText) {
+		const chunks = [];
+		let remaining = text;
+		while (remaining) {
+			const chunk = sliceUtf16Safe(remaining, 0, chunkLimit) || Array.from(remaining)[0] || "";
+			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);
+	return resolveTextChunksWithFallback(text, (chunkMode === "newline" ? chunkMarkdownTextWithMode(text, chunkLimit, chunkMode) : [text]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode })));
+}
+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 createSlackDmCacheKey(params) {
+	return `${params.accountId ?? "default"}:${createSlackTokenCacheKey(params.token)}:${params.recipientId}`;
+}
+function getSlackDmChannelCache(client) {
+	const existing = slackDmChannelCaches.get(client);
+	if (existing) return existing;
+	const cache = /* @__PURE__ */ new Map();
+	slackDmChannelCaches.set(client, cache);
+	return cache;
+}
+function setSlackDmChannelCache(cache, key, channelId) {
+	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.set(key, channelId);
+}
+function isSlackUserRecipient(recipient) {
+	return recipient.kind === "user";
+}
+function resolveDirectUserPostChannelId(params) {
+	if (!isSlackUserRecipient(params.recipient) || 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 };
+	const cacheKey = createSlackDmCacheKey({
+		accountId: params.accountId,
+		token: params.token,
+		recipientId: recipient.id
+	});
+	const cache = getSlackDmChannelCache(client);
+	const cachedChannelId = cache.get(cacheKey);
+	if (cachedChannelId) return {
+		channelId: cachedChannelId,
+		isDm: true,
+		cacheHit: true
+	};
+	const channelId = (await withSlackDnsRequestRetry("conversations.open", () => client.conversations.open({ users: recipient.id }))).channel?.id;
+	if (!channelId) throw new Error("Failed to open Slack DM channel");
+	setSlackDmChannelCache(cache, cacheKey, channelId);
+	return {
+		channelId,
+		isDm: true,
+		cacheHit: false
+	};
+}
+async function resolveSlackDmChannelId(params) {
+	return (await resolveChannelId(params.client, {
+		kind: "user",
+		id: params.userId
+	}, {
+		accountId: params.accountId,
+		token: params.token
+	})).channelId;
+}
+function createSlackDeliveryMetadataId(queueId) {
+	const normalized = normalizeOptionalString(queueId);
+	if (!normalized) return;
+	return createHash("sha256").update(normalized).digest("base64url");
+}
+function createSlackDeliveryMetadataSignature(params) {
+	return createHmac("sha256", params.queueId).update(JSON.stringify([
+		SLACK_DELIVERY_METADATA_EVENT,
+		params.channelId,
+		params.threadTs ?? "",
+		params.partIndex,
+		params.partCount
+	])).digest("base64url");
+}
+function withSlackDeliveryMetadata(metadata, params) {
+	const queueId = normalizeOptionalString(params.queueId);
+	const deliveryId = createSlackDeliveryMetadataId(queueId);
+	if (!queueId || !deliveryId) return metadata;
+	const marker = {
+		[SLACK_DELIVERY_METADATA_KEY]: deliveryId,
+		[SLACK_DELIVERY_METADATA_PART_INDEX_KEY]: params.partIndex,
+		[SLACK_DELIVERY_METADATA_PART_COUNT_KEY]: params.partCount,
+		[SLACK_DELIVERY_METADATA_SIGNATURE_KEY]: createSlackDeliveryMetadataSignature({
+			queueId,
+			channelId: params.channelId,
+			threadTs: params.threadTs,
+			partIndex: params.partIndex,
+			partCount: params.partCount
+		})
+	};
+	if (!metadata) return {
+		event_type: SLACK_DELIVERY_METADATA_EVENT,
+		event_payload: marker
+	};
+	return {
+		...metadata,
+		event_payload: {
+			...metadata.event_payload,
+			...marker
+		}
+	};
+}
+function formatSlackTimestampFromMs(ms) {
+	return (Math.max(0, ms) / 1e3).toFixed(6);
+}
+function asSlackConversationMessages(response) {
+	return Array.isArray(response.messages) ? response.messages.filter((message) => typeof message === "object" && message !== null && !Array.isArray(message)) : [];
+}
+const SLACK_RECONCILIATION_EVIDENCE_RANK = {
+	none: 0,
+	partial: 1,
+	conflict: 2,
+	complete: 3
+};
+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 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;
+		const expectedSignature = createSlackDeliveryMetadataSignature({
+			queueId: params.queueId,
+			channelId: params.channelId,
+			threadTs: params.threadTs,
+			partIndex,
+			partCount
+		});
+		const actualSignature = marker[SLACK_DELIVERY_METADATA_SIGNATURE_KEY];
+		if (typeof actualSignature !== "string" || !safeEqualSecret(actualSignature, expectedSignature)) continue;
+		const messageId = typeof message.ts === "string" ? normalizeSlackThreadTsCandidate(message.ts) : void 0;
+		if (!messageId) continue;
+		const threadTs = typeof message.thread_ts === "string" ? normalizeSlackThreadTsCandidate(message.thread_ts) : void 0;
+		matches.push({
+			messageId,
+			partIndex,
+			partCount,
+			...threadTs ? { threadTs } : {}
+		});
+	}
+	return matches;
+}
+async function scanSlackConversationForDelivery(params) {
+	const threadTs = params.threadTs;
+	let cursor;
+	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({
+			channel: params.channelId,
+			oldest: params.oldest,
+			latest: params.latest,
+			include_all_metadata: true,
+			limit: SLACK_RECONCILE_LIMIT,
+			...cursor ? { cursor } : {}
+		}));
+		const matches = findSlackConversationDeliveryParts({
+			messages: asSlackConversationMessages(response),
+			queueId: params.queueId,
+			deliveryId: params.deliveryId,
+			channelId: params.channelId,
+			...threadTs ? { threadTs } : {}
+		});
+		for (const match of matches) {
+			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
+				},
+				evidence: "conflict"
+			};
+			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 reconciledThreadTs = completeParts[0]?.threadTs ?? params.threadTs;
+			const platformMessageIds = completeParts.map((part) => part.messageId);
+			return {
+				reconciliation: {
+					status: "sent",
+					messageId: platformMessageIds[0],
+					receipt: createSlackSendReceipt({
+						platformMessageIds,
+						channelId: params.channelId,
+						kind: "text",
+						...reconciledThreadTs ? { threadTs: reconciledThreadTs } : {}
+					})
+				},
+				evidence: "complete"
+			};
+		}
+		const nextCursor = normalizeOptionalString(response.response_metadata?.next_cursor);
+		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
+				},
+				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
+		},
+		evidence: deliveryParts.size > 0 ? "partial" : "none"
+	};
+}
+async function reconcileSlackUnknownSend(ctx) {
+	const account = resolveSlackAccount({
+		cfg: requireRuntimeConfig(ctx.cfg, "Slack delivery reconciliation"),
+		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
+	};
+	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 userRecipient = isSlackUserRecipient(recipient);
+	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
+	};
+	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),
+		threadId: ctx.threadId
+	});
+	const searchStartedAt = ctx.platformSendStartedAt ?? ctx.enqueuedAt;
+	const oldest = formatSlackTimestampFromMs(searchStartedAt - SLACK_RECONCILE_LOOKBACK_MS - SLACK_RECONCILE_CLOCK_SKEW_MS);
+	const latest = formatSlackTimestampFromMs(searchStartedAt + SLACK_RECONCILE_CLOCK_SKEW_MS);
+	try {
+		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, {
+			accountId: account.accountId,
+			token: channelToken
+		});
+		const lookupClients = [readClient, ...writeClient && writeClient !== readClient && writeToken !== readToken ? [writeClient] : []];
+		let lookupError;
+		let bestUnresolvedScan;
+		for (const lookupClient of lookupClients) try {
+			const scan = await scanSlackConversationForDelivery({
+				client: lookupClient,
+				channelId,
+				...threadTs ? { threadTs } : {},
+				oldest,
+				latest,
+				queueId: ctx.queueId,
+				deliveryId,
+				retryCount: ctx.retryCount
+			});
+			if (scan.reconciliation.status === "sent") return scan.reconciliation;
+			if (!bestUnresolvedScan || SLACK_RECONCILIATION_EVIDENCE_RANK[scan.evidence] > SLACK_RECONCILIATION_EVIDENCE_RANK[bestUnresolvedScan.evidence]) bestUnresolvedScan = scan;
+		} catch (err) {
+			lookupError = err;
+		}
+		if (bestUnresolvedScan) return bestUnresolvedScan.reconciliation;
+		throw lookupError;
+	} catch (err) {
+		return {
+			status: "unresolved",
+			error: readSlackRequestErrorMessage(enrichSlackWebApiError(err)),
+			retryable: ctx.retryCount < 3
+		};
+	}
+}
+async function sendMessageSlack(to, message, opts) {
+	const normalizedMessage = normalizeOptionalString(message) ?? "";
+	const trimmedMessage = opts.textIsSlackPlainText && normalizedMessage ? message : normalizedMessage;
+	const cfg = requireRuntimeConfig(opts.cfg, "Slack send");
+	const account = resolveSlackAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const eventScope = resolveSlackSendEventScope({ opts });
+	const recipient = eventScope ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
+	if (!eventScope) assertSlackDetachedTargetAllowed(account.accountId, recipient.teamId);
+	if (isSilentReplyText(normalizedMessage) && !opts.mediaUrl && !opts.blocks) {
+		logVerbose("slack send: suppressed NO_REPLY token before API call");
+		return {
+			messageId: "suppressed",
+			channelId: "",
+			receipt: createSlackSendReceipt({
+				platformMessageIds: [],
+				kind: "unknown"
+			})
+		};
+	}
+	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
+	if (!normalizedMessage && !opts.mediaUrl && !blocks) throw new Error("Slack send requires text, blocks, or media");
+	const queuedOpts = Object.freeze({ ...opts });
+	const delivery = resolveSlackDelivery({
+		account,
+		eventScope,
+		opts: queuedOpts,
+		recipient
+	});
+	const result = await runQueuedSlackSend(createSlackSendQueueKey({
+		accountId: account.accountId,
+		token: delivery.credential,
+		recipient: delivery.recipient,
+		threadTs: opts.threadTs,
+		teamId: delivery.teamId
+	}), () => sendMessageSlackQueued({
+		trimmedMessage,
+		opts: queuedOpts,
+		cfg,
+		account,
+		blocks,
+		delivery
+	}));
+	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.");
+	const directUserPostChannelId = opts.deliveryQueueId ? void 0 : resolveDirectUserPostChannelId({
+		recipient,
+		hasMedia: Boolean(opts.mediaUrl),
+		...opts.threadTs ? { threadTs: opts.threadTs } : {}
+	});
+	const { channelId } = directUserPostChannelId ? { channelId: directUserPostChannelId } : await resolveChannelId(client, recipient, {
+		accountId: account.accountId,
+		token: delivery.credential
+	});
+	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 () => {
+		if (didDispatch) return;
+		didDispatch = true;
+		await opts.onPlatformSendDispatch?.();
+	};
+	const explicitNativeDataFallbackBase = Object.hasOwn(opts, "nativeDataFallbackBaseText") ? opts.nativeDataFallbackBaseText?.trim() ?? "" : void 0;
+	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,
+		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 sentMessageIds = [];
+	let lastMessageId = "";
+	let deliveredChannelId = channelId;
+	let canonicalDeliveredThreadTs;
+	let sendIdentity = identity;
+	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 initialBlockMetadata = withSlackDeliveryMetadata(opts.metadata, {
+				queueId: opts.deliveryQueueId,
+				channelId,
+				threadTs: opts.threadTs,
+				partIndex: 0,
+				partCount: 1
+			});
+			await dispatchOnce();
+			try {
+				const { response } = await postSlackMessageBestEffort({
+					client,
+					channelId,
+					text: accessibilityText,
+					threadTs: opts.threadTs,
+					replyBroadcast: opts.replyBroadcast,
+					identity,
+					blocks,
+					metadata: initialBlockMetadata,
+					...usesOrderedBlockAccessibility ? { mrkdwn: false } : {},
+					unfurl
+				});
+				assertSlackPostMessageResponse(response, delivery.requireMessageTimestamp);
+				const messageId = response.ts ?? "unknown";
+				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");
+				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 posted = await postSlackMessageBestEffort({
+					client,
+					channelId,
+					text: fallback.text,
+					threadTs: opts.threadTs,
+					replyBroadcast: partIndex === 0 ? opts.replyBroadcast : void 0,
+					identity: sendIdentity,
+					...fallback.blocks ? { blocks: fallback.blocks } : {},
+					metadata,
+					mrkdwn: false,
+					unfurl
+				});
+				const response = posted.response;
+				assertSlackPostMessageResponse(response, delivery.requireMessageTimestamp);
+				sendIdentity = posted.identity;
+				lastMessageId = response.ts ?? lastMessageId;
+				deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
+				canonicalDeliveredThreadTs ??= resolvePostedMessageThreadTs(response);
+				if (!response.ts) continue;
+				sentMessageIds.push(response.ts);
+				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
+				const fallbackDelivery = await reportDelivery({
+					messageId: response.ts,
+					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 messageId = lastMessageId || "unknown";
+			const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
+			return {
+				messageId,
+				channelId: deliveredChannelId,
+				threadTs: deliveredThreadTs,
+				...questionDelivery?.meta ? { meta: {
+					...questionDelivery.meta,
+					slackQuestionMessageId: questionDelivery.messageId
+				} } : {},
+				receipt: createSlackSendReceipt({
+					platformMessageIds: sentMessageIds.length ? sentMessageIds : [messageId],
+					channelId: deliveredChannelId,
+					kind: fallbackMessages.some((message) => message.blocks) ? "card" : "text",
+					threadTs: deliveredThreadTs
+				})
+			};
+		}
+	}
+	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 ? { completionClient: delivery.upload.completionClient } : {},
+			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,
+			...delivery.upload ? { auditContext: delivery.upload.auditContext } : {}
+		});
+		sentMessageIds.push(lastMessageId);
+		await reportDelivery({
+			messageId: lastMessageId,
+			channelId,
+			threadTs: normalizeSlackThreadTsCandidate(opts.threadTs),
+			receipt: createSlackSendReceipt({
+				platformMessageIds: [lastMessageId],
+				channelId,
+				kind: "media",
+				threadTs: normalizeSlackThreadTsCandidate(opts.threadTs)
+			})
+		});
+		chunksToPost = rest;
+	} else chunksToPost = resolvedChunks.length ? resolvedChunks : [""];
+	for (const [partIndex, chunk] of chunksToPost.entries()) {
+		const carriesPrimaryMessageOptions = partIndex === 0 && !opts.mediaUrl && sentMessageIds.length === 0;
+		const baseMetadata = carriesPrimaryMessageOptions ? opts.metadata : void 0;
+		const metadata = opts.mediaUrl ? baseMetadata : withSlackDeliveryMetadata(baseMetadata, {
+			queueId: opts.deliveryQueueId,
+			channelId,
+			threadTs: opts.threadTs,
+			partIndex,
+			partCount: chunksToPost.length
+		});
+		if (partIndex === 0 && !opts.mediaUrl) await dispatchOnce();
+		const posted = await postSlackMessageBestEffort({
+			client,
+			channelId,
+			text: chunk,
+			threadTs: opts.threadTs,
+			replyBroadcast: carriesPrimaryMessageOptions ? opts.replyBroadcast : void 0,
+			identity: sendIdentity,
+			metadata,
+			...opts.textIsSlackPlainText ? { mrkdwn: false } : {},
+			unfurl
+		});
+		const response = posted.response;
+		assertSlackPostMessageResponse(response, delivery.requireMessageTimestamp);
+		sendIdentity = posted.identity;
+		lastMessageId = response.ts ?? lastMessageId;
+		deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
+		canonicalDeliveredThreadTs ??= resolvePostedMessageThreadTs(response);
+		if (response.ts) {
+			sentMessageIds.push(response.ts);
+			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)
+				})
+			});
+		}
+	}
+	const messageId = lastMessageId || "unknown";
+	const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
+	return {
+		messageId,
+		channelId: deliveredChannelId,
+		threadTs: deliveredThreadTs,
+		receipt: createSlackSendReceipt({
+			platformMessageIds: sentMessageIds.length ? sentMessageIds : [messageId],
+			channelId: deliveredChannelId,
+			kind: opts.mediaUrl ? "media" : "text",
+			threadTs: deliveredThreadTs
+		})
+	};
+}
+//#endregion
+export { updateMessageSlack as a, hasSlackThreadFailureNotice as c, recordSlackThreadFailureNotice as d, recordSlackThreadParticipation as f, setSlackDefaultSendIdentity as i, hasSlackThreadParticipation as l, chunkSlackTextAtHardLimit as m, resolveSlackDmChannelId as n, clearSlackThreadFailureNotice as o, buildSlackNativeDataDeliveryPlan as p, sendMessageSlack as r, clearSlackThreadParticipationCache as s, reconcileSlackUnknownSend as t, hasSlackThreadParticipationWithPersistence as u };