@openclaw/slack 2026.9.6 → 2026.9.7

package/dist/.setup/{account-inspect-DP1Bcwj4.mjs → account-inspect-DWBXpER6.mjs}

@@ -1,5 +1,5 @@
 import { t as hasSlackAccountCredentials } from "./account-configured-sUohAxZr.mjs";
-import { a as resolveDefaultSlackAccountId, i as mergeSlackAccountConfig } from "./accounts-BBHvg0pY.mjs";
+import { a as mergeSlackAccountConfig, o as resolveDefaultSlackAccountId } from "./accounts-D_N9IqNA.mjs";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { hasConfiguredSecretInput, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";

package/dist/.setup/{accounts-BBHvg0pY.mjs → accounts-D_N9IqNA.mjs}

@@ -1,9 +1,11 @@
+import { r as __exportAll } from "./streaming-compat-C5Wut626.mjs";
 import { t as hasSlackAccountCredentials } from "./account-configured-sUohAxZr.mjs";
 import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { mapAllowFromEntries, normalizeChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-helpers";
 import { resolveAccountEntry } from "openclaw/plugin-sdk/routing";
+import { normalizeChatType } from "openclaw/plugin-sdk/account-core";
 //#region extensions/slack/src/token.ts
 function formatSlackBotTokenIdentityWarning(params) {
 	const userId = params.auth.user_id?.trim();
@@ -31,7 +33,27 @@ function resolveSlackUserToken(raw, path = "channels.slack.userToken") {
 	});
 }
 //#endregion
+//#region extensions/slack/src/account-reply-mode.ts
+function resolveSlackReplyToMode(account, chatType) {
+	const normalized = normalizeChatType(chatType ?? void 0);
+	if (normalized && account.replyToModeByChatType?.[normalized] !== void 0) return account.replyToModeByChatType[normalized] ?? "off";
+	return account.replyToMode ?? "off";
+}
+//#endregion
 //#region extensions/slack/src/accounts.ts
+var accounts_exports = /* @__PURE__ */ __exportAll({
+	hasImplicitDefaultSlackAccount: () => hasImplicitDefaultSlackAccount,
+	listEnabledSlackAccounts: () => listEnabledSlackAccounts,
+	listSlackAccountIds: () => listSlackAccountIds,
+	mergeSlackAccountConfig: () => mergeSlackAccountConfig,
+	resolveDefaultSlackAccountId: () => resolveDefaultSlackAccountId,
+	resolveSlackAccount: () => resolveSlackAccount,
+	resolveSlackAccountAllowFrom: () => resolveSlackAccountAllowFrom,
+	resolveSlackAccountDmPolicy: () => resolveSlackAccountDmPolicy,
+	resolveSlackConfigAccessorAccount: () => resolveSlackConfigAccessorAccount,
+	resolveSlackOperationToken: () => resolveSlackOperationToken,
+	resolveSlackReplyToMode: () => resolveSlackReplyToMode
+});
 function resolveSlackOperationToken(account, operation) {
 	if (account.identity === "user") return normalizeOptionalString(account.userToken);
 	const userToken = normalizeOptionalString(account.userToken);
@@ -185,4 +207,4 @@ function listEnabledSlackAccounts(cfg) {
 	})).filter((account) => account.enabled);
 }
 //#endregion
-export { resolveDefaultSlackAccountId as a, resolveSlackAccountDmPolicy as c, formatSlackBotTokenIdentityWarning as d, resolveSlackAppToken as f, mergeSlackAccountConfig as i, resolveSlackConfigAccessorAccount as l, listEnabledSlackAccounts as n, resolveSlackAccount as o, resolveSlackBotToken as p, listSlackAccountIds as r, resolveSlackAccountAllowFrom as s, hasImplicitDefaultSlackAccount as t, resolveSlackOperationToken as u };
+export { mergeSlackAccountConfig as a, resolveSlackAccountAllowFrom as c, resolveSlackOperationToken as d, resolveSlackReplyToMode as f, resolveSlackBotToken as h, listSlackAccountIds as i, resolveSlackAccountDmPolicy as l, resolveSlackAppToken as m, hasImplicitDefaultSlackAccount as n, resolveDefaultSlackAccountId as o, formatSlackBotTokenIdentityWarning as p, listEnabledSlackAccounts as r, resolveSlackAccount as s, accounts_exports as t, resolveSlackConfigAccessorAccount as u };

package/dist/.setup/{action-runtime-B01d85zt.mjs → action-runtime-DfWvuiZd.mjs}

@@ -1,7 +1,7 @@
-import { Mt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, Nt as resolveSlackAutoThreadId, ct as parseSlackBlocksInput, f as assertSlackDetachedTargetAllowed, r as buildSlackChannelIdCandidates, v as hasSlackNativeDataBlock, xt as getSlackInstallationKind } from "./session-status-Cf7AvWOt.mjs";
-import { a as parseSlackTarget, n as formatSlackTarget, o as resolveSlackChannelId } from "./target-parsing-DEsPjngB.mjs";
-import { t as slackContextTargetsMatch } from "./targets-Cku2KCvg.mjs";
-import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-BApW53pI.mjs";
+import { a as parseSlackTarget, n as formatSlackTarget, o as resolveSlackChannelId } from "./target-parsing-FFE26kOV.mjs";
+import { t as slackContextTargetsMatch } from "./targets-C6LZQL1Q.mjs";
+import { Nt as getSlackInstallationKind, Ut as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, Wt as resolveSlackAutoThreadId, _t as parseSlackBlocksInput, f as assertSlackDetachedTargetAllowed, r as buildSlackChannelIdCandidates, v as hasSlackNativeDataBlock } from "./session-status-DscajIsd.mjs";
+import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-D-jfM174.mjs";
 import { t as mergeSlackSendResults } from "./send-results-eeOu_HYm.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -27,10 +27,10 @@ const pinActions = /* @__PURE__ */ new Set([
 	"listPins"
 ]);
 const SLACK_REACTION_RESULT_LIMIT = 100;
-const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions-DKCtBgCI.mjs").then((n) => n.t));
+const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions-Df0CzcDl.mjs").then((n) => n.t));
 const bindSlackAction = createLazyRuntimeMethodBinder(loadSlackActionsRuntime);
-const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts.runtime-DN-PPocC.mjs"));
-const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-Dxk8VJUb.mjs").then((n) => n.t));
+const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts-D_N9IqNA.mjs").then((n) => n.t));
+const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-ClOttrZ5.mjs").then((n) => n.t));
 const bindSlackChannelType = createLazyRuntimeMethodBinder(loadSlackChannelTypeRuntime);
 const slackActionRuntime = {
 	deleteSlackMessage: bindSlackAction((runtime) => runtime.deleteSlackMessage),
@@ -49,7 +49,7 @@ const slackActionRuntime = {
 	removeSlackReaction: bindSlackAction((runtime) => runtime.removeSlackReaction),
 	resolveSlackConversationName: bindSlackAction((runtime) => runtime.resolveSlackConversationName),
 	resolveSlackConversationInfo: bindSlackChannelType((runtime) => runtime.resolveSlackConversationInfo),
-	resolveSlackChannelType: async (params) => (await loadSlackChannelTypeRuntime()).resolveSlackChannelType(params),
+	resolveSlackChannelType: bindSlackChannelType((runtime) => runtime.resolveSlackChannelType),
 	sendSlackMessage: bindSlackAction((runtime) => runtime.sendSlackMessage),
 	unpinSlackMessage: bindSlackAction((runtime) => runtime.unpinSlackMessage)
 };
@@ -63,12 +63,6 @@ function resolveThreadTsFromContext(explicitThreadTs, targetChannel, context, op
 	if (isSingleUseReplyToMode(context?.replyToMode ?? "off") && !context?.hasRepliedRef) return;
 	return threadTs;
 }
-function readSlackBlocksParam(params) {
-	return slackActionRuntime.parseSlackBlocksInput(params.blocks);
-}
-function isImageContentType(value) {
-	return value?.trim().toLowerCase().startsWith("image/") === true;
-}
 function hasPotentialSlackNamedPolicy(params) {
 	if (params.allowNameMatching !== true) return false;
 	return Object.entries(params.channels ?? {}).some(([key, entry]) => {
@@ -345,6 +339,17 @@ async function handleSlackAction(params, cfg, context) {
 	if (messagingActions.has(action)) {
 		if (!isActionEnabled("messages")) throw new Error("Slack messages are disabled.");
 		const sentResults = [];
+		const buildSendOpts = (destination, forceDocument) => {
+			const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), destination, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
+			return {
+				...buildActionOpts("write"),
+				mediaAccess: context?.mediaAccess,
+				mediaLocalRoots: context?.mediaLocalRoots,
+				mediaReadFile: context?.mediaReadFile,
+				threadTs,
+				...forceDocument ? { forceDocument: true } : {}
+			};
+		};
 		const sendSlackMessage = async (target, content, options) => {
 			const replyReference = context?.hasRepliedRef && slackContextTargetsMatch(target, context) ? context.hasRepliedRef : void 0;
 			const result = await slackActionRuntime.sendSlackMessage(target, content, {
@@ -374,7 +379,7 @@ async function handleSlackAction(params, cfg, context) {
 				const destination = resolveSlackActionTarget(account, readStringParam(params, "to", { required: true }), context).routingTarget;
 				const content = readStringParam(params, "content", { allowEmpty: true });
 				const mediaUrl = readStringParam(params, "mediaUrl");
-				const blocks = readSlackBlocksParam(params);
+				const blocks = slackActionRuntime.parseSlackBlocksInput(params.blocks);
 				const replyBroadcast = readBooleanParam(params, "replyBroadcast");
 				const textIsSlackMrkdwn = readBooleanParam(params, "textIsSlackMrkdwn");
 				const textIsSlackPlainText = readBooleanParam(params, "textIsSlackPlainText");
@@ -385,15 +390,7 @@ async function handleSlackAction(params, cfg, context) {
 				const nativeDataFallbackBaseText = readStringParam(params, "nativeDataFallbackBaseText", { allowEmpty: true });
 				if (!content && !mediaUrl && !blocks && !preparedMessages?.length) throw new Error("Slack sendMessage requires content, blocks, or mediaUrl.");
 				if (replyBroadcast && mediaUrl) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
-				const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), destination, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
-				const baseSendOpts = {
-					...buildActionOpts("write"),
-					mediaAccess: context?.mediaAccess,
-					mediaLocalRoots: context?.mediaLocalRoots,
-					mediaReadFile: context?.mediaReadFile,
-					threadTs: threadTs ?? void 0,
-					...forceDocument ? { forceDocument: true } : {}
-				};
+				const baseSendOpts = buildSendOpts(destination, forceDocument);
 				const sendOpts = {
 					...baseSendOpts,
 					...replyBroadcast ? { replyBroadcast } : {},
@@ -451,15 +448,9 @@ async function handleSlackAction(params, cfg, context) {
 				const title = readStringParam(params, "title");
 				const forceDocument = readBooleanParam(params, "forceDocument") === true;
 				if (readBooleanParam(params, "replyBroadcast")) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
-				const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), destination, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
 				const result = await sendSlackMessage(destination, initialComment ?? "", {
-					...buildActionOpts("write"),
+					...buildSendOpts(destination, forceDocument),
 					mediaUrl: filePath,
-					mediaAccess: context?.mediaAccess,
-					mediaLocalRoots: context?.mediaLocalRoots,
-					mediaReadFile: context?.mediaReadFile,
-					threadTs: threadTs ?? void 0,
-					...forceDocument ? { forceDocument: true } : {},
 					...filename ? { uploadFileName: filename } : {},
 					...title ? { uploadTitle: title } : {}
 				});
@@ -473,7 +464,7 @@ async function handleSlackAction(params, cfg, context) {
 				const { channelId } = target;
 				const messageId = readStringParam(params, "messageId", { required: true });
 				const content = readStringParam(params, "content", { allowEmpty: true });
-				const blocks = readSlackBlocksParam(params);
+				const blocks = slackActionRuntime.parseSlackBlocksInput(params.blocks);
 				if (!content && !blocks) throw new Error("Slack editMessage requires content or blocks.");
 				await assertReadTargetAllowed(target);
 				const writeOpts = buildActionOpts("write", target.teamId);
@@ -541,7 +532,7 @@ async function handleSlackAction(params, cfg, context) {
 					ok: false,
 					error: "File could not be downloaded. Confirm the fileId came from the requested Slack channel or explicit thread and that the file is accessible and within the size limit."
 				});
-				if (!isImageContentType(downloaded.contentType)) return jsonResult({
+				if (!downloaded.contentType?.trim().toLowerCase().startsWith("image/")) return jsonResult({
 					ok: true,
 					fileId,
 					path: downloaded.path,
@@ -574,16 +565,10 @@ async function handleSlackAction(params, cfg, context) {
 		const { channelId } = target;
 		const readOpts = buildActionOpts("read", target.teamId);
 		const writeOpts = buildActionOpts("write", target.teamId);
-		if (action === "pinMessage") {
-			const messageId = readStringParam(params, "messageId", { required: true });
-			await assertReadTargetAllowed(target);
-			await slackActionRuntime.pinSlackMessage(channelId, messageId, writeOpts);
-			return jsonResult({ ok: true });
-		}
-		if (action === "unpinMessage") {
+		if (action === "pinMessage" || action === "unpinMessage") {
 			const messageId = readStringParam(params, "messageId", { required: true });
 			await assertReadTargetAllowed(target);
-			await slackActionRuntime.unpinSlackMessage(channelId, messageId, writeOpts);
+			await (action === "pinMessage" ? slackActionRuntime.pinSlackMessage : slackActionRuntime.unpinSlackMessage)(channelId, messageId, writeOpts);
 			return jsonResult({ ok: true });
 		}
 		await assertReadTargetAllowed(target);

package/dist/.setup/action-runtime.runtime-Ck4bAWOX.mjs

@@ -0,0 +1,2 @@
+import { t as handleSlackAction } from "./action-runtime-DfWvuiZd.mjs";
+export { handleSlackAction };

package/dist/.setup/{actions-DKCtBgCI.mjs → actions-Df0CzcDl.mjs}

@@ -1,12 +1,12 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as resolveDefaultSlackAccountId, o as resolveSlackAccount, p as resolveSlackBotToken } from "./accounts-BBHvg0pY.mjs";
-import { A as countSlackTextUtf8Bytes, C as buildSlackBlocksFallbackText, E as SLACK_EDIT_TEXT_MAX_BYTES, M as truncateSlackTextByUtf8Bytes, Mt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, S as stripSlackNativeDataBlocks, T as renderSlackBlockFallbackText, Y as normalizeSlackOutboundText, f as assertSlackDetachedTargetAllowed, h as appendSlackNativeDataPlainTextFallback, lt as validateSlackBlocksArray, m as appendSlackNativeDataFallbackText, ot as escapeSlackMrkdwn, v as hasSlackNativeDataBlock, w as buildSlackCompleteBlocksFallbackText, y as isSlackInvalidBlocksError } from "./session-status-Cf7AvWOt.mjs";
-import { n as formatSlackTarget } from "./target-parsing-DEsPjngB.mjs";
-import { g as getSlackWriteClient, l as createSlackLookupClient, m as createSlackWriteClient } from "./probe-DiYIMPJo.mjs";
-import { m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-Cp6omkOg.mjs";
+import { r as __exportAll } from "./streaming-compat-C5Wut626.mjs";
+import { h as resolveSlackBotToken, o as resolveDefaultSlackAccountId, s as resolveSlackAccount } from "./accounts-D_N9IqNA.mjs";
+import { n as formatSlackTarget } from "./target-parsing-FFE26kOV.mjs";
+import { A as countSlackTextUtf8Bytes, C as buildSlackBlocksFallbackText, E as SLACK_EDIT_TEXT_MAX_BYTES, M as truncateSlackTextByUtf8Bytes, Q as normalizeSlackOutboundText, S as stripSlackNativeDataBlocks, T as renderSlackBlockFallbackText, Ut as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, f as assertSlackDetachedTargetAllowed, h as appendSlackNativeDataPlainTextFallback, lt as escapeSlackMrkdwn, m as appendSlackNativeDataFallbackText, v as hasSlackNativeDataBlock, vt as validateSlackBlocksArray, w as buildSlackCompleteBlocksFallbackText, y as isSlackInvalidBlocksError } from "./session-status-DscajIsd.mjs";
+import { _ as getSlackWriteClient, h as createSlackWriteClient, u as createSlackLookupClient } from "./probe-B2Y9qc_z.mjs";
+import { p as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-BOVLQi3n.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createSubsystemLogger, logVerbose, logVerbose as logVerbose$1 } from "openclaw/plugin-sdk/runtime-env";
+import { asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readNonBlankString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createSubsystemLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { captureChannelReadAuthority as captureChannelReadAuthority$1 } from "openclaw/plugin-sdk/fetch-runtime";
 import { fetchWithRuntimeDispatcher as fetchWithRuntimeDispatcher$1 } from "openclaw/plugin-sdk/runtime-fetch";
@@ -57,11 +57,8 @@ function buildSlackEditTextPayload(content, blocks) {
 }
 //#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;
+	return blocks?.some((block) => asOptionalRecord(block)?.type === "table") ?? false;
 }
 function hasSlackMessageTableBlock(message) {
 	return hasSlackTableBlock(message.blocks) || message.attachments?.some((attachment) => !isSlackUnfurlAttachment(attachment) && hasSlackTableBlock(attachment.blocks)) === true;
@@ -75,7 +72,7 @@ function resolveSlackBlocksText(blocks) {
 	let hasRichText = false;
 	let hasNativeData = false;
 	for (const block of blocks) {
-		const blockType = readSlackBlockType(block);
+		const blockType = asOptionalRecord(block)?.type;
 		hasRichText ||= blockType === "rich_text";
 		hasNativeData ||= blockType === "data_visualization" || blockType === "data_table" || blockType === "table";
 		const text = renderSlackBlockFallbackText(block, {
@@ -103,7 +100,7 @@ function resolveSlackAttachmentTableTexts(attachments) {
 	for (const attachment of attachments ?? []) {
 		if (isSlackUnfurlAttachment(attachment)) continue;
 		for (const block of attachment.blocks ?? []) {
-			if (readSlackBlockType(block) !== "table") continue;
+			if (asOptionalRecord(block)?.type !== "table") continue;
 			const text = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
 			if (!text || seen.has(text)) continue;
 			seen.add(text);
@@ -115,7 +112,7 @@ function resolveSlackAttachmentTableTexts(attachments) {
 /** 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),
+		messageText: options.preserveMessageTextWhitespace ? readNonBlankString(message.text) : normalizeOptionalString(message.text),
 		blocksText: resolveSlackBlocksText(message.blocks)
 	});
 	for (const tableText of resolveSlackAttachmentTableTexts(message.attachments)) resolved = appendDistinctSlackText(resolved, tableText);
@@ -195,9 +192,6 @@ function assertSlackFileUrl(rawUrl, govSlack) {
 	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 captureSlackMediaReadGuard(params) {
 	const inherited = captureChannelReadAuthority$1();
 	const { assertCurrent, abortSignal } = params;
@@ -208,12 +202,6 @@ function captureSlackMediaReadGuard(params) {
 		assertCurrent?.();
 	};
 }
-function createSlackMediaRequest(url, token, govSlack) {
-	return {
-		url: assertSlackFileUrl(url, govSlack).href,
-		requestInit: { headers: createSlackAuthHeaders(token) }
-	};
-}
 function createSlackMediaFetch(govSlack, assertReadAuthority = captureChannelReadAuthority$1()) {
 	return async (input, init) => {
 		const url = resolveRequestUrl(input);
@@ -247,34 +235,41 @@ const SLACK_GOV_MEDIA_SSRF_POLICY = {
 const SLACK_MEDIA_READ_IDLE_TIMEOUT_MS = 6e4;
 const SLACK_MEDIA_TOTAL_TIMEOUT_MS = 12e4;
 async function saveSlackMedia(params) {
-	const timeoutAbortController = params.totalTimeoutMs ? new AbortController() : void 0;
-	const abortSignals = [
-		params.abortSignal,
-		params.options.requestInit?.signal ?? void 0,
-		timeoutAbortController?.signal
-	].filter((signal) => Boolean(signal));
+	const url = assertSlackFileUrl(params.url, params.govSlack).href;
+	const totalTimeoutMs = params.totalTimeoutMs ?? SLACK_MEDIA_TOTAL_TIMEOUT_MS;
+	const timeoutAbortController = totalTimeoutMs ? new AbortController() : void 0;
+	const abortSignals = [params.abortSignal, timeoutAbortController?.signal].filter((signal) => Boolean(signal));
 	const signal = abortSignals.length > 1 ? AbortSignal.any(abortSignals) : abortSignals[0];
 	let timedOut = false;
 	let timeoutHandle = null;
 	const savePromise = saveRemoteMedia({
-		...params.options,
-		readIdleTimeoutMs: params.readIdleTimeoutMs ?? 6e4,
-		...signal ? { requestInit: {
-			...params.options.requestInit,
-			signal
-		} } : {}
+		url,
+		fetchImpl: createSlackMediaFetch(params.govSlack, params.assertReadAuthority),
+		beforeRequest: params.assertReadAuthority,
+		assertCurrent: params.assertCurrent,
+		requestInit: {
+			headers: { Authorization: `Bearer ${params.token}` },
+			...signal ? { signal } : {}
+		},
+		...params.file ? {
+			filePathHint: params.file.name,
+			fallbackContentType: resolveSlackMediaMimetype(params.file)
+		} : {},
+		maxBytes: params.maxBytes,
+		ssrfPolicy: params.govSlack ? SLACK_GOV_MEDIA_SSRF_POLICY : SLACK_MEDIA_SSRF_POLICY,
+		readIdleTimeoutMs: params.readIdleTimeoutMs ?? 6e4
 	}).catch((error) => {
 		if (timedOut) return new Promise(() => {});
 		throw error;
 	});
 	try {
-		if (!params.totalTimeoutMs) return await savePromise;
+		if (!totalTimeoutMs) return await savePromise;
 		const timeoutPromise = new Promise((_, reject) => {
 			timeoutHandle = setTimeout(() => {
 				timedOut = true;
 				timeoutAbortController?.abort();
-				reject(/* @__PURE__ */ new Error(`slack media download timed out after ${params.totalTimeoutMs}ms`));
-			}, params.totalTimeoutMs);
+				reject(/* @__PURE__ */ new Error(`slack media download timed out after ${totalTimeoutMs}ms`));
+			}, totalTimeoutMs);
 			timeoutHandle.unref?.();
 		});
 		return await Promise.race([savePromise, timeoutPromise]);
@@ -323,41 +318,28 @@ async function fetchFreshSlackFileUrl(params) {
 		assertCurrent?.();
 		const freshFile = info.file;
 		if (freshFile && params.isRefreshedFileAllowed?.(freshFile) === false) {
-			logVerbose$1(`slack: refreshed file metadata rejected for file id=${params.file.id}`);
+			logVerbose(`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}`);
+			logVerbose(`slack: refreshed file URL via files.info for file id=${params.file.id}`);
 			return freshUrl;
 		}
-		logVerbose$1(`slack: files.info returned no private URL for file id=${params.file.id}`);
+		logVerbose(`slack: files.info returned no private URL for file id=${params.file.id}`);
 		return null;
 	} catch (error) {
 		assertCurrent?.();
-		logVerbose$1(`slack: files.info failed for file id=${params.file.id}: ${formatErrorMessage(error)}`);
+		logVerbose(`slack: files.info failed for file id=${params.file.id}: ${formatErrorMessage(error)}`);
 		return null;
 	}
 }
 async function downloadSlackMediaFile(params) {
 	const assertReadAuthority = captureSlackMediaReadGuard(params);
 	assertReadAuthority?.();
-	const { url: slackUrl, requestInit } = createSlackMediaRequest(params.url, params.token, params.govSlack);
 	const saved = await saveSlackMedia({
-		options: {
-			url: slackUrl,
-			fetchImpl: createSlackMediaFetch(params.govSlack, assertReadAuthority),
-			beforeRequest: assertReadAuthority,
-			assertCurrent: params.assertCurrent,
-			requestInit,
-			filePathHint: params.file.name,
-			fallbackContentType: resolveSlackMediaMimetype(params.file, params.file.mimetype),
-			maxBytes: params.maxBytes,
-			ssrfPolicy: params.govSlack ? SLACK_GOV_MEDIA_SSRF_POLICY : SLACK_MEDIA_SSRF_POLICY
-		},
-		readIdleTimeoutMs: params.readIdleTimeoutMs,
-		totalTimeoutMs: params.totalTimeoutMs ?? SLACK_MEDIA_TOTAL_TIMEOUT_MS,
-		abortSignal: params.abortSignal
+		...params,
+		assertReadAuthority
 	});
 	const fileMime = normalizeOptionalLowercaseString(params.file.mimetype);
 	const fileName = normalizeLowercaseStringOrEmpty(params.file.name);
@@ -367,9 +349,8 @@ async function downloadSlackMediaFile(params) {
 			throw new Error("blocked: unexpected HTML content");
 		}
 	}
-	const effectiveMime = resolveSlackMediaMimetype(params.file, saved.contentType);
+	const contentType = resolveSlackMediaMimetype(params.file, saved.contentType);
 	const label = saved.fileName ?? params.file.name;
-	const contentType = effectiveMime ?? saved.contentType;
 	return {
 		path: saved.path,
 		...contentType ? { contentType } : {},
@@ -380,16 +361,11 @@ async function downloadSlackMediaFile(params) {
 		})}]`
 	};
 }
-function isForwardedSlackAttachment(attachment) {
-	return attachment.is_share === true;
-}
 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, govSlack)) return null;
-		return parsed.toString();
+		return assertSlackFileUrl(rawUrl, govSlack).href;
 	} catch {
 		return null;
 	}
@@ -446,7 +422,7 @@ async function resolveSlackMedia(params) {
 }
 /** Extracts text and media from forwarded-message attachments. Returns null when empty. */
 async function resolveSlackAttachmentContent(params) {
-	const forwardedAttachments = (params.attachments ?? []).filter((attachment) => isForwardedSlackAttachment(attachment)).slice(0, MAX_SLACK_FORWARDED_ATTACHMENTS);
+	const forwardedAttachments = (params.attachments ?? []).filter((attachment) => attachment.is_share === true).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();
@@ -492,21 +468,12 @@ async function resolveSlackAttachmentContent(params) {
 				}
 				const imageUrl = resolveForwardedAttachmentImageUrl(att, govSlack);
 				if (imageUrl) try {
-					const { url: slackUrl, requestInit } = createSlackMediaRequest(imageUrl, params.token, govSlack);
 					const assertReadAuthority = captureSlackMediaReadGuard(params);
 					const saved = await saveSlackMedia({
-						options: {
-							url: slackUrl,
-							fetchImpl: createSlackMediaFetch(govSlack, assertReadAuthority),
-							beforeRequest: assertReadAuthority,
-							assertCurrent: params.assertCurrent,
-							requestInit,
-							maxBytes: params.maxBytes,
-							ssrfPolicy: govSlack ? SLACK_GOV_MEDIA_SSRF_POLICY : SLACK_MEDIA_SSRF_POLICY
-						},
-						readIdleTimeoutMs: params.readIdleTimeoutMs,
-						totalTimeoutMs: params.totalTimeoutMs ?? SLACK_MEDIA_TOTAL_TIMEOUT_MS,
-						abortSignal: params.abortSignal
+						...params,
+						url: imageUrl,
+						govSlack,
+						assertReadAuthority
 					});
 					const label = saved.fileName ?? "forwarded image";
 					attachmentMedia.push({
@@ -679,39 +646,29 @@ async function getClient(opts = {}, mode = "read") {
 		if (opts.assertDirectAdapterHandoff) return createSlackWriteClient(token, { teamId: opts.teamId }, opts.assertDirectAdapterHandoff);
 		return getSlackWriteClient(token, { teamId: opts.teamId });
 	}
-	return opts.assertDirectAdapterHandoff ? createSlackLookupClient(token, { teamId: opts.teamId }, opts.assertDirectAdapterHandoff) : createSlackLookupClient(token, { teamId: opts.teamId });
+	return createSlackLookupClient(token, { teamId: opts.teamId }, opts.assertDirectAdapterHandoff);
 }
 async function resolveBotUserId(client) {
 	const auth = await client.auth.test();
 	if (!auth?.user_id) throw new Error("Failed to resolve Slack bot user id");
 	return auth.user_id;
 }
-async function reactSlackMessage(channelId, messageId, emoji, opts = {}) {
-	const client = await getClient(opts, "write");
-	try {
-		await client.reactions.add({
-			channel: channelId,
-			timestamp: messageId,
-			name: normalizeSlackEmojiName(emoji)
-		});
-	} catch (err) {
-		if (hasSlackPlatformError(err, "already_reacted")) return;
-		throw err;
-	}
-}
-async function removeSlackReaction(channelId, messageId, emoji, opts = {}) {
-	const client = await getClient(opts, "write");
-	try {
-		await client.reactions.remove({
-			channel: channelId,
-			timestamp: messageId,
-			name: normalizeSlackEmojiName(emoji)
-		});
-	} catch (err) {
-		if (hasSlackPlatformError(err, "no_reaction")) return;
-		throw err;
-	}
+function createSlackReactionUpdater(method, unchangedError) {
+	return async (channelId, messageId, emoji, opts = {}) => {
+		const client = await getClient(opts, "write");
+		try {
+			await client.reactions[method]({
+				channel: channelId,
+				timestamp: messageId,
+				name: normalizeSlackEmojiName(emoji)
+			});
+		} catch (err) {
+			if (!hasSlackPlatformError(err, unchangedError)) throw err;
+		}
+	};
 }
+const reactSlackMessage = createSlackReactionUpdater("add", "already_reacted");
+const removeSlackReaction = createSlackReactionUpdater("remove", "no_reaction");
 async function removeOwnSlackReactions(channelId, messageId, opts = {}) {
 	const client = await getClient(opts, "write");
 	const userId = await resolveBotUserId(client);
@@ -783,7 +740,7 @@ async function editSlackRenderedMessage(channelId, messageId, content, opts = {}
 	try {
 		await client.chat.update(update);
 	} catch (error) {
-		if (!hasSlackNativeDataBlock(blocks) || !isSlackInvalidBlocksError(error)) throw error;
+		if (!hasNativeData || !isSlackInvalidBlocksError(error)) throw error;
 		logVerbose("slack edit: native data block rejected, retrying with text fallback");
 		const survivorBlocks = stripSlackNativeDataBlocks(blocks);
 		const survivorText = buildSlackBlocksFallbackText(survivorBlocks) ?? "";
@@ -834,30 +791,18 @@ async function readSlackMessages(channelId, opts = {}) {
 		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,
-			oldest
-		});
-		return {
-			messages: (result.messages ?? []).filter((message) => {
-				if (exactMessageId) return message.ts === exactMessageId;
-				return message.ts !== opts.threadId;
-			}).map(renderSlackReadMessageText),
-			hasMore: exactMessageId ? false : Boolean(result.has_more)
-		};
-	}
-	const result = await client.conversations.history({
+	const query = {
 		channel: channelId,
 		limit: readLimit,
 		...exactBounds
-	});
+	};
+	const result = opts.threadId ? await client.conversations.replies({
+		...query,
+		ts: opts.threadId,
+		oldest: exactMessageId ? exactMessageId : exactBounds.oldest && Number(exactBounds.oldest) > Number(opts.threadId) ? exactBounds.oldest : opts.threadId
+	}) : await client.conversations.history(query);
 	return {
-		messages: (result.messages ?? []).filter((message) => !exactMessageId || message.ts === exactMessageId).map(renderSlackReadMessageText),
+		messages: (result.messages ?? []).filter((message) => exactMessageId ? message.ts === exactMessageId : !opts.threadId || message.ts !== opts.threadId).map(renderSlackReadMessageText),
 		hasMore: exactMessageId ? false : Boolean(result.has_more)
 	};
 }
@@ -882,55 +827,23 @@ async function unpinSlackMessage(channelId, messageId, opts = {}) {
 async function listSlackPins(channelId, opts = {}) {
 	return (await (await getClient(opts)).pins.list({ channel: channelId })).items ?? [];
 }
-function collectSlackDirectShareChannelIds(file) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const group of [
+function hasSlackScopeProof(params) {
+	const channelId = normalizeOptionalString(params.channelId);
+	if (!channelId) return false;
+	const threadId = normalizeOptionalString(params.threadId);
+	const { file } = params;
+	if (!threadId && [
 		file.channels,
 		file.groups,
 		file.ims
-	]) {
-		if (!Array.isArray(group)) continue;
-		for (const entry of group) {
-			if (typeof entry !== "string") continue;
-			const normalized = normalizeOptionalString(entry);
-			if (normalized) ids.add(normalized);
-		}
-	}
-	return ids;
-}
-function collectSlackShareMaps(file) {
-	if (!file.shares || typeof file.shares !== "object" || Array.isArray(file.shares)) return [];
-	const shares = file.shares;
-	return [shares.public, shares.private].filter((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value));
-}
-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;
-			if (ts || threadTs) shares.push({
-				channelId,
-				ts,
-				threadTs
-			});
-		}
-	}
-	return shares;
-}
-function lacksSlackScopeProof(params) {
-	const channelId = normalizeOptionalString(params.channelId);
-	if (!channelId) return true;
-	const threadId = normalizeOptionalString(params.threadId);
-	const directIds = collectSlackDirectShareChannelIds(params.file);
-	const shares = collectSlackShares(params.file);
-	if (!(directIds.has(channelId) || shares.some((entry) => entry.channelId === channelId))) return true;
-	if (!threadId) return false;
-	return !shares.some((entry) => entry.channelId === channelId && (entry.threadTs === threadId || entry.ts === threadId));
+	].some((group) => Array.isArray(group) && group.some((entry) => normalizeOptionalString(entry) === channelId))) return true;
+	if (!isRecord(file.shares)) return false;
+	return [file.shares.public, file.shares.private].some((shareMap) => isRecord(shareMap) && Object.entries(shareMap).some(([sharedChannelId, entries]) => normalizeOptionalString(sharedChannelId) === channelId && Array.isArray(entries) && entries.some((entry) => {
+		if (!isRecord(entry)) return false;
+		const ts = normalizeOptionalString(entry.ts);
+		const threadTs = normalizeOptionalString(entry.thread_ts);
+		return threadId ? ts === threadId || threadTs === threadId : Boolean(ts || threadTs);
+	})));
 }
 /**
 * Downloads a Slack file by ID and saves it to the local media store.
@@ -940,7 +853,7 @@ function lacksSlackScopeProof(params) {
 async function downloadSlackFile(fileId, opts) {
 	const token = resolveToken(opts.token, opts.accountId, opts.cfg);
 	const client = await getClient(opts);
-	const isFileAllowed = (file) => !lacksSlackScopeProof({
+	const isFileAllowed = (file) => hasSlackScopeProof({
 		file,
 		channelId: opts.channelId,
 		threadId: opts.threadId
@@ -963,4 +876,4 @@ async function downloadSlackFile(fileId, opts) {
 	}))?.[0] ?? null;
 }
 //#endregion
-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 };
+export { hasSlackTableBlock as C, buildSlackEditTextPayload as D, resolveSlackMessageText as E, hasSlackMessageTableBlock as S, resolveSlackBlocksText as T, media_exports as _, editSlackRenderedMessage as a, formatSlackFileReference 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, isGovSlackClient as v, isSlackUnfurlAttachment as w, formatSlackFileReferenceList as x, saveRemoteMedia as y };