@openclaw/slack 2026.7.2-beta.7 → 2026.7.33

package/dist/.setup/send-DEOvcVM4.mjs

@@ -0,0 +1,933 @@
+import { a as resolveSlackAccount, f as resolveSlackBotToken, l as resolveSlackOperationToken } from "./accounts-uGn8E6uq.mjs";
+import { r as parseSlackTarget } from "./target-parsing-C36VFWHQ.mjs";
+import "./targets-DnpzC22e.mjs";
+import { a as SLACK_TEXT_LIMIT, b as truncateSlackText, i as validateSlackBlocksArray } from "./reply-blocks-Cwu6LYJI.mjs";
+import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.mjs";
+import { a as getSlackWriteClient, n as createSlackTokenCacheKey, r as createSlackWebClient } from "./client-B6i83rHk.mjs";
+import { t as getOptionalSlackRuntime } from "./runtime-BOk7xkOl.mjs";
+import { t as markdownToSlackMrkdwnChunks } from "./format-xuAop9a-.mjs";
+import { i as loadOutboundMediaFromUrl } from "./runtime-api-BnavgpzD.mjs";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+import { withTrustedEnvProxyGuardedFetchMode } from "openclaw/plugin-sdk/fetch-runtime";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-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 { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
+import { createPersistentDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
+//#region extensions/slack/src/blocks-fallback.ts
+function cleanCandidate(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.replace(/\s+/g, " ").trim();
+	return normalized.length > 0 ? normalized : void 0;
+}
+function readSectionText(block) {
+	return cleanCandidate(block.text?.text);
+}
+function readHeaderText(block) {
+	return cleanCandidate(block.text?.text);
+}
+function readImageText(block) {
+	return cleanCandidate(block.alt_text) ?? cleanCandidate(block.title?.text);
+}
+function readVideoText(block) {
+	return cleanCandidate(block.title?.text) ?? cleanCandidate(block.alt_text);
+}
+function readContextText(block) {
+	if (!Array.isArray(block.elements)) return;
+	const textParts = block.elements.map((element) => cleanCandidate(element.text)).filter((value) => Boolean(value));
+	return textParts.length > 0 ? textParts.join(" ") : void 0;
+}
+function buildSlackBlocksFallbackText(blocks) {
+	for (const raw of blocks) {
+		const block = raw;
+		switch (block.type) {
+			case "header": {
+				const text = readHeaderText(block);
+				if (text) return text;
+				break;
+			}
+			case "section": {
+				const text = readSectionText(block);
+				if (text) return text;
+				break;
+			}
+			case "image": {
+				const text = readImageText(block);
+				if (text) return text;
+				return "Shared an image";
+			}
+			case "video": {
+				const text = readVideoText(block);
+				if (text) return text;
+				return "Shared a video";
+			}
+			case "file": return "Shared a file";
+			case "context": {
+				const text = readContextText(block);
+				if (text) return text;
+				break;
+			}
+		}
+	}
+	return "Shared a Block Kit message";
+}
+//#endregion
+//#region extensions/slack/src/sent-thread-cache.ts
+const threadParticipation = createPersistentDedupeCache({
+	globalKey: Symbol.for("openclaw.slackThreadParticipation"),
+	ttlMs: 864e5,
+	maxSize: 5e3,
+	persistent: {
+		namespace: "slack.thread-participation",
+		maxEntries: 1e3,
+		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 {}
+		}
+	}
+});
+function makeKey(accountId, channelId, threadTs) {
+	return `${accountId}:${channelId}:${threadTs}`;
+}
+function recordSlackThreadParticipation(accountId, channelId, threadTs, opts) {
+	if (!accountId || !channelId || !threadTs) return;
+	threadParticipation.register(makeKey(accountId, channelId, threadTs), {
+		...opts?.agentId ? { agentId: opts.agentId } : {},
+		repliedAt: Date.now()
+	});
+}
+function hasSlackThreadParticipation(accountId, channelId, threadTs) {
+	if (!accountId || !channelId || !threadTs) return false;
+	return threadParticipation.peek(makeKey(accountId, channelId, threadTs));
+}
+async function hasSlackThreadParticipationWithPersistence(params) {
+	if (!params.accountId || !params.channelId || !params.threadTs) return false;
+	return await threadParticipation.lookup(makeKey(params.accountId, params.channelId, params.threadTs));
+}
+function clearSlackThreadParticipationCache() {
+	threadParticipation.clearForTest();
+}
+//#endregion
+//#region extensions/slack/src/send.ts
+const SLACK_UPLOAD_SSRF_POLICY = {
+	allowedHostnames: [
+		"*.slack.com",
+		"*.slack-edge.com",
+		"*.slack-files.com"
+	],
+	allowRfc2544BenchmarkRange: true
+};
+const SLACK_DM_CHANNEL_CACHE_MAX = 1024;
+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;
+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 = 3e5;
+const SLACK_RECONCILE_LIMIT = 100;
+const SLACK_RECONCILE_MAX_PAGES = 10;
+const slackDmChannelCache = /* @__PURE__ */ new Map();
+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 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 } : {},
+		...threadPayload,
+		...unfurlPayload
+	};
+	return {
+		channel: params.channelId,
+		text: params.text,
+		...params.metadata ? { metadata: params.metadata } : {},
+		...threadPayload,
+		...unfurlPayload
+	};
+}
+function normalizeSlackScopeList(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((scope) => {
+		const normalized = normalizeOptionalString(scope);
+		return normalized ? [normalized] : [];
+	});
+}
+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 = normalizeSlackScopeList(data?.response_metadata?.scopes);
+	if (scopes.length) details.push(`granted: ${scopes.join(", ")}`);
+	const acceptedScopes = normalizeSlackScopeList(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 readSlackRequestErrorCode(value) {
+	if (!value || typeof value !== "object") return;
+	const code = value.code;
+	return typeof code === "string" ? code.toUpperCase() : void 0;
+}
+function readSlackRequestErrorMessage(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(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));
+	});
+}
+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");
+}
+function isSlackCustomizeScopeError(err) {
+	const data = getSlackWebApiErrorData(err);
+	if (normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.error)) !== "missing_scope") return false;
+	if (normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.needed))?.includes("chat:write.customize")) return true;
+	return [...normalizeSlackScopeList(data?.response_metadata?.scopes), ...normalizeSlackScopeList(data?.response_metadata?.acceptedScopes)].map((scope) => normalizeLowercaseStringOrEmpty(scope)).includes("chat:write.customize");
+}
+function isSlackCustomIdentityRejectedError(err) {
+	if (isSlackCustomizeScopeError(err)) return true;
+	const data = getSlackWebApiErrorData(err);
+	const code = normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.error));
+	return code === "invalid_arguments" || code === "invalid_arg_name";
+}
+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
+	});
+	try {
+		const identity = params.identity;
+		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) {
+		const identity = params.identity;
+		if (!identity || !hasCustomIdentity(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);
+	}
+}
+function resolvePostedMessageThreadTs(response) {
+	const threadTs = response.message?.thread_ts;
+	return typeof threadTs === "string" ? normalizeSlackThreadTsCandidate(threadTs) : void 0;
+}
+function createSlackSendReceipt(params) {
+	const platformMessageIds = params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown" && messageId !== "suppressed");
+	return createMessageReceiptFromOutboundResults({
+		results: platformMessageIds.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 = resolveSlackBotToken(params.explicit);
+	if (explicit) return explicit;
+	const fallback = resolveSlackBotToken(params.fallbackToken);
+	if (!fallback) {
+		logVerbose(`slack send: missing bot token for account=${params.accountId} explicit=${Boolean(params.explicit)} source=${params.fallbackSource ?? "unknown"}`);
+		throw new Error(`Slack bot token missing for account "${params.accountId}" (set channels.slack.accounts.${params.accountId}.botToken or SLACK_BOT_TOKEN for default).`);
+	}
+	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: target.id
+	};
+}
+function createSlackSendQueueKey(params) {
+	const recipientKey = `${params.recipient.kind === "user" || /^U[A-Z0-9]+$/i.test(params.recipient.id) ? "user" : params.recipient.kind}:${params.recipient.id}`;
+	return `${params.accountId}:${createSlackTokenCacheKey(params.token)}:${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 setSlackDmChannelCache(key, channelId) {
+	if (slackDmChannelCache.has(key)) slackDmChannelCache.delete(key);
+	else if (slackDmChannelCache.size >= SLACK_DM_CHANNEL_CACHE_MAX) {
+		const oldest = slackDmChannelCache.keys().next().value;
+		if (oldest) slackDmChannelCache.delete(oldest);
+	}
+	slackDmChannelCache.set(key, channelId);
+}
+function isSlackUserRecipient(recipient) {
+	return recipient.kind === "user" || /^U[A-Z0-9]+$/i.test(recipient.id);
+}
+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 cachedChannelId = slackDmChannelCache.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(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 matchesSlackDeliveryMetadataSignature(actual, expected) {
+	if (typeof actual !== "string" || actual.length !== expected.length) return false;
+	return timingSafeEqual(Buffer.from(actual), Buffer.from(expected));
+}
+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
+		});
+		if (!matchesSlackDeliveryMetadataSignature(marker[SLACK_DELIVERY_METADATA_SIGNATURE_KEY], 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, opts) {
+	const cfg = requireRuntimeConfig(ctx.cfg, "Slack delivery reconciliation");
+	const account = resolveSlackAccount({
+		cfg,
+		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 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 {
+		status: "unresolved",
+		error: `Slack write token missing for direct-message reconciliation on account "${account.accountId}"`,
+		retryable: false
+	};
+	const readClient = opts?.client ?? createSlackWebClient(readToken);
+	const writeClient = opts?.client ?? (writeToken ? getSlackWriteClient(writeToken) : void 0);
+	const payloadReplyToId = ctx.payloads[0]?.replyToId;
+	const effectiveReplyToId = Object.hasOwn(ctx, "effectiveReplyToId") ? normalizeOptionalString(ctx.effectiveReplyToId) : payloadReplyToId != null ? normalizeOptionalString(payloadReplyToId) : ctx.replyToMode === "off" ? void 0 : normalizeOptionalString(ctx.replyToId);
+	const threadTs = resolveSlackThreadTsValue({
+		replyToId: effectiveReplyToId,
+		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 = opts?.client ? [opts.client] : [readClient, ...writeClient && 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 uploadSlackFile(params) {
+	const { buffer, contentType, fileName } = await loadOutboundMediaFromUrl(params.mediaUrl, {
+		maxBytes: params.maxBytes,
+		mediaAccess: params.mediaAccess,
+		mediaLocalRoots: params.mediaLocalRoots,
+		mediaReadFile: params.mediaReadFile
+	});
+	const uploadFileName = params.uploadFileName ?? fileName ?? "upload";
+	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 uploadBody = new Uint8Array(buffer);
+	const { response: uploadResp, release } = await fetchWithSsrFGuard(withTrustedEnvProxyGuardedFetchMode({
+		url: uploadUrlResp.upload_url,
+		init: {
+			method: "POST",
+			...contentType ? { headers: { "Content-Type": contentType } } : {},
+			body: uploadBody
+		},
+		policy: SLACK_UPLOAD_SSRF_POLICY,
+		auditContext: "slack-upload-file"
+	}));
+	try {
+		if (!uploadResp.ok) throw new Error(`Failed to upload file: HTTP ${uploadResp.status}`);
+	} finally {
+		await release();
+	}
+	await params.onPlatformSendDispatch?.();
+	const completeResp = await withSlackDnsRequestRetry("files.completeUploadExternal", () => params.client.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;
+}
+async function sendMessageSlack(to, message, opts) {
+	const trimmedMessage = normalizeOptionalString(message) ?? "";
+	if (isSilentReplyText(trimmedMessage) && !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 (!trimmedMessage && !opts.mediaUrl && !blocks) throw new Error("Slack send requires text, blocks, or media");
+	const cfg = requireRuntimeConfig(opts.cfg, "Slack send");
+	const account = resolveSlackAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const token = resolveToken({
+		explicit: opts.token,
+		accountId: account.accountId,
+		fallbackToken: account.botToken,
+		fallbackSource: account.botTokenSource
+	});
+	const recipient = parseRecipient(to);
+	const result = await runQueuedSlackSend(createSlackSendQueueKey({
+		accountId: account.accountId,
+		token,
+		recipient,
+		threadTs: opts.threadTs
+	}), () => sendMessageSlackQueued({
+		trimmedMessage,
+		opts,
+		cfg,
+		account,
+		token,
+		recipient,
+		blocks
+	}));
+	const threadTs = result.threadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
+	if (threadTs && result.channelId && account.accountId) recordSlackThreadParticipation(account.accountId, result.channelId, threadTs);
+	return result;
+}
+async function sendMessageSlackQueued(params) {
+	try {
+		return await sendMessageSlackQueuedInner(params);
+	} catch (err) {
+		throw enrichSlackWebApiError(err);
+	}
+}
+async function sendMessageSlackQueuedInner(params) {
+	const { opts, cfg, account, token, recipient, blocks, trimmedMessage } = params;
+	const client = opts.client ?? getSlackWriteClient(token);
+	const identity = resolveSlackSendIdentity({
+		accountId: account.accountId,
+		explicit: opts.identity
+	});
+	if (opts.replyBroadcast && opts.mediaUrl) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
+	const unfurl = {
+		unfurlLinks: account.config.unfurlLinks,
+		unfurlMedia: account.config.unfurlMedia
+	};
+	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
+	});
+	const reportDelivery = async (result) => {
+		await opts.onDeliveryResult?.(result);
+		return result;
+	};
+	if (blocks) {
+		if (opts.mediaUrl) throw new Error("Slack send does not support blocks with mediaUrl");
+		const fallbackText = truncateSlackText(trimmedMessage || buildSlackBlocksFallbackText(blocks), SLACK_TEXT_LIMIT);
+		await opts.onPlatformSendDispatch?.();
+		const { response } = await postSlackMessageBestEffort({
+			client,
+			channelId,
+			text: fallbackText,
+			threadTs: opts.threadTs,
+			replyBroadcast: opts.replyBroadcast,
+			identity,
+			blocks,
+			metadata: opts.metadata,
+			unfurl
+		});
+		const messageId = response.ts ?? "unknown";
+		const 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
+			})
+		});
+	}
+	const textLimit = resolveTextChunkLimit(cfg, "slack", account.accountId, { fallbackLimit: SLACK_TEXT_LIMIT });
+	const chunkLimit = Math.min(textLimit, SLACK_TEXT_LIMIT);
+	const tableMode = resolveMarkdownTableMode({
+		cfg,
+		channel: "slack",
+		accountId: account.accountId
+	});
+	const chunkMode = resolveChunkMode(cfg, "slack", account.accountId);
+	const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(trimmedMessage, chunkLimit, chunkMode) : [trimmedMessage]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode }));
+	const resolvedChunks = resolveTextChunksWithFallback(trimmedMessage, chunks);
+	const mediaMaxBytes = typeof account.config.mediaMaxMb === "number" ? account.config.mediaMaxMb * 1024 * 1024 : void 0;
+	const sentMessageIds = [];
+	let lastMessageId = "";
+	let deliveredChannelId = channelId;
+	let canonicalDeliveredThreadTs;
+	let chunksToPost;
+	if (opts.mediaUrl) {
+		const [firstChunk, ...rest] = resolvedChunks;
+		lastMessageId = await uploadSlackFile({
+			client,
+			channelId,
+			mediaUrl: opts.mediaUrl,
+			mediaAccess: opts.mediaAccess,
+			uploadFileName: opts.uploadFileName,
+			uploadTitle: opts.uploadTitle,
+			mediaLocalRoots: opts.mediaLocalRoots,
+			mediaReadFile: opts.mediaReadFile,
+			caption: firstChunk,
+			threadTs: opts.threadTs,
+			maxBytes: mediaMaxBytes,
+			onPlatformSendDispatch: opts.onPlatformSendDispatch
+		});
+		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 : [""];
+	let sendIdentity = identity;
+	for (const [partIndex, chunk] of chunksToPost.entries()) {
+		const baseMetadata = sentMessageIds.length === 0 ? 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 opts.onPlatformSendDispatch?.();
+		const posted = await postSlackMessageBestEffort({
+			client,
+			channelId,
+			text: chunk,
+			threadTs: opts.threadTs,
+			replyBroadcast: sentMessageIds.length === 0 ? opts.replyBroadcast : void 0,
+			identity: sendIdentity,
+			metadata,
+			unfurl
+		});
+		const response = posted.response;
+		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 { clearSlackThreadParticipationCache as a, recordSlackThreadParticipation as c, setSlackDefaultSendIdentity as i, buildSlackBlocksFallbackText as l, resolveSlackDmChannelId as n, hasSlackThreadParticipation as o, sendMessageSlack as r, hasSlackThreadParticipationWithPersistence as s, reconcileSlackUnknownSend as t };