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

package/dist/{actions-D3NuJvva.js → actions-DFk0ANVB.js}

@@ -1,22 +1,19 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as resolveSlackAccount, f as resolveSlackBotToken } from "./accounts-CHAeNZOX.js";
-import { $ as escapeSlackMrkdwn, C as hasSlackNativeDataBlock, D as stripSlackNativeDataBlocks, F as SLACK_EDIT_TEXT_MAX_BYTES, M as buildSlackCompleteBlocksFallbackText, U as truncateSlackTextByUtf8Bytes, V as countSlackTextUtf8Bytes, b as appendSlackNativeDataPlainTextFallback, it as validateSlackBlocksArray, j as buildSlackBlocksFallbackText, w as isSlackInvalidBlocksError, y as appendSlackNativeDataFallbackText } from "./group-policy-NQZti9t-.js";
-import { a as createSlackLookupClient, f as getSlackWriteClient } from "./probe-CgDsSops.js";
-import { a as resolveSlackMessageText$1, i as resolveSlackBlocksText, n as hasSlackTableBlock, r as isSlackUnfurlAttachment, t as hasSlackMessageTableBlock } from "./block-text-DkHaoGem.js";
-import { r as sendMessageSlack, u as buildSlackNativeDataDeliveryPlan } from "./send-DsLeZpST.js";
+import { a as resolveSlackAccount, f as resolveSlackBotToken } from "./accounts-BlzxuYle.js";
+import { B as SLACK_EDIT_TEXT_MAX_BYTES, F as normalizeSlackOutboundText, I as buildSlackBlocksFallbackText, L as buildSlackCompleteBlocksFallbackText, Lt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, M as stripSlackNativeDataBlocks, O as hasSlackNativeDataBlock, T as appendSlackNativeDataPlainTextFallback, Y as truncateSlackTextByUtf8Bytes, ct as escapeSlackMrkdwn, g as assertSlackDetachedTargetAllowed, k as isSlackInvalidBlocksError, mt as validateSlackBlocksArray, q as countSlackTextUtf8Bytes, w as appendSlackNativeDataFallbackText } from "./group-policy-DyfB_ZIE.js";
+import { d as getSlackWriteClient, i as createSlackLookupClient } from "./probe-BVA65leh.js";
+import { c as resolveSlackMessageText, i as hasSlackMessageTableBlock, n as fetchWithRuntimeDispatcher, r as saveRemoteMedia, t as isGovSlackClient } from "./slack-client-kind-BXyOOICI.js";
+import { m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-CtnOxKCc.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 { 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/edit-text.ts
 function buildSlackEditTextPayload(content, blocks) {
 	const trimmedContent = content.trim();
@@ -33,182 +30,38 @@ function buildSlackEditTextPayload(content, blocks) {
 //#region extensions/slack/src/file-reference.ts
 function formatSlackFileReference(file) {
 	const name = normalizeOptionalString(file?.name) ?? "file";
+	const mimetype = normalizeOptionalString(file?.mimetype);
+	const size = file?.size;
 	const fileId = normalizeOptionalString(file?.id);
-	return fileId ? `${name} (fileId: ${fileId})` : name;
+	const metadata = [
+		mimetype,
+		typeof size === "number" && Number.isSafeInteger(size) && size >= 0 ? `${size} bytes` : void 0,
+		fileId ? `fileId: ${fileId}` : void 0
+	].filter((value) => value !== void 0);
+	return metadata.length > 0 ? `${name} (${metadata.join(", ")})` : name;
 }
 function formatSlackFileReferenceList(files) {
 	if (!files?.length) return "file";
 	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 = params.workspaceScope ? JSON.stringify([
-		params.workspaceScope.accountId,
-		params.workspaceScope.teamId,
-		params.channelId,
-		params.threadTs
-	]) : `${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 [];
-	}
-}
-//#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
+	resolveSlackMedia: () => resolveSlackMedia
 });
-function isSlackHostname(hostname) {
+function isSlackHostname(hostname, govSlack) {
 	const normalized = normalizeHostname(hostname);
 	if (!normalized) return false;
+	if (govSlack) return normalized === "files.slack-gov.com";
 	return [
 		"slack.com",
 		"slack-edge.com",
 		"slack-files.com"
 	].some((suffix) => normalized === suffix || normalized.endsWith(`.${suffix}`));
 }
-function assertSlackFileUrl(rawUrl) {
+function assertSlackFileUrl(rawUrl, govSlack) {
 	let parsed;
 	try {
 		parsed = new URL(rawUrl);
@@ -216,15 +69,15 @@ function assertSlackFileUrl(rawUrl) {
 		throw new Error(`Invalid Slack file URL: ${rawUrl}`);
 	}
 	if (parsed.protocol !== "https:") throw new Error(`Refusing Slack file URL with non-HTTPS protocol: ${parsed.protocol}`);
-	if (!isSlackHostname(parsed.hostname)) throw new Error(`Refusing to send Slack token to non-Slack host "${parsed.hostname}" (url: ${rawUrl})`);
+	if (!isSlackHostname(parsed.hostname, govSlack)) throw new Error(`Refusing to send Slack token to non-Slack host "${parsed.hostname}" (url: ${rawUrl})`);
 	return parsed;
 }
 function createSlackAuthHeaders(token) {
 	return { Authorization: `Bearer ${token}` };
 }
-function createSlackMediaRequest(url, token) {
+function createSlackMediaRequest(url, token, govSlack) {
 	return {
-		url: assertSlackFileUrl(url).href,
+		url: assertSlackFileUrl(url, govSlack).href,
 		requestInit: { headers: createSlackAuthHeaders(token) }
 	};
 }
@@ -233,11 +86,11 @@ function isMockedFetch(fetchImpl) {
 	const candidate = fetchImpl;
 	return candidate.mock !== void 0 || candidate["_isMockFunction"] === true;
 }
-function createSlackMediaFetch() {
+function createSlackMediaFetch(govSlack) {
 	return async (input, init) => {
 		const url = resolveRequestUrl(input);
 		if (!url) throw new Error("Unsupported fetch input: expected string, URL, or Request");
-		const parsed = assertSlackFileUrl(url);
+		const parsed = assertSlackFileUrl(url, govSlack);
 		return ("dispatcher" in (init ?? {}) && !isMockedFetch(globalThis.fetch) ? fetchWithRuntimeDispatcher : globalThis.fetch)(parsed.href, {
 			...init,
 			redirect: "manual"
@@ -257,6 +110,10 @@ const SLACK_MEDIA_SSRF_POLICY = {
 	],
 	allowRfc2544BenchmarkRange: true
 };
+const SLACK_GOV_MEDIA_SSRF_POLICY = {
+	hostnameAllowlist: ["files.slack-gov.com"],
+	allowRfc2544BenchmarkRange: true
+};
 const SLACK_MEDIA_READ_IDLE_TIMEOUT_MS = 6e4;
 const SLACK_MEDIA_TOTAL_TIMEOUT_MS = 12e4;
 async function saveSlackMedia(params) {
@@ -340,16 +197,16 @@ async function fetchFreshSlackFileUrl(params) {
 	}
 }
 async function downloadSlackMediaFile(params) {
-	const { url: slackUrl, requestInit } = createSlackMediaRequest(params.url, params.token);
+	const { url: slackUrl, requestInit } = createSlackMediaRequest(params.url, params.token, params.govSlack);
 	const saved = await saveSlackMedia({
 		options: {
 			url: slackUrl,
-			fetchImpl: createSlackMediaFetch(),
+			fetchImpl: createSlackMediaFetch(params.govSlack),
 			requestInit,
 			filePathHint: params.file.name,
 			fallbackContentType: resolveSlackMediaMimetype(params.file, params.file.mimetype),
 			maxBytes: params.maxBytes,
-			ssrfPolicy: SLACK_MEDIA_SSRF_POLICY
+			ssrfPolicy: params.govSlack ? SLACK_GOV_MEDIA_SSRF_POLICY : SLACK_MEDIA_SSRF_POLICY
 		},
 		readIdleTimeoutMs: params.readIdleTimeoutMs,
 		totalTimeoutMs: params.totalTimeoutMs ?? SLACK_MEDIA_TOTAL_TIMEOUT_MS,
@@ -378,12 +235,12 @@ async function downloadSlackMediaFile(params) {
 function isForwardedSlackAttachment(attachment) {
 	return attachment.is_share === true;
 }
-function resolveForwardedAttachmentImageUrl(attachment) {
+function resolveForwardedAttachmentImageUrl(attachment, govSlack) {
 	const rawUrl = attachment.image_url?.trim();
 	if (!rawUrl) return null;
 	try {
 		const parsed = new URL(rawUrl);
-		if (parsed.protocol !== "https:" || !isSlackHostname(parsed.hostname)) return null;
+		if (parsed.protocol !== "https:" || !isSlackHostname(parsed.hostname, govSlack)) return null;
 		return parsed.toString();
 	} catch {
 		return null;
@@ -394,44 +251,50 @@ function resolveForwardedAttachmentImageUrl(attachment) {
 * Returns `null` when no files could be downloaded.
 */
 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
-		}).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
-		}).catch(() => null) ?? pMapSkip;
-	}, {
-		concurrency: MAX_SLACK_MEDIA_CONCURRENCY,
-		stopOnError: true
+	const { results } = await runTasksWithConcurrency({
+		tasks: (files.length > 8 ? files.slice(0, 8) : files).map((file) => async () => {
+			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 null;
+			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;
+			const freshUrl = await fetchFreshSlackFileUrl({
+				file,
+				client: params.client
+			});
+			if (!freshUrl) return null;
+			return await downloadSlackMediaFile({
+				file,
+				url: freshUrl,
+				token: params.token,
+				maxBytes: params.maxBytes,
+				readIdleTimeoutMs: params.readIdleTimeoutMs,
+				totalTimeoutMs: params.totalTimeoutMs,
+				abortSignal: params.abortSignal,
+				govSlack
+			}).catch(() => 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. */
@@ -442,6 +305,9 @@ async function resolveSlackAttachmentContent(params) {
 	if (forwardedAttachments.length === 0) return null;
 	const textBlocks = [];
 	const allMedia = [];
+	const allFiles = forwardedAttachments.flatMap((attachment) => attachment.files ?? []);
+	let unavailableImageCount = 0;
+	const govSlack = isGovSlackClient(params.client);
 	for (const att of forwardedAttachments) {
 		const text = att.text?.trim() || att.fallback?.trim();
 		if (text) {
@@ -449,16 +315,16 @@ async function resolveSlackAttachmentContent(params) {
 			const heading = author ? `[Forwarded message from ${author}]` : "[Forwarded message]";
 			textBlocks.push(`${heading}\n${text}`);
 		}
-		const imageUrl = resolveForwardedAttachmentImageUrl(att);
+		const imageUrl = resolveForwardedAttachmentImageUrl(att, govSlack);
 		if (imageUrl) try {
-			const { url: slackUrl, requestInit } = createSlackMediaRequest(imageUrl, params.token);
+			const { url: slackUrl, requestInit } = createSlackMediaRequest(imageUrl, params.token, govSlack);
 			const saved = await saveSlackMedia({
 				options: {
 					url: slackUrl,
-					fetchImpl: createSlackMediaFetch(),
+					fetchImpl: createSlackMediaFetch(govSlack),
 					requestInit,
 					maxBytes: params.maxBytes,
-					ssrfPolicy: SLACK_MEDIA_SSRF_POLICY
+					ssrfPolicy: govSlack ? SLACK_GOV_MEDIA_SSRF_POLICY : SLACK_MEDIA_SSRF_POLICY
 				},
 				readIdleTimeoutMs: params.readIdleTimeoutMs,
 				totalTimeoutMs: params.totalTimeoutMs ?? SLACK_MEDIA_TOTAL_TIMEOUT_MS,
@@ -470,7 +336,9 @@ async function resolveSlackAttachmentContent(params) {
 				contentType: saved.contentType,
 				placeholder: `[Forwarded image: ${label}]`
 			});
-		} catch {}
+		} catch {
+			unavailableImageCount += 1;
+		}
 		if (att.files && att.files.length > 0) {
 			const fileMedia = await resolveSlackMedia({
 				files: att.files,
@@ -485,17 +353,19 @@ async function resolveSlackAttachmentContent(params) {
 		}
 	}
 	const combinedText = textBlocks.join("\n\n");
-	if (!combinedText && allMedia.length === 0) return null;
+	if (!combinedText && allMedia.length === 0 && allFiles.length === 0 && unavailableImageCount === 0) return null;
 	return {
 		text: combinedText,
-		media: allMedia
+		media: allMedia,
+		unavailableImageCount,
+		...allFiles.length > 0 ? { files: allFiles } : {}
 	};
 }
 //#endregion
 //#region extensions/slack/src/actions.ts
 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
@@ -595,8 +465,13 @@ function hasSlackPlatformError(err, code) {
 }
 async function getClient(opts = {}, mode = "read") {
 	if (opts.client) return opts.client;
+	assertSlackDetachedTargetAllowed(opts.cfg ? resolveSlackAccount({
+		cfg: requireRuntimeConfig(opts.cfg, "Slack actions"),
+		accountId: opts.accountId
+	}).accountId : normalizeAccountId(opts.accountId), opts.teamId);
 	const token = resolveToken(opts.token, opts.accountId, opts.cfg);
-	return mode === "write" ? getSlackWriteClient(token) : createSlackLookupClient(token);
+	if (mode === "write") return getSlackWriteClient(token, { teamId: opts.teamId });
+	return createSlackLookupClient(token, { teamId: opts.teamId });
 }
 async function resolveBotUserId(client) {
 	const auth = await client.auth.test();
@@ -654,11 +529,13 @@ 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,
 		token: opts.token,
 		mediaUrl: opts.mediaUrl,
+		...opts.forceDocument ? { forceDocument: true } : {},
 		mediaAccess: opts.mediaAccess,
 		mediaLocalRoots: opts.mediaLocalRoots,
 		mediaReadFile: opts.mediaReadFile,
@@ -671,10 +548,14 @@ 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);
+}
+async function editSlackRenderedMessage(channelId, messageId, content, opts = {}) {
 	const client = await getClient(opts, "write");
 	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
 	const editText = buildSlackEditTextPayload(content, blocks);
@@ -726,18 +607,20 @@ async function readSlackMessages(channelId, opts = {}) {
 	const exactBounds = exactMessageId ? {
 		inclusive: true,
 		latest: exactMessageId,
-		oldest: void 0
+		oldest: exactMessageId
 	} : {
 		latest: normalizeSlackReadTimestamp(opts.before, "before"),
 		oldest: normalizeSlackReadTimestamp(opts.after, "after")
 	};
 	const client = await getClient(opts);
 	if (opts.threadId) {
+		const oldest = exactMessageId ? exactMessageId : exactBounds.oldest && Number(exactBounds.oldest) > Number(opts.threadId) ? exactBounds.oldest : opts.threadId;
 		const result = await client.conversations.replies({
 			channel: channelId,
 			ts: opts.threadId,
 			limit: readLimit,
-			...exactBounds
+			...exactBounds,
+			oldest
 		});
 		return {
 			messages: (result.messages ?? []).filter((message) => {
@@ -778,10 +661,6 @@ async function unpinSlackMessage(channelId, messageId, opts = {}) {
 async function listSlackPins(channelId, opts = {}) {
 	return (await (await getClient(opts)).pins.list({ channel: channelId })).items ?? [];
 }
-function normalizeSlackScopeValue(value) {
-	const trimmed = value?.trim();
-	return trimmed ? trimmed : void 0;
-}
 function collectSlackDirectShareChannelIds(file) {
 	const ids = /* @__PURE__ */ new Set();
 	for (const group of [
@@ -792,7 +671,7 @@ function collectSlackDirectShareChannelIds(file) {
 		if (!Array.isArray(group)) continue;
 		for (const entry of group) {
 			if (typeof entry !== "string") continue;
-			const normalized = normalizeSlackScopeValue(entry);
+			const normalized = normalizeOptionalString(entry);
 			if (normalized) ids.add(normalized);
 		}
 	}
@@ -806,7 +685,7 @@ function collectSlackShareMaps(file) {
 function collectSlackSharedChannelIds(file) {
 	const ids = /* @__PURE__ */ new Set();
 	for (const shareMap of collectSlackShareMaps(file)) for (const channelId of Object.keys(shareMap)) {
-		const normalized = normalizeSlackScopeValue(channelId);
+		const normalized = normalizeOptionalString(channelId);
 		if (normalized) ids.add(normalized);
 	}
 	return ids;
@@ -819,8 +698,8 @@ function collectSlackThreadShares(file, channelId) {
 		for (const rawEntry of rawEntries) {
 			if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) continue;
 			const entry = rawEntry;
-			const ts = typeof entry.ts === "string" ? normalizeSlackScopeValue(entry.ts) : void 0;
-			const threadTs = typeof entry.thread_ts === "string" ? normalizeSlackScopeValue(entry.thread_ts) : void 0;
+			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({
 				channelId,
 				ts,
@@ -831,9 +710,9 @@ function collectSlackThreadShares(file, channelId) {
 	return matches;
 }
 function hasSlackScopeMismatch(params) {
-	const channelId = normalizeSlackScopeValue(params.channelId);
+	const channelId = normalizeOptionalString(params.channelId);
 	if (!channelId) return false;
-	const threadId = normalizeSlackScopeValue(params.threadId);
+	const threadId = normalizeOptionalString(params.threadId);
 	const directIds = collectSlackDirectShareChannelIds(params.file);
 	const sharedIds = collectSlackSharedChannelIds(params.file);
 	const hasChannelEvidence = directIds.size > 0 || sharedIds.size > 0;
@@ -853,7 +732,8 @@ function hasSlackScopeMismatch(params) {
 */
 async function downloadSlackFile(fileId, opts) {
 	const token = resolveToken(opts.token, opts.accountId, opts.cfg);
-	const file = (await (await getClient(opts)).files.info({ file: fileId })).file;
+	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({
 		file,
@@ -868,9 +748,10 @@ async function downloadSlackFile(fileId, opts) {
 			url_private: file.url_private,
 			url_private_download: file.url_private_download
 		}],
+		client,
 		token,
 		maxBytes: opts.maxBytes
 	}))?.[0] ?? null;
 }
 //#endregion
-export { resolveSlackThreadHistory as _, listSlackEmojis as a, buildSlackEditTextPayload as b, pinSlackMessage as c, removeOwnSlackReactions as d, removeSlackReaction as f, media_exports as g, unpinSlackMessage as h, getSlackMemberInfo as i, reactSlackMessage as l, sendSlackMessage as m, downloadSlackFile as n, listSlackPins as o, resolveSlackConversationName as p, editSlackMessage as r, listSlackReactions as s, deleteSlackMessage as t, readSlackMessages as u, resolveSlackThreadStarter as v, formatSlackFileReference as y };
+export { media_exports as _, getSlackMemberInfo as a, formatSlackFileReferenceList 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, logVerbose$1 as v, buildSlackEditTextPayload as x, formatSlackFileReference as y };

package/dist/actions.runtime-CYLsYRai.js

@@ -0,0 +1,2 @@
+import { a as getSlackMemberInfo, c as listSlackReactions, d as readSlackMessages, f as removeOwnSlackReactions, g as unpinSlackMessage, h as sendSlackMessage, l as pinSlackMessage, m as resolveSlackConversationName, n as downloadSlackFile, o as listSlackEmojis, p as removeSlackReaction, r as editSlackMessage, s as listSlackPins, t as deleteSlackMessage, u as reactSlackMessage } from "./actions-DFk0ANVB.js";
+export { deleteSlackMessage, downloadSlackFile, editSlackMessage, getSlackMemberInfo, listSlackEmojis, listSlackPins, listSlackReactions, pinSlackMessage, reactSlackMessage, readSlackMessages, removeOwnSlackReactions, removeSlackReaction, resolveSlackConversationName, sendSlackMessage, unpinSlackMessage };

package/dist/api.js

@@ -1,18 +1,18 @@
 import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath, t as handleSlackHttpRequest } from "./registry-bbjH7IHX.js";
-import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, r as mergeSlackAccountConfig, t as listEnabledSlackAccounts } from "./accounts-CHAeNZOX.js";
-import { t as resolveSlackReplyToMode } from "./account-reply-mode-DrUXogvO.js";
-import { t as inspectSlackAccount } from "./account-inspect-DEKpg9Ip.js";
-import { a as resolveSlackChannelId, i as parseSlackTarget, n as looksLikeSlackTargetId, r as normalizeSlackMessagingTarget } from "./target-parsing-N6lHogYZ.js";
-import "./targets-KmjP2E8s.js";
-import { n as buildSlackThreadingToolContext, r as resolveSlackAutoThreadId, t as slackPlugin } from "./channel-B9fVdW3s.js";
-import { R as buildSlackInteractiveBlocks, a as allowListMatches, c as normalizeSlackAllowOwnerEntry, d as resolveSlackUserAllowed, it as validateSlackBlocksArray, l as normalizeSlackSlug, n as resolveSlackGroupRequireMention, nt as SLACK_MAX_BLOCKS, o as normalizeAllowList, r as resolveSlackGroupToolPolicy, rt as parseSlackBlocksInput, s as normalizeAllowListLower, u as resolveSlackAllowListMatch, z as buildSlackPresentationBlocks } from "./group-policy-NQZti9t-.js";
-import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-DkhFpMoy.js";
-import { _ as resolveSlackWriteClientOptions, c as createSlackTokenCacheKey, f as getSlackWriteClient, g as resolveSlackWebClientOptions, i as clearSlackWriteClientCacheForTest, l as createSlackWebClient, m as SLACK_WRITE_RETRY_OPTIONS, p as SLACK_DEFAULT_RETRY_OPTIONS, t as probeSlack, u as createSlackWriteClient } from "./probe-CgDsSops.js";
-import { n as resetSlackChannelTypeCacheForTest, r as resolveSlackChannelType } from "./channel-type-DXyos1d2.js";
-import { t as slackSetupPlugin } from "./channel.setup-CLP5oTvh.js";
-import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, n as downloadSlackFile, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-D3NuJvva.js";
-import { l as recordSlackThreadParticipation, o as clearSlackThreadParticipationCache, s as hasSlackThreadParticipation } from "./send-DsLeZpST.js";
-import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-CnCIAktf.js";
-import { t as collectSlackSecurityAuditFindings } from "./security-audit-DR097212.js";
-import { n as resolveSlackRuntimeGroupPolicy } from "./provider-DmRizMZt.js";
-export { SLACK_DEFAULT_RETRY_OPTIONS, SLACK_MAX_BLOCKS, SLACK_WRITE_RETRY_OPTIONS, resetSlackChannelTypeCacheForTest as __resetSlackChannelTypeCacheForTest, resetSlackChannelTypeCacheForTest, allowListMatches, buildSlackInteractiveBlocks, buildSlackPresentationBlocks, buildSlackThreadingToolContext, clearSlackThreadParticipationCache, clearSlackWriteClientCacheForTest, collectSlackSecurityAuditFindings, createSlackTokenCacheKey, createSlackWebClient, createSlackWriteClient, deleteSlackMessage, downloadSlackFile, editSlackMessage, extractSlackToolSend, getSlackMemberInfo, getSlackWriteClient, handleSlackHttpRequest, hasSlackThreadParticipation, inspectSlackAccount, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listSlackEmojis, listSlackMessageActions, listSlackPins, listSlackReactions, looksLikeSlackTargetId, mergeSlackAccountConfig, normalizeAllowList, normalizeAllowListLower, normalizeSlackAllowOwnerEntry, normalizeSlackMessagingTarget, normalizeSlackSlug, normalizeSlackWebhookPath, parseSlackBlocksInput, parseSlackTarget, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, recordSlackThreadParticipation, registerSlackHttpHandler, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAllowListMatch, resolveSlackAutoThreadId, resolveSlackChannelId, resolveSlackChannelType, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackReplyToMode, resolveSlackRuntimeGroupPolicy, resolveSlackUserAllowed, resolveSlackWebClientOptions, resolveSlackWriteClientOptions, sendSlackMessage, slackPlugin, slackSetupPlugin, unpinSlackMessage, validateSlackBlocksArray };
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, r as mergeSlackAccountConfig, t as listEnabledSlackAccounts } from "./accounts-BlzxuYle.js";
+import { r as resolveSlackReplyToMode } from "./conversation-binding-route-DFVLUdYF.js";
+import { t as inspectSlackAccount } from "./account-inspect-YJvFBbCR.js";
+import { a as parseSlackTarget, i as normalizeSlackMessagingTarget, o as resolveSlackChannelId, r as looksLikeSlackTargetId } from "./target-parsing-BnMD2ZqZ.js";
+import "./targets-Cx5W_n3W.js";
+import { G as buildSlackPresentationBlocks, Rt as resolveSlackAutoThreadId, W as buildSlackInteractiveBlocks, c as allowListMatches, d as normalizeSlackAllowOwnerEntry, f as normalizeSlackSlug, ft as SLACK_MAX_BLOCKS, h as resolveSlackUserAllowed, i as resolveSlackGroupToolPolicy, l as normalizeAllowList, mt as validateSlackBlocksArray, p as resolveSlackAllowListMatch, pt as parseSlackBlocksInput, r as resolveSlackGroupRequireMention, u as normalizeAllowListLower } from "./group-policy-DyfB_ZIE.js";
+import { n as buildSlackThreadingToolContext, t as slackPlugin } from "./channel-CA5w7qDF.js";
+import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-CqMr5Rmc.js";
+import { _ as resolveSlackWriteClientOptions, c as createSlackWebClient, d as getSlackWriteClient, f as SLACK_DEFAULT_RETRY_OPTIONS, g as resolveSlackWebClientOptions, l as createSlackWriteClient, p as SLACK_WRITE_RETRY_OPTIONS, s as createSlackTokenCacheKey, t as probeSlack } from "./probe-BVA65leh.js";
+import { n as resolveSlackChannelType } from "./channel-type-CZWv55Wu.js";
+import { t as slackSetupPlugin } from "./channel.setup-CpyYsEXH.js";
+import { a as getSlackMemberInfo, c as listSlackReactions, d as readSlackMessages, f as removeOwnSlackReactions, g as unpinSlackMessage, h as sendSlackMessage, l as pinSlackMessage, n as downloadSlackFile, o as listSlackEmojis, p as removeSlackReaction, r as editSlackMessage, s as listSlackPins, t as deleteSlackMessage, u as reactSlackMessage } from "./actions-DFk0ANVB.js";
+import { f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, s as clearSlackThreadParticipationCache } from "./send-CtnOxKCc.js";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-BGYyuzWh.js";
+import { t as collectSlackSecurityAuditFindings } from "./security-audit-B_yKr7MW.js";
+import { n as resolveSlackRuntimeGroupPolicy } from "./provider-CUUiwsg2.js";
+export { SLACK_DEFAULT_RETRY_OPTIONS, SLACK_MAX_BLOCKS, SLACK_WRITE_RETRY_OPTIONS, allowListMatches, buildSlackInteractiveBlocks, buildSlackPresentationBlocks, buildSlackThreadingToolContext, clearSlackThreadParticipationCache, collectSlackSecurityAuditFindings, createSlackTokenCacheKey, createSlackWebClient, createSlackWriteClient, deleteSlackMessage, downloadSlackFile, editSlackMessage, extractSlackToolSend, getSlackMemberInfo, getSlackWriteClient, handleSlackHttpRequest, hasSlackThreadParticipation, inspectSlackAccount, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listSlackEmojis, listSlackMessageActions, listSlackPins, listSlackReactions, looksLikeSlackTargetId, mergeSlackAccountConfig, normalizeAllowList, normalizeAllowListLower, normalizeSlackAllowOwnerEntry, normalizeSlackMessagingTarget, normalizeSlackSlug, normalizeSlackWebhookPath, parseSlackBlocksInput, parseSlackTarget, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, recordSlackThreadParticipation, registerSlackHttpHandler, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAllowListMatch, resolveSlackAutoThreadId, resolveSlackChannelId, resolveSlackChannelType, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackReplyToMode, resolveSlackRuntimeGroupPolicy, resolveSlackUserAllowed, resolveSlackWebClientOptions, resolveSlackWriteClientOptions, sendSlackMessage, slackPlugin, slackSetupPlugin, unpinSlackMessage, validateSlackBlocksArray };