@openclaw/slack 2026.8.1-beta.2 → 2026.8.1

package/dist/{actions-BTDXwwE3.js → actions-BI7JkfVm.js}

@@ -1,23 +1,46 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as resolveSlackAccount, f as resolveSlackBotToken } from "./accounts-CK4AVI2_.js";
-import { E as isSlackInvalidBlocksError, K as truncateSlackTextByUtf8Bytes, L as SLACK_EDIT_TEXT_MAX_BYTES, M as normalizeSlackOutboundText, N as buildSlackBlocksFallbackText, P as buildSlackCompleteBlocksFallbackText, S as appendSlackNativeDataPlainTextFallback, T as hasSlackNativeDataBlock, W as countSlackTextUtf8Bytes, at as escapeSlackMrkdwn, k as stripSlackNativeDataBlocks, p as assertSlackDetachedTargetAllowed, ut as validateSlackBlocksArray, x as appendSlackNativeDataFallbackText } from "./group-policy-c4RP9bjc.js";
-import { d as getSlackWriteClient, i as createSlackLookupClient } from "./probe-HoEg_WxB.js";
-import { a as resolveSlackMessageText$1, i as resolveSlackBlocksText, n as hasSlackTableBlock, r as isSlackUnfurlAttachment, t as hasSlackMessageTableBlock } from "./block-text-YtiNkqmx.js";
-import { p as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-Nor0iBwY.js";
+import { a as resolveSlackAccount, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId } from "./accounts-Dm_H77gH.js";
+import { n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
+import { At as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, D as renderSlackBlockFallbackText, E as buildSlackCompleteBlocksFallbackText, I as countSlackTextUtf8Bytes, Q as normalizeSlackOutboundText, R as truncateSlackTextByUtf8Bytes, T as buildSlackBlocksFallbackText, _ as appendSlackNativeDataPlainTextFallback, b as hasSlackNativeDataBlock, c as assertSlackDetachedTargetAllowed, et as escapeSlackMrkdwn, g as appendSlackNativeDataFallbackText, k as SLACK_EDIT_TEXT_MAX_BYTES, st as validateSlackBlocksArray, w as stripSlackNativeDataBlocks, x as isSlackInvalidBlocksError } from "./group-policy-BdwszjYn.js";
+import { S as getSlackWriteClient, h as createSlackLookupClient } from "./probe-0usmAb0i.js";
+import { m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-DS9ICrBI.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { logVerbose, logVerbose as logVerbose$1 } from "openclaw/plugin-sdk/runtime-env";
-import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { createSubsystemLogger, logVerbose, logVerbose as logVerbose$1 } from "openclaw/plugin-sdk/runtime-env";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
 import { z } from "zod";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import fs from "node:fs/promises";
+import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { normalizeHostname } from "openclaw/plugin-sdk/host-runtime";
 import { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
-import pMap, { pMapSkip } from "p-map";
 import { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
 import { saveRemoteMedia } from "openclaw/plugin-sdk/media-runtime";
-import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
+//#region extensions/slack/src/conversation-open.ts
+function parseSlackConversationOpenInput(userIds, teamId) {
+	const users = z.array(z.string().trim().regex(/^[UW][A-Z0-9]+$/)).min(1).max(8).parse(userIds);
+	if (new Set(users).size !== users.length) throw new Error("Slack conversation-open requires distinct userIds.");
+	return {
+		users,
+		teamId: teamId === void 0 ? void 0 : z.string().trim().regex(/^T[A-Z0-9]+$/i).parse(teamId)
+	};
+}
+async function openSlackConversationWithClient(client, input) {
+	const channelId = (await client.conversations.open({ users: input.users.join(",") })).channel?.id?.trim();
+	if (!channelId || !/^[CDG][A-Z0-9]+$/i.test(channelId)) throw new Error("Slack conversations.open did not return a valid conversation ID.");
+	return {
+		channelId,
+		target: formatSlackTarget({
+			teamId: input.teamId,
+			kind: "channel",
+			id: channelId,
+			explicitKind: true
+		})
+	};
+}
+//#endregion
 //#region extensions/slack/src/edit-text.ts
 function buildSlackEditTextPayload(content, blocks) {
 	const trimmedContent = content.trim();
@@ -31,6 +54,85 @@ function buildSlackEditTextPayload(content, blocks) {
 	return " ";
 }
 //#endregion
+//#region extensions/slack/src/monitor/block-text.ts
+function readSlackBlockType(block) {
+	return block && typeof block === "object" && !Array.isArray(block) ? block.type : void 0;
+}
+function hasSlackTableBlock(blocks) {
+	return blocks?.some((block) => readSlackBlockType(block) === "table") ?? false;
+}
+function hasSlackMessageTableBlock(message) {
+	return hasSlackTableBlock(message.blocks) || message.attachments?.some((attachment) => !isSlackUnfurlAttachment(attachment) && hasSlackTableBlock(attachment.blocks)) === true;
+}
+function isSlackUnfurlAttachment(attachment) {
+	return attachment.is_msg_unfurl === true || attachment.is_app_unfurl === true || typeof attachment.app_unfurl_url === "string" && attachment.app_unfurl_url.trim().length > 0;
+}
+function resolveSlackBlocksText(blocks) {
+	if (!blocks?.length) return;
+	const parts = [];
+	let hasRichText = false;
+	let hasNativeData = false;
+	for (const block of blocks) {
+		const blockType = readSlackBlockType(block);
+		hasRichText ||= blockType === "rich_text";
+		hasNativeData ||= blockType === "data_visualization" || blockType === "data_table" || blockType === "table";
+		const text = renderSlackBlockFallbackText(block, {
+			nativeDataFormat: "plain",
+			nativeReferenceFormat: "plain"
+		});
+		if (text) parts.push(text);
+	}
+	return parts.length > 0 ? {
+		text: parts.join("\n"),
+		hasRichText,
+		hasNativeData
+	} : void 0;
+}
+function appendDistinctSlackText(base, addition) {
+	if (!base) return addition;
+	const comparableBase = `\n${base.replace(/\r\n?/g, "\n")}\n`;
+	const comparableAddition = `\n${addition.replace(/\r\n?/g, "\n")}\n`;
+	if (comparableBase.includes(comparableAddition)) return base;
+	return `${base}\n${addition}`;
+}
+function resolveSlackAttachmentTableTexts(attachments) {
+	const seen = /* @__PURE__ */ new Set();
+	const texts = [];
+	for (const attachment of attachments ?? []) {
+		if (isSlackUnfurlAttachment(attachment)) continue;
+		for (const block of attachment.blocks ?? []) {
+			if (readSlackBlockType(block) !== "table") continue;
+			const text = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
+			if (!text || seen.has(text)) continue;
+			seen.add(text);
+			texts.push(text);
+		}
+	}
+	return texts;
+}
+/** Resolve agent-visible Slack text while admitting only native tables from attachments. */
+function resolveSlackMessageText(message, options = {}) {
+	let resolved = chooseSlackPrimaryText({
+		messageText: options.preserveMessageTextWhitespace ? typeof message.text === "string" && message.text.trim().length > 0 ? message.text : void 0 : normalizeOptionalString(message.text),
+		blocksText: resolveSlackBlocksText(message.blocks)
+	});
+	for (const tableText of resolveSlackAttachmentTableTexts(message.attachments)) resolved = appendDistinctSlackText(resolved, tableText);
+	return resolved;
+}
+function chooseSlackPrimaryText(params) {
+	const { messageText, blocksText } = params;
+	if (!blocksText) return messageText;
+	if (!messageText) return blocksText.text;
+	if (blocksText.hasNativeData) {
+		const comparableMessageText = messageText.replace(/\s+/g, " ").trim();
+		const comparableBlocksText = blocksText.text.replace(/\s+/g, " ").trim();
+		if (comparableMessageText.includes(comparableBlocksText)) return messageText;
+		return comparableBlocksText.startsWith(comparableMessageText) ? blocksText.text : `${messageText}\n${blocksText.text}`;
+	}
+	if (blocksText.hasRichText && blocksText.text.length > messageText.length) return blocksText.text;
+	return blocksText.text.length > messageText.length && blocksText.text.startsWith(messageText) ? blocksText.text : messageText;
+}
+//#endregion
 //#region extensions/slack/src/file-reference.ts
 function formatSlackFileReference(file) {
 	const name = normalizeOptionalString(file?.name) ?? "file";
@@ -49,164 +151,11 @@ function formatSlackFileReferenceList(files) {
 	return files.map((file) => formatSlackFileReference(file)).join(", ");
 }
 //#endregion
-//#region extensions/slack/src/monitor/thread.ts
-const THREAD_STARTER_CACHE = /* @__PURE__ */ new Map();
-const THREAD_STARTER_CACHE_TTL_MS = 360 * 6e4;
-const THREAD_STARTER_CACHE_MAX = 2e3;
-function evictThreadStarterCache() {
-	const now = asDateTimestampMs(Date.now());
-	if (now === void 0) {
-		THREAD_STARTER_CACHE.clear();
-		return;
-	}
-	for (const [cacheKey, entry] of THREAD_STARTER_CACHE.entries()) if (asDateTimestampMs(entry.expiresAt) === void 0 || entry.expiresAt <= now) THREAD_STARTER_CACHE.delete(cacheKey);
-	pruneMapToMaxSize(THREAD_STARTER_CACHE, THREAD_STARTER_CACHE_MAX);
-}
-function formatSlackFilePlaceholder(files) {
-	return `[attached: ${formatSlackFileReferenceList(files)}]`;
-}
-function pushUniqueText(parts, value, options = {}) {
-	const text = options.preserveWhitespace ? typeof value === "string" && value.trim().length > 0 ? value : void 0 : normalizeOptionalString(value);
-	if (text && !parts.includes(text)) parts.push(text);
-}
-function resolveSlackBlocksFallbackText(blocks) {
-	return resolveSlackBlocksText(blocks)?.text;
-}
-function resolveSlackAttachmentFallbackText(attachments) {
-	if (!Array.isArray(attachments) || attachments.length === 0) return;
-	const parts = [];
-	for (const attachment of attachments) {
-		const excludeTableBlocks = isSlackUnfurlAttachment(attachment);
-		const fallbackBlocks = (blocks) => excludeTableBlocks ? blocks?.filter((block) => !hasSlackTableBlock([block])) : blocks;
-		pushUniqueText(parts, attachment.pretext);
-		pushUniqueText(parts, attachment.title);
-		pushUniqueText(parts, attachment.text);
-		if (!(hasSlackTableBlock(attachment.blocks) && normalizeOptionalString(attachment.fallback) === "[no preview available]")) pushUniqueText(parts, attachment.fallback);
-		for (const field of attachment.fields ?? []) {
-			pushUniqueText(parts, field.title);
-			pushUniqueText(parts, field.value);
-		}
-		pushUniqueText(parts, resolveSlackBlocksFallbackText(fallbackBlocks(attachment.blocks)), { preserveWhitespace: true });
-		pushUniqueText(parts, resolveSlackBlocksFallbackText(fallbackBlocks(attachment.message_blocks)), { preserveWhitespace: true });
-	}
-	return parts.length > 0 ? parts.join("\n") : void 0;
-}
-function resolveSlackMessageText(message) {
-	const messageText = normalizeOptionalString(message.text) ?? resolveSlackAttachmentFallbackText(message.attachments);
-	return resolveSlackMessageText$1({
-		...message,
-		text: messageText
-	}, { preserveMessageTextWhitespace: true });
-}
-async function resolveSlackThreadStarter(params) {
-	evictThreadStarterCache();
-	const cacheKey = JSON.stringify([
-		params.workspaceScope.accountId,
-		params.workspaceScope.teamId,
-		params.channelId,
-		params.threadTs
-	]);
-	const cached = THREAD_STARTER_CACHE.get(cacheKey);
-	if (cached) {
-		const now = asDateTimestampMs(Date.now());
-		if (now !== void 0 && cached.expiresAt > now) return cached.value;
-		THREAD_STARTER_CACHE.delete(cacheKey);
-	}
-	try {
-		const message = (await params.client.conversations.replies({
-			channel: params.channelId,
-			ts: params.threadTs,
-			limit: 1,
-			inclusive: true
-		}))?.messages?.[0];
-		const text = message ? resolveSlackMessageText(message) : void 0;
-		const files = message?.files?.length ? message.files : void 0;
-		if (!message || !text && !files) return null;
-		const starter = {
-			text: text || formatSlackFilePlaceholder(files),
-			userId: message.user,
-			botId: message.bot_id,
-			ts: message.ts,
-			files
-		};
-		const expiresAt = resolveExpiresAtMsFromDurationMs(THREAD_STARTER_CACHE_TTL_MS);
-		if (expiresAt !== void 0) {
-			if (THREAD_STARTER_CACHE.has(cacheKey)) THREAD_STARTER_CACHE.delete(cacheKey);
-			THREAD_STARTER_CACHE.set(cacheKey, {
-				value: starter,
-				expiresAt
-			});
-			evictThreadStarterCache();
-		}
-		return starter;
-	} catch (err) {
-		logVerbose$1(`slack thread starter fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
-		return null;
-	}
-}
-function resetSlackThreadStarterCacheForTest() {
-	THREAD_STARTER_CACHE.clear();
-}
-const SLACK_THREAD_HISTORY_MAX_PAGES = 3;
-/**
-* Fetches the most recent messages in a Slack thread (excluding the current message).
-* Used to populate thread context when a new thread session starts.
-*
-* Uses cursor pagination and keeps only the latest N retained messages when the full
-* thread fits in the bounded fetch window.
-*/
-async function resolveSlackThreadHistory(params) {
-	const maxMessages = params.limit ?? 20;
-	if (!Number.isFinite(maxMessages) || maxMessages <= 0) return [];
-	const fetchLimit = 200;
-	const retained = [];
-	let cursor;
-	let pagesFetched = 0;
-	try {
-		do {
-			pagesFetched += 1;
-			const response = await params.client.conversations.replies({
-				channel: params.channelId,
-				ts: params.threadTs,
-				limit: fetchLimit,
-				inclusive: true,
-				...cursor ? { cursor } : {}
-			});
-			for (const msg of response.messages ?? []) {
-				if (!resolveSlackMessageText(msg) && !msg.files?.length) continue;
-				if (params.currentMessageTs && msg.ts === params.currentMessageTs) continue;
-				retained.push(msg);
-			}
-			if (retained.length > maxMessages) retained.splice(0, retained.length - maxMessages);
-			const next = response.response_metadata?.next_cursor;
-			cursor = typeof next === "string" && next.trim().length > 0 ? next.trim() : void 0;
-		} while (cursor && pagesFetched < SLACK_THREAD_HISTORY_MAX_PAGES);
-		if (cursor) {
-			logVerbose$1(`slack thread history capped channel=${params.channelId} ts=${params.threadTs} pages=${SLACK_THREAD_HISTORY_MAX_PAGES}`);
-			return [];
-		}
-		return retained.map((msg) => ({
-			text: resolveSlackMessageText(msg) ?? formatSlackFilePlaceholder(msg.files),
-			userId: msg.user,
-			botId: msg.bot_id,
-			ts: msg.ts,
-			files: msg.files
-		}));
-	} catch (err) {
-		logVerbose$1(`slack thread history fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
-		return [];
-	}
-}
+//#region extensions/slack/src/monitor/media.runtime.ts
+const slackMediaLog = createSubsystemLogger("gateway/channels/slack").child("media");
 //#endregion
-//#region extensions/slack/src/monitor/media.ts
-var media_exports = /* @__PURE__ */ __exportAll({
-	SLACK_MEDIA_READ_IDLE_TIMEOUT_MS: () => SLACK_MEDIA_READ_IDLE_TIMEOUT_MS,
-	resetSlackThreadStarterCacheForTest: () => resetSlackThreadStarterCacheForTest,
-	resolveSlackAttachmentContent: () => resolveSlackAttachmentContent,
-	resolveSlackMedia: () => resolveSlackMedia,
-	resolveSlackThreadHistory: () => resolveSlackThreadHistory,
-	resolveSlackThreadStarter: () => resolveSlackThreadStarter
-});
+//#region extensions/slack/src/monitor/slack-client-kind.ts
+/** Detects the isolated GovSlack API plane without consulting mutable config. */
 function isGovSlackClient(client) {
 	if (!client?.slackApiUrl) return false;
 	try {
@@ -216,6 +165,13 @@ function isGovSlackClient(client) {
 		return false;
 	}
 }
+//#endregion
+//#region extensions/slack/src/monitor/media.ts
+var media_exports = /* @__PURE__ */ __exportAll({
+	SLACK_MEDIA_READ_IDLE_TIMEOUT_MS: () => SLACK_MEDIA_READ_IDLE_TIMEOUT_MS,
+	resolveSlackAttachmentContent: () => resolveSlackAttachmentContent,
+	resolveSlackMedia: () => resolveSlackMedia
+});
 function isSlackHostname(hostname, govSlack) {
 	const normalized = normalizeHostname(hostname);
 	if (!normalized) return false;
@@ -345,10 +301,18 @@ async function looksLikeHtmlFile(filePath) {
 }
 const MAX_SLACK_MEDIA_CONCURRENCY = 3;
 const MAX_SLACK_FORWARDED_ATTACHMENTS = 8;
+const SLACK_MEDIA_LIMIT_REASON = `omitted: 8-file limit`;
+function formatSlackMediaFailure(error) {
+	return redactToolPayloadText(formatErrorMessage(error)).replace(/\s+/g, " ").slice(0, 200);
+}
 async function fetchFreshSlackFileUrl(params) {
 	if (!params.file.id || !params.client) return null;
 	try {
 		const freshFile = (await params.client.files.info({ file: params.file.id })).file;
+		if (freshFile && params.isRefreshedFileAllowed?.(freshFile) === false) {
+			logVerbose$1(`slack: refreshed file metadata rejected for file id=${params.file.id}`);
+			return null;
+		}
 		const freshUrl = freshFile?.url_private_download ?? freshFile?.url_private;
 		if (freshUrl) {
 			logVerbose$1(`slack: refreshed file URL via files.info for file id=${params.file.id}`);
@@ -382,7 +346,7 @@ async function downloadSlackMediaFile(params) {
 	if (!(fileMime === "text/html" || fileName.endsWith(".html") || fileName.endsWith(".htm"))) {
 		if (normalizeOptionalLowercaseString(saved.contentType?.split(";")[0]) === "text/html" || await looksLikeHtmlFile(saved.path)) {
 			await fs.rm(saved.path, { force: true }).catch(() => void 0);
-			return null;
+			throw new Error("blocked: unexpected HTML content");
 		}
 	}
 	const effectiveMime = resolveSlackMediaMimetype(params.file, saved.contentType);
@@ -391,6 +355,7 @@ async function downloadSlackMediaFile(params) {
 	return {
 		path: saved.path,
 		...contentType ? { contentType } : {},
+		...label ? { fileName: label } : {},
 		placeholder: `[Slack file: ${formatSlackFileReference({
 			...params.file,
 			name: label
@@ -418,57 +383,81 @@ function resolveForwardedAttachmentImageUrl(attachment, govSlack) {
 async function resolveSlackMedia(params) {
 	const govSlack = isGovSlackClient(params.client);
 	const files = params.files ?? [];
-	const resolved = await pMap(files.length > 8 ? files.slice(0, 8) : files, async (file) => {
-		const preloaded = params.preloadedMedia?.get(file);
-		if (preloaded) return preloaded;
-		const eventUrl = file.url_private_download ?? file.url_private;
-		const url = eventUrl ?? await fetchFreshSlackFileUrl({
-			file,
-			client: params.client
-		});
-		if (!url) return pMapSkip;
-		const result = await downloadSlackMediaFile({
-			file,
-			url,
-			token: params.token,
-			maxBytes: params.maxBytes,
-			readIdleTimeoutMs: params.readIdleTimeoutMs,
-			totalTimeoutMs: params.totalTimeoutMs,
-			abortSignal: params.abortSignal,
-			govSlack
-		}).catch(() => null);
-		if (result || !eventUrl) return result ?? pMapSkip;
-		const freshUrl = await fetchFreshSlackFileUrl({
-			file,
-			client: params.client
-		});
-		if (!freshUrl) return pMapSkip;
-		return await downloadSlackMediaFile({
-			file,
-			url: freshUrl,
-			token: params.token,
-			maxBytes: params.maxBytes,
-			readIdleTimeoutMs: params.readIdleTimeoutMs,
-			totalTimeoutMs: params.totalTimeoutMs,
-			abortSignal: params.abortSignal,
-			govSlack
-		}).catch(() => null) ?? pMapSkip;
-	}, {
-		concurrency: MAX_SLACK_MEDIA_CONCURRENCY,
-		stopOnError: true
+	const limitedFiles = files.length > 8 ? files.slice(0, 8) : files;
+	for (const file of files.slice(8)) params.unavailableFiles?.set(file, SLACK_MEDIA_LIMIT_REASON);
+	const refreshFileUrl = (file) => fetchFreshSlackFileUrl({
+		file,
+		client: params.client,
+		isRefreshedFileAllowed: params.isRefreshedFileAllowed
+	});
+	const { results } = await runTasksWithConcurrency({
+		tasks: limitedFiles.map((file) => async () => {
+			const preloaded = params.preloadedMedia?.get(file);
+			if (preloaded) return preloaded;
+			const eventUrl = file.url_private_download ?? file.url_private;
+			let url = eventUrl ?? await refreshFileUrl(file);
+			let reason = "no private download URL";
+			for (let attempt = 0; url && attempt < 2; attempt += 1) {
+				try {
+					return await downloadSlackMediaFile({
+						...params,
+						file,
+						url,
+						govSlack
+					});
+				} catch (error) {
+					reason = formatSlackMediaFailure(error);
+				}
+				url = attempt === 0 && eventUrl ? await refreshFileUrl(file) : null;
+			}
+			params.unavailableFiles?.set(file, reason);
+			slackMediaLog.warn(`slack: file ${formatSlackFileReference(file)} unavailable (${reason})`);
+			return null;
+		}),
+		limit: MAX_SLACK_MEDIA_CONCURRENCY,
+		errorMode: "stop",
+		throwOnError: true
 	});
+	const resolved = results.filter((result) => result !== null);
 	return resolved.length > 0 ? resolved : null;
 }
 /** Extracts text and media from forwarded-message attachments. Returns null when empty. */
 async function resolveSlackAttachmentContent(params) {
-	const attachments = params.attachments;
-	if (!attachments || attachments.length === 0) return null;
-	const forwardedAttachments = attachments.filter((attachment) => isForwardedSlackAttachment(attachment)).slice(0, MAX_SLACK_FORWARDED_ATTACHMENTS);
-	if (forwardedAttachments.length === 0) return null;
+	const forwardedAttachments = (params.attachments ?? []).filter((attachment) => isForwardedSlackAttachment(attachment)).slice(0, MAX_SLACK_FORWARDED_ATTACHMENTS);
+	const candidates = [...params.files ?? [], ...forwardedAttachments.flatMap((attachment) => attachment.files ?? [])];
+	if (forwardedAttachments.length === 0 && candidates.length === 0) return null;
+	const fileIds = /* @__PURE__ */ new Set();
+	const allFiles = candidates.filter((file) => {
+		const fileId = normalizeOptionalString(file.id);
+		if (!fileId) return true;
+		if (fileIds.has(fileId)) return false;
+		fileIds.add(fileId);
+		return true;
+	}).map((file, index) => {
+		if (index >= 8) return file;
+		const fileId = normalizeOptionalString(file.id);
+		const preloaded = fileId && candidates.find((candidate) => normalizeOptionalString(candidate.id) === fileId && params.preloadedMedia?.has(candidate));
+		if (preloaded) return preloaded;
+		if (!fileId || file.url_private_download || file.url_private) return file;
+		const downloadable = candidates.find((candidate) => normalizeOptionalString(candidate.id) === fileId && (candidate.url_private_download || candidate.url_private));
+		return downloadable ? Object.assign({}, file, downloadable) : file;
+	});
+	const pendingFiles = new Map(allFiles.slice(0, 8).map((file) => [normalizeOptionalString(file.id) ?? file, file]));
+	const unavailableFileReasons = /* @__PURE__ */ new Map();
+	const resolveFiles = (files) => resolveSlackMedia({
+		...params,
+		unavailableFiles: unavailableFileReasons,
+		files: files?.flatMap((file) => {
+			const key = normalizeOptionalString(file.id) ?? file;
+			const selected = pendingFiles.get(key);
+			pendingFiles.delete(key);
+			return selected ? [selected] : [];
+		})
+	});
+	const directMediaPromise = resolveFiles(params.files);
 	const textBlocks = [];
-	const allMedia = [];
-	const allFiles = forwardedAttachments.flatMap((attachment) => attachment.files ?? []);
-	let unavailableImageCount = 0;
+	const attachmentMedia = [];
+	let unavailableMediaCount = 0;
 	const govSlack = isGovSlackClient(params.client);
 	for (const att of forwardedAttachments) {
 		const text = att.text?.trim() || att.fallback?.trim();
@@ -493,41 +482,60 @@ async function resolveSlackAttachmentContent(params) {
 				abortSignal: params.abortSignal
 			});
 			const label = saved.fileName ?? "forwarded image";
-			allMedia.push({
+			attachmentMedia.push({
 				path: saved.path,
 				contentType: saved.contentType,
+				...saved.fileName ? { fileName: saved.fileName } : {},
 				placeholder: `[Forwarded image: ${label}]`
 			});
-		} catch {
-			unavailableImageCount += 1;
-		}
-		if (att.files && att.files.length > 0) {
-			const fileMedia = await resolveSlackMedia({
-				files: att.files,
-				client: params.client,
-				token: params.token,
-				maxBytes: params.maxBytes,
-				readIdleTimeoutMs: params.readIdleTimeoutMs,
-				totalTimeoutMs: params.totalTimeoutMs,
-				abortSignal: params.abortSignal
-			});
-			if (fileMedia) allMedia.push(...fileMedia);
+		} catch (error) {
+			unavailableMediaCount += 1;
+			slackMediaLog.warn(`slack: forwarded image unavailable (${formatSlackMediaFailure(error)})`);
 		}
+		attachmentMedia.push(...await resolveFiles(att.files) ?? []);
 	}
+	const allMedia = [...await directMediaPromise ?? [], ...attachmentMedia];
+	const unavailableFiles = allFiles.flatMap((file, index) => {
+		const reason = index >= 8 ? SLACK_MEDIA_LIMIT_REASON : unavailableFileReasons.get(file);
+		return reason ? [{
+			...file,
+			reason
+		}] : [];
+	});
+	unavailableMediaCount += unavailableFiles.length;
 	const combinedText = textBlocks.join("\n\n");
-	if (!combinedText && allMedia.length === 0 && allFiles.length === 0 && unavailableImageCount === 0) return null;
+	if (!combinedText && allMedia.length === 0 && allFiles.length === 0 && unavailableMediaCount === 0) return null;
 	return {
 		text: combinedText,
 		media: allMedia,
-		unavailableImageCount,
-		...allFiles.length > 0 ? { files: allFiles } : {}
+		unavailableMediaCount,
+		...unavailableFiles.length > 0 ? { files: unavailableFiles } : {}
 	};
 }
 //#endregion
 //#region extensions/slack/src/actions.ts
+var actions_exports = /* @__PURE__ */ __exportAll({
+	deleteSlackMessage: () => deleteSlackMessage,
+	downloadSlackFile: () => downloadSlackFile,
+	editSlackMessage: () => editSlackMessage,
+	editSlackRenderedMessage: () => editSlackRenderedMessage,
+	getSlackMemberInfo: () => getSlackMemberInfo,
+	listSlackEmojis: () => listSlackEmojis,
+	listSlackPins: () => listSlackPins,
+	listSlackReactions: () => listSlackReactions,
+	openSlackConversation: () => openSlackConversation,
+	pinSlackMessage: () => pinSlackMessage,
+	reactSlackMessage: () => reactSlackMessage,
+	readSlackMessages: () => readSlackMessages,
+	removeOwnSlackReactions: () => removeOwnSlackReactions,
+	removeSlackReaction: () => removeSlackReaction,
+	resolveSlackConversationName: () => resolveSlackConversationName,
+	sendSlackMessage: () => sendSlackMessage,
+	unpinSlackMessage: () => unpinSlackMessage
+});
 function renderSlackReadMessageText(message) {
 	if (!hasSlackMessageTableBlock(message)) return message;
-	const text = resolveSlackMessageText$1(message, { preserveMessageTextWhitespace: true });
+	const text = resolveSlackMessageText(message, { preserveMessageTextWhitespace: true });
 	return text && text !== message.text ? {
 		...message,
 		text
@@ -691,6 +699,7 @@ async function listSlackReactions(channelId, messageId, opts = {}) {
 	})).message?.reactions ?? [];
 }
 async function sendSlackMessage(to, content, opts) {
+	const onDeliveryResult = Object.getOwnPropertyDescriptor(opts, SLACK_PRIVATE_ACTION_DELIVERY_RESULT)?.value;
 	return await sendMessageSlack(to, content, {
 		accountId: opts.accountId,
 		cfg: opts.cfg,
@@ -709,11 +718,17 @@ async function sendSlackMessage(to, content, opts) {
 		...Object.hasOwn(opts, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: opts.nativeDataFallbackBaseText } : {},
 		...opts.uploadFileName ? { uploadFileName: opts.uploadFileName } : {},
 		...opts.uploadTitle ? { uploadTitle: opts.uploadTitle } : {},
+		...typeof onDeliveryResult === "function" ? { onDeliveryResult } : {},
 		blocks: opts.blocks
 	});
 }
 async function editSlackMessage(channelId, messageId, content, opts = {}) {
-	await editSlackRenderedMessage(channelId, messageId, normalizeSlackOutboundText(content), opts);
+	const accountId = opts.accountId ?? (opts.cfg ? resolveDefaultSlackAccountId(opts.cfg) : void 0);
+	await editSlackRenderedMessage(channelId, messageId, normalizeSlackOutboundText(content, { tableMode: resolveMarkdownTableMode({
+		cfg: opts.cfg,
+		channel: "slack",
+		accountId
+	}) }), opts);
 }
 async function editSlackRenderedMessage(channelId, messageId, content, opts = {}) {
 	const client = await getClient(opts, "write");
@@ -758,6 +773,13 @@ async function deleteSlackMessage(channelId, messageId, opts = {}) {
 		ts: messageId
 	});
 }
+async function openSlackConversation(userIds, opts = {}) {
+	const input = parseSlackConversationOpenInput(userIds, opts.teamId);
+	return await openSlackConversationWithClient(await getClient({
+		...opts,
+		teamId: input.teamId
+	}, "write"), input);
+}
 async function resolveSlackConversationName(channelId, opts = {}) {
 	return (await (await getClient(opts, "read")).conversations.info({ channel: channelId })).channel?.name?.trim() || void 0;
 }
@@ -842,48 +864,34 @@ function collectSlackShareMaps(file) {
 	const shares = file.shares;
 	return [shares.public, shares.private].filter((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value));
 }
-function collectSlackSharedChannelIds(file) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const shareMap of collectSlackShareMaps(file)) for (const channelId of Object.keys(shareMap)) {
-		const normalized = normalizeOptionalString(channelId);
-		if (normalized) ids.add(normalized);
-	}
-	return ids;
-}
-function collectSlackThreadShares(file, channelId) {
-	const matches = [];
-	for (const shareMap of collectSlackShareMaps(file)) {
-		const rawEntries = shareMap[channelId];
-		if (!Array.isArray(rawEntries)) continue;
+function collectSlackShares(file) {
+	const shares = [];
+	for (const shareMap of collectSlackShareMaps(file)) for (const [rawChannelId, rawEntries] of Object.entries(shareMap)) {
+		const channelId = normalizeOptionalString(rawChannelId);
+		if (!channelId || !Array.isArray(rawEntries)) continue;
 		for (const rawEntry of rawEntries) {
 			if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) continue;
 			const entry = rawEntry;
 			const ts = typeof entry.ts === "string" ? normalizeOptionalString(entry.ts) : void 0;
 			const threadTs = typeof entry.thread_ts === "string" ? normalizeOptionalString(entry.thread_ts) : void 0;
-			matches.push({
+			if (ts || threadTs) shares.push({
 				channelId,
 				ts,
 				threadTs
 			});
 		}
 	}
-	return matches;
+	return shares;
 }
-function hasSlackScopeMismatch(params) {
+function lacksSlackScopeProof(params) {
 	const channelId = normalizeOptionalString(params.channelId);
-	if (!channelId) return false;
+	if (!channelId) return true;
 	const threadId = normalizeOptionalString(params.threadId);
 	const directIds = collectSlackDirectShareChannelIds(params.file);
-	const sharedIds = collectSlackSharedChannelIds(params.file);
-	const hasChannelEvidence = directIds.size > 0 || sharedIds.size > 0;
-	const inChannel = directIds.has(channelId) || sharedIds.has(channelId);
-	if (hasChannelEvidence && !inChannel) return true;
+	const shares = collectSlackShares(params.file);
+	if (!(directIds.has(channelId) || shares.some((entry) => entry.channelId === channelId))) return true;
 	if (!threadId) return false;
-	const threadShares = collectSlackThreadShares(params.file, channelId);
-	if (threadShares.length === 0) return false;
-	const threadEvidence = threadShares.filter((entry) => entry.threadTs || entry.ts);
-	if (threadEvidence.length === 0) return false;
-	return !threadEvidence.some((entry) => entry.threadTs === threadId || entry.ts === threadId);
+	return !shares.some((entry) => entry.channelId === channelId && (entry.threadTs === threadId || entry.ts === threadId));
 }
 /**
 * Downloads a Slack file by ID and saves it to the local media store.
@@ -893,13 +901,14 @@ function hasSlackScopeMismatch(params) {
 async function downloadSlackFile(fileId, opts) {
 	const token = resolveToken(opts.token, opts.accountId, opts.cfg);
 	const client = await getClient(opts);
-	const file = (await client.files.info({ file: fileId })).file;
-	if (!file?.url_private_download && !file?.url_private) return null;
-	if (hasSlackScopeMismatch({
+	const isFileAllowed = (file) => !lacksSlackScopeProof({
 		file,
 		channelId: opts.channelId,
 		threadId: opts.threadId
-	})) return null;
+	});
+	const file = (await client.files.info({ file: fileId })).file;
+	if (!file?.url_private_download && !file?.url_private) return null;
+	if (!isFileAllowed(file)) return null;
 	return (await resolveSlackMedia({
 		files: [{
 			id: file.id,
@@ -909,9 +918,10 @@ async function downloadSlackFile(fileId, opts) {
 			url_private_download: file.url_private_download
 		}],
 		client,
+		isRefreshedFileAllowed: isFileAllowed,
 		token,
 		maxBytes: opts.maxBytes
 	}))?.[0] ?? null;
 }
 //#endregion
-export { media_exports as _, getSlackMemberInfo as a, formatSlackFileReference as b, listSlackReactions as c, readSlackMessages as d, removeOwnSlackReactions as f, unpinSlackMessage as g, sendSlackMessage as h, editSlackRenderedMessage as i, pinSlackMessage as l, resolveSlackConversationName as m, downloadSlackFile as n, listSlackEmojis as o, removeSlackReaction as p, editSlackMessage as r, listSlackPins as s, deleteSlackMessage as t, reactSlackMessage as u, resolveSlackThreadHistory as v, buildSlackEditTextPayload as x, resolveSlackThreadStarter as y };
+export { hasSlackMessageTableBlock as C, resolveSlackMessageText as D, resolveSlackBlocksText as E, buildSlackEditTextPayload as O, formatSlackFileReferenceList as S, isSlackUnfurlAttachment as T, media_exports as _, editSlackRenderedMessage as a, saveRemoteMedia as b, listSlackPins as c, reactSlackMessage as d, readSlackMessages as f, unpinSlackMessage as g, sendSlackMessage as h, editSlackMessage as i, listSlackReactions as l, removeSlackReaction as m, deleteSlackMessage as n, getSlackMemberInfo as o, removeOwnSlackReactions as p, downloadSlackFile as r, listSlackEmojis as s, actions_exports as t, pinSlackMessage as u, logVerbose$1 as v, hasSlackTableBlock as w, formatSlackFileReference as x, isGovSlackClient as y };