@openclaw/slack 2026.9.5 → 2026.9.7

package/dist/.setup/{plugin-routes-C3X0eVaK.mjs → plugin-routes-B8tooDLj.mjs}

@@ -1,4 +1,4 @@
-import { r as normalizeSlackWebhookPath, t as handleSlackHttpRequest } from "./registry-bbjH7IHX.mjs";
+import { r as normalizeSlackWebhookPath, t as handleSlackHttpRequest } from "./registry-CIbMfuf8.mjs";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 //#region extensions/slack/src/http/plugin-routes.ts
 function resolveSlackWebhookPaths(config) {

package/dist/.setup/{policy-Db_QWCZZ.mjs → policy-D-jfM174.mjs}

@@ -1,11 +1,9 @@
-import { i as buildSlackChannelPolicyScope, r as buildSlackChannelIdCandidates } from "./session-status-BhG6pdiH.mjs";
-import { D as normalizeSlackSlug, k as resolveSlackUserAllowListForTeam } from "./probe-64C6k3_Q.mjs";
+import { i as buildSlackChannelPolicyScope, r as buildSlackChannelIdCandidates } from "./session-status-DscajIsd.mjs";
+import { A as resolveSlackUserAllowListForTeam, O as normalizeSlackSlug } from "./probe-B2Y9qc_z.mjs";
 import { applyChannelMatchMeta, buildChannelKeyCandidates } from "openclaw/plugin-sdk/channel-targets";
+import { firstDefined } from "openclaw/plugin-sdk/allow-from";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
 //#region extensions/slack/src/monitor/channel-config.ts
-function firstDefined(...values) {
-	for (const value of values) if (value !== void 0) return value;
-}
 function resolveSlackChannelLabel(params) {
 	const channelName = params.channelName?.trim();
 	if (channelName) return `#${normalizeSlackSlug(channelName) || channelName}`;
@@ -36,6 +34,7 @@ function resolveSlackChannelConfig(params) {
 	const resolved = matched ?? fallback ?? {};
 	const allowed = firstDefined(resolved.enabled, fallback?.enabled, true) ?? true;
 	const requireMention = firstDefined(resolved.requireMention, fallback?.requireMention, requireMentionDefault) ?? requireMentionDefault;
+	const requireMentionInBotThreads = firstDefined(resolved.requireMentionInBotThreads, fallback?.requireMentionInBotThreads);
 	const ignoreOtherMentions = firstDefined(resolved.ignoreOtherMentions, fallback?.ignoreOtherMentions);
 	const allowBots = firstDefined(resolved.allowBots, fallback?.allowBots);
 	const replyToMode = firstDefined(resolved.replyToMode, fallback?.replyToMode);
@@ -51,6 +50,7 @@ function resolveSlackChannelConfig(params) {
 	const result = {
 		allowed,
 		requireMention,
+		requireMentionInBotThreads,
 		ignoreOtherMentions,
 		replyToMode,
 		allowBots,

package/dist/.setup/{probe-64C6k3_Q.mjs → probe-B2Y9qc_z.mjs}

@@ -1,14 +1,16 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { u as formatSlackBotTokenIdentityWarning } from "./accounts-C1FspRF-.mjs";
-import { a as parseSlackTarget } from "./target-parsing-DEsPjngB.mjs";
+import { r as __exportAll } from "./streaming-compat-C5Wut626.mjs";
+import { p as formatSlackBotTokenIdentityWarning } from "./accounts-D_N9IqNA.mjs";
+import { a as parseSlackTarget } from "./target-parsing-FFE26kOV.mjs";
+import { createRequire } from "node:module";
 import { isRecord, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { runChannelProbe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { normalizeHyphenSlug, normalizeStringEntriesLower } from "openclaw/plugin-sdk/string-normalization-runtime";
 import { compileAllowlist, resolveCompiledAllowlistMatch } from "openclaw/plugin-sdk/allow-from";
-import { normalizeHyphenSlug, normalizeStringEntries as normalizeStringEntries$1, normalizeStringEntriesLower } from "openclaw/plugin-sdk/string-normalization-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { hash } from "node:crypto";
 import { WebAPIRateLimitedError, WebClient } from "@slack/web-api";
-import { captureChannelReadAuthority, createHttp1EnvHttpProxyAgent, resolveEnvHttpProxyAgentOptions, resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
+import { addActiveManagedProxyTlsOptions, captureChannelReadAuthority, createHttp1EnvHttpProxyAgent, resolveEnvHttpProxyAgentOptions, resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { isDebugProxyGlobalFetchPatchInstalled } from "openclaw/plugin-sdk/proxy-capture";
 import { parseRetryAfterHeaderSeconds, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 import { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
@@ -24,18 +26,9 @@ function normalizeSlackSlug(raw) {
 	if (cached !== void 0) return cached;
 	const normalized = normalizeHyphenSlug(raw);
 	slackSlugCache.set(key, normalized);
-	if (slackSlugCache.size > SLACK_SLUG_CACHE_MAX) {
-		const oldest = slackSlugCache.keys().next();
-		if (!oldest.done) slackSlugCache.delete(oldest.value);
-	}
+	pruneMapToMaxSize(slackSlugCache, SLACK_SLUG_CACHE_MAX);
 	return normalized;
 }
-function normalizeAllowList(list) {
-	return normalizeStringEntries$1(list);
-}
-function normalizeAllowListLower(list) {
-	return normalizeStringEntriesLower(list);
-}
 function normalizeSlackAllowOwnerEntry(entry) {
 	const trimmed = normalizeOptionalLowercaseString(entry);
 	if (!trimmed || trimmed === "*") return;
@@ -95,7 +88,7 @@ function allowListMatches(params) {
 	return resolveSlackAllowListMatch(params).allowed;
 }
 function resolveSlackUserAllowed(params) {
-	const allowList = normalizeAllowListLower(params.allowList);
+	const allowList = normalizeStringEntriesLower(params.allowList);
 	if (allowList.length === 0) return true;
 	return allowListMatches({
 		allowList,
@@ -106,7 +99,7 @@ function resolveSlackUserAllowed(params) {
 	});
 }
 function resolveSlackUserAllowListForTeam(params) {
-	const allowList = normalizeAllowListLower(params.allowList);
+	const allowList = normalizeStringEntriesLower(params.allowList);
 	const teamId = normalizeOptionalLowercaseString(params.teamId);
 	return allowList.flatMap((entry) => {
 		if (entry === "*") return [entry];
@@ -137,7 +130,7 @@ function normalizeSlackFetchInit(init) {
 	const { body: _body, ...rest } = init;
 	return rest;
 }
-/** Build the dispatcher shared by Slack Web API fetches and Socket Mode. */
+/** Build the dispatcher for Slack Web API fetches (paired with the runtime fetch). */
 function resolveSlackProxyDispatcher() {
 	const options = resolveEnvHttpProxyAgentOptions();
 	if (!options) return;
@@ -147,6 +140,58 @@ function resolveSlackProxyDispatcher() {
 		return;
 	}
 }
+let slackSocketModeUndici;
+/**
+* Load the undici copy that @slack/socket-mode opens its WebSocket with.
+*
+* Socket Mode 3 calls `new undici.WebSocket(url, { dispatcher })` with its own
+* undici. A dispatcher from another undici copy fails the handshake, so we must
+* identify whether Socket Mode can share the runtime dispatcher. The explicit
+* `undici/index.js` subpath keeps Bun's bare-`undici` placeholder out of the
+* dispatcher (the same reason the runtime loads undici this way); under Bun,
+* Socket Mode's bare import gets Bun's WebSocket, which does not consult a
+* dispatcher at all.
+*/
+function loadSlackSocketModeUndici() {
+	if (slackSocketModeUndici) return slackSocketModeUndici;
+	const requireFromPlugin = createRequire(import.meta.url);
+	const requireFromBolt = createRequire(requireFromPlugin.resolve("@slack/bolt/package.json"));
+	slackSocketModeUndici = createRequire(requireFromBolt.resolve("@slack/socket-mode/package.json"))("undici/index.js");
+	return slackSocketModeUndici;
+}
+/**
+* Build the env-proxy dispatcher for Socket Mode's WebSocket.
+*
+* Reuse the Web API dispatcher when both transports load the same undici copy;
+* its custom proxy routing supports Socket Mode's CONNECT handshake. Otherwise
+* build one from Socket Mode's copy. Without a proxy env, preserve the default
+* direct connection.
+*/
+function resolveSlackSocketModeDispatcher(webApi) {
+	const options = resolveEnvHttpProxyAgentOptions();
+	if (!options) return;
+	const { EnvHttpProxyAgent } = loadSlackSocketModeUndici();
+	if (webApi instanceof EnvHttpProxyAgent) return webApi;
+	const agentOptions = addActiveManagedProxyTlsOptions(options);
+	try {
+		return new EnvHttpProxyAgent(agentOptions);
+	} catch {
+		return;
+	}
+}
+/** Pair each Slack monitor transport with the dispatcher from the undici copy it uses. */
+function resolveSlackMonitorDispatchers(mode) {
+	const webApi = resolveSlackProxyDispatcher();
+	const socketMode = mode === "socket" ? resolveSlackSocketModeDispatcher(webApi) : void 0;
+	return {
+		webApi,
+		socketMode,
+		close: async () => {
+			await webApi?.close();
+			if (socketMode !== webApi) await socketMode?.close();
+		}
+	};
+}
 const DIRECT_SLACK_DISPATCHER_OPTIONS = {
 	httpProxy: "",
 	httpsProxy: "",
@@ -252,6 +297,22 @@ function resolveSlackLookupClientOptions(options = {}, dispatcher = resolveSlack
 	return resolved;
 }
 //#endregion
+//#region extensions/slack/src/monitor/lru-map-cache.ts
+/** LRU-touch read: move hit to newest so pruneMapToMaxSize keeps active keys. */
+function readLruMapEntry(cache, cacheKey) {
+	const cached = cache.get(cacheKey);
+	if (cached) {
+		cache.delete(cacheKey);
+		cache.set(cacheKey, cached);
+	}
+	return cached;
+}
+function writeLruMapEntry(cache, cacheKey, entry, maxEntries) {
+	cache.delete(cacheKey);
+	cache.set(cacheKey, entry);
+	pruneMapToMaxSize(cache, maxEntries);
+}
+//#endregion
 //#region extensions/slack/src/client.ts
 const SLACK_WRITE_CLIENT_CACHE_MAX = 32;
 const SLACK_STARTUP_AUTH_TIMEOUT_MS = 1e4;
@@ -307,18 +368,11 @@ function slackWriteClientCacheKey(token, options) {
 function getSlackWriteClient(token, options = {}) {
 	const resolvedOptions = resolveSlackWriteClientOptions(options);
 	const tokenKey = slackWriteClientCacheKey(token, resolvedOptions);
-	const cached = slackWriteClientCache.get(tokenKey);
-	if (cached) {
-		slackWriteClientCache.delete(tokenKey);
-		slackWriteClientCache.set(tokenKey, cached);
-		return cached;
-	}
+	const cached = readLruMapEntry(slackWriteClientCache, tokenKey);
+	if (cached) return cached;
 	const client = new WebClient(token, resolvedOptions);
-	if (slackWriteClientCache.size >= SLACK_WRITE_CLIENT_CACHE_MAX) {
-		const oldestTokenKey = slackWriteClientCache.keys().next().value;
-		if (oldestTokenKey) slackWriteClientCache.delete(oldestTokenKey);
-	}
 	slackWriteClientCache.set(tokenKey, client);
+	pruneMapToMaxSize(slackWriteClientCache, SLACK_WRITE_CLIENT_CACHE_MAX);
 	return client;
 }
 function getSlackListenerWriteClient(params) {
@@ -370,12 +424,14 @@ async function collectSlackCursorPages(params) {
 //#region extensions/slack/src/errors.ts
 const NO_ERROR_DETAIL = "no error detail";
 const MAX_ERROR_CAUSE_DEPTH = 32;
-function redact(value) {
-	return redactSensitiveText(value);
+function getSlackWebApiErrorData(error) {
+	if (!(error instanceof Error)) return;
+	const data = error.data;
+	return data && typeof data === "object" ? data : void 0;
 }
 function addStringDetail(details, label, value) {
 	if (typeof value !== "string") return;
-	const trimmed = redact(value.trim());
+	const trimmed = redactSensitiveText(value.trim());
 	if (trimmed) details.push(label ? `${label}: ${trimmed}` : trimmed);
 }
 function addScalarDetail(details, label, value) {
@@ -389,7 +445,7 @@ function addStringListDetail(details, label, value) {
 	if (!Array.isArray(value)) return;
 	const entries = value.flatMap((entry) => {
 		if (typeof entry !== "string") return [];
-		const trimmed = redact(entry.trim());
+		const trimmed = redactSensitiveText(entry.trim());
 		return trimmed ? [trimmed] : [];
 	});
 	if (entries.length) details.push(`${label}: ${entries.join(", ")}`);
@@ -403,7 +459,7 @@ function safeStringify(value) {
 			seen.add(nested);
 			return nested;
 		});
-		return result ? redact(result) : void 0;
+		return result ? redactSensitiveText(result) : void 0;
 	} catch {
 		return;
 	}
@@ -412,10 +468,10 @@ function addSlackResponseMetadata(details, value) {
 	if (!isRecord(value)) return;
 	addStringListDetail(details, "scopes", value.scopes);
 	addStringListDetail(details, "accepted", value.acceptedScopes);
-	const messages = value.messages;
-	if (Array.isArray(messages)) for (const message of messages) addStringDetail(details, "slack message", message);
-	const warnings = value.warnings;
-	if (Array.isArray(warnings)) for (const warning of warnings) addStringDetail(details, "slack warning", warning);
+	for (const [key, label] of [["messages", "slack message"], ["warnings", "slack warning"]]) {
+		const entries = value[key];
+		if (Array.isArray(entries)) for (const entry of entries) addStringDetail(details, label, entry);
+	}
 }
 function addSlackDataDetails(details, value) {
 	if (!isRecord(value)) return;
@@ -566,7 +622,13 @@ function createSlackIngressSubject(params) {
 	const senderName = params.senderName?.trim().toLowerCase();
 	const senderNameSlug = senderName ? normalizeSlackSlug(senderName) : void 0;
 	return {
-		stableId: senderId,
+		stableId: params.senderId,
+		authentication: {
+			senderId: params.senderAuthentication ?? "asserted",
+			workspaceSenderId: params.senderAuthentication ?? "asserted",
+			senderName: "mutable",
+			senderNameSlug: "mutable"
+		},
 		aliases: {
 			workspaceSenderId: teamId && senderId ? `team:${teamId}:user:${senderId}` : void 0,
 			senderName,
@@ -645,4 +707,4 @@ async function probeSlack(token, timeoutMs = 2500, opts) {
 	}
 }
 //#endregion
-export { resolveSlackUserAllowed as A, allowListMatches as C, normalizeSlackSlug as D, normalizeSlackAllowOwnerEntry as E, resolveSlackAllowListMatch as O, resolveSlackWriteClientOptions as S, normalizeAllowListLower as T, SLACK_DEFAULT_RETRY_OPTIONS as _, slackIngressIdentity as a, resolveSlackProxyDispatcher as b, fetchSlackChannelListPage as c, createSlackStartupAuthClient as d, createSlackTokenCacheKey as f, getSlackWriteClient as g, getSlackListenerWriteClient as h, createSlackIngressSubject as i, resolveSlackUserAllowListForTeam as k, createSlackLookupClient as l, createSlackWriteClient as m, probe_exports as n, formatSlackError as o, createSlackWebClient as p, SLACK_USER_NAME_KIND as r, collectSlackCursorPages as s, probeSlack as t, createSlackReadClient as u, SLACK_WRITE_RETRY_OPTIONS as v, normalizeAllowList as w, resolveSlackWebClientOptions as x, resolveSlackLookupClientOptions as y };
+export { resolveSlackUserAllowListForTeam as A, resolveSlackMonitorDispatchers as C, normalizeSlackAllowOwnerEntry as D, allowListMatches as E, normalizeSlackSlug as O, resolveSlackLookupClientOptions as S, resolveSlackWriteClientOptions as T, getSlackWriteClient as _, slackIngressIdentity as a, SLACK_DEFAULT_RETRY_OPTIONS as b, collectSlackCursorPages as c, createSlackReadClient as d, createSlackStartupAuthClient as f, getSlackListenerWriteClient as g, createSlackWriteClient as h, createSlackIngressSubject as i, resolveSlackUserAllowed as j, resolveSlackAllowListMatch as k, fetchSlackChannelListPage as l, createSlackWebClient as m, probe_exports as n, formatSlackError as o, createSlackTokenCacheKey as p, SLACK_USER_NAME_KIND as r, getSlackWebApiErrorData as s, probeSlack as t, createSlackLookupClient as u, readLruMapEntry as v, resolveSlackWebClientOptions as w, SLACK_WRITE_RETRY_OPTIONS as x, writeLruMapEntry as y };

package/dist/.setup/{registry-bbjH7IHX.mjs → registry-CIbMfuf8.mjs}

@@ -23,9 +23,13 @@ function registerSlackHttpHandler(params) {
 		params.log?.(`slack: webhook path ${normalizedPath} already registered${suffix}`);
 		return () => {};
 	}
-	routes.set(normalizedPath, params.handler);
+	const handler = params.handler;
+	routes.set(normalizedPath, handler);
+	let registered = true;
 	return () => {
-		getSlackHttpRoutes().delete(normalizedPath);
+		if (!registered) return;
+		registered = false;
+		if (routes.get(normalizedPath) === handler) routes.delete(normalizedPath);
 	};
 }
 async function handleSlackHttpRequest(req, res) {

package/dist/.setup/{relay-source-CDqY76Vp.mjs → relay-source-BpKdjsll.mjs}

@@ -1,5 +1,6 @@
-import { C as formatUnknownError, S as SLACK_SOCKET_RECONNECT_POLICY, a as requireSlackMessageEvent, i as parseSlackMessageEvent } from "./provider-w36VTgZ3.mjs";
-import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { o as formatSlackError } from "./probe-B2Y9qc_z.mjs";
+import { d as parseSlackMessageEvent, f as requireSlackMessageEvent, x as SLACK_SOCKET_RECONNECT_POLICY } from "./monitor-BPVfkumU.mjs";
+import { asOptionalRecord, normalizeOptionalString, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
 import { isIP } from "node:net";
@@ -42,11 +43,11 @@ async function monitorSlackRelaySource(params) {
 				lifecycle: "recovering",
 				lastDisconnect: {
 					at: Date.now(),
-					error: formatUnknownError(err)
+					error: formatSlackError(err)
 				},
-				lastError: formatUnknownError(err)
+				lastError: formatSlackError(err)
 			});
-			params.runtime.log?.(warn(`slack relay mode disconnected; reconnecting in ${Math.round(delayMs / 1e3)}s (attempt ${reconnectAttempts}) reason="${formatUnknownError(err)}"`));
+			params.runtime.log?.(warn(`slack relay mode disconnected; reconnecting in ${Math.round(delayMs / 1e3)}s (attempt ${reconnectAttempts}) reason="${formatSlackError(err)}"`));
 			await sleepWithAbort(delayMs, params.abortSignal);
 		} finally {
 			closeRelayWebSocket(connection);
@@ -114,7 +115,7 @@ function runRelayWebSocket(params) {
 				setStatus: params.setStatus,
 				setIdentity: params.setIdentity
 			})).catch((err) => {
-				params.runtime.error?.(`slack relay frame failed: ${formatUnknownError(err)}`);
+				params.runtime.error?.(`slack relay frame failed: ${formatSlackError(err)}`);
 			});
 		};
 		const onError = (error) => {
@@ -213,10 +214,10 @@ function parseRelayFrame(data) {
 function extractRelaySlackMessageEvent(frame) {
 	const record = asOptionalRecord(frame);
 	if (!record || record.type !== "slack_event") return;
-	const deliveryId = stringValue(record.delivery_id);
+	const deliveryId = readStringValue(record.delivery_id);
 	const routeRecord = asOptionalRecord(record.route);
-	const routeKind = stringValue(routeRecord?.kind);
-	const routeKey = stringValue(routeRecord?.key);
+	const routeKind = readStringValue(routeRecord?.kind);
+	const routeKey = readStringValue(routeRecord?.key);
 	const payload = asOptionalRecord(record.payload);
 	const event = parseSlackMessageEvent(payload?.event);
 	if (!event) return;
@@ -263,8 +264,5 @@ function formatRelayClose(code, reason) {
 	const text = reason.toString("utf8");
 	return text ? `Slack relay websocket closed (${code} ${text})` : `Slack relay websocket closed (${code})`;
 }
-function stringValue(value) {
-	return typeof value === "string" ? value : void 0;
-}
 //#endregion
 export { SLACK_RELAY_MAX_PAYLOAD_BYTES, SlackRelayMalformedFrameError, buildRelayWebSocketOptions, buildRelayWebSocketUrl, monitorSlackRelaySource, parseRelayFrame, requireSlackMessageEvent };

package/dist/.setup/{replies-CWFhjS9S.mjs → replies-BAnUtr2f.mjs}

@@ -1,8 +1,8 @@
-import { C as buildSlackBlocksFallbackText, J as markdownToSlackMrkdwnChunks, b as isSlackInvalidBlocksResponse, g as buildSlackNativeDataAccessibilityText, k as SLACK_TEXT_LIMIT, v as hasSlackNativeDataBlock, x as isSlackNativeResponseUrlRejection } from "./session-status-BhG6pdiH.mjs";
-import { n as iterateSlackReplyDeliveryMessages, o as resolveSlackReplyBlockResolution, s as resolveSlackReplyBlocks, t as hasSlackReplyStructuredContent } from "./reply-blocks-9uCeAJts.mjs";
-import { n as resolveSlackReplyThreadTs } from "./thread-ts-CukseRVL.mjs";
-import { h as chunkSlackTextAtHardLimit, m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-6GCb3lBP.mjs";
-import { c as createSlackResponseUrlBudget, s as SlackResponseAlreadyReportedError } from "./provider-w36VTgZ3.mjs";
+import { C as buildSlackBlocksFallbackText, Z as markdownToSlackMrkdwnChunks, b as isSlackInvalidBlocksResponse, g as buildSlackNativeDataAccessibilityText, k as SLACK_TEXT_LIMIT, v as hasSlackNativeDataBlock, x as isSlackNativeResponseUrlRejection } from "./session-status-DscajIsd.mjs";
+import { n as iterateSlackReplyDeliveryMessages, o as resolveSlackReplyBlockResolution, t as hasSlackReplyStructuredContent } from "./reply-blocks-SE1kTE3I.mjs";
+import { n as resolveSlackReplyThreadTs } from "./thread-ts-Cvt7WD6B.mjs";
+import { m as chunkSlackTextAtHardLimit, p as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-BOVLQi3n.mjs";
+import { a as SlackResponseAlreadyReportedError, o as createSlackResponseUrlBudget } from "./monitor-BPVfkumU.mjs";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
@@ -14,18 +14,11 @@ import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
 import { createChannelPartialDeliveryError, getGroupThreadDeliverySession } from "openclaw/plugin-sdk/channel-inbound";
 import { buildCanonicalSentMessageHookContext, createInternalHookEvent, fireAndForgetHook, toInternalMessageSentContext, toPluginMessageContext, toPluginMessageSentEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
 //#region extensions/slack/src/message-sent-hook.ts
-/**
-* Slack-side emission of the `message_sent` plugin hook.
-*
-* Mirrors the Telegram pattern in `extensions/telegram/src/bot/delivery.replies.ts`
-* (`buildTelegramSentHookContext`, `emitMessageSentHooks`, `emitTelegramMessageSentHooks`).
-*
-* Without this, plugins observing `message_sent` see Telegram outbound but not
-* Slack outbound — even though `docs/plugins/hooks.md` documents the hook as
-* firing for all successful outbound deliveries.
-*/
-function buildSlackSentHookContext(params) {
-	return buildCanonicalSentMessageHookContext({
+function emitSlackMessageSentHooks(params) {
+	const hookRunner = getGlobalHookRunner();
+	const enabled = hookRunner?.hasHooks("message_sent") ?? false;
+	if (!enabled && !params.sessionKeyForInternalHooks) return;
+	const canonical = buildCanonicalSentMessageHookContext({
 		to: params.to,
 		content: params.content,
 		success: params.success,
@@ -38,34 +31,8 @@ function buildSlackSentHookContext(params) {
 		isGroup: params.isGroup,
 		groupId: params.groupId
 	});
-}
-function emitInternalSlackMessageSentHook(params) {
-	if (!params.sessionKeyForInternalHooks) return;
-	const canonical = buildSlackSentHookContext(params);
-	fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "sent", params.sessionKeyForInternalHooks, toInternalMessageSentContext(canonical))), "slack: message:sent internal hook failed");
-}
-function emitMessageSentHooks(params) {
-	if (!params.enabled && !params.sessionKeyForInternalHooks) return;
-	const canonical = buildSlackSentHookContext(params);
-	if (params.enabled) fireAndForgetHook(Promise.resolve(params.hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical))), "slack: message_sent plugin hook failed");
-	emitInternalSlackMessageSentHook(params);
-}
-/**
-* Fire both the plugin `message_sent` hook and (if a session key is supplied)
-* the internal `message:sent` hook for a successful or failed Slack outbound
-* delivery.
-*
-* Safe to call after every `chat.postMessage` — the function self-gates on
-* `hookRunner.hasHooks("message_sent")` so plugins not observing the hook
-* incur no cost.
-*/
-function emitSlackMessageSentHooks(params) {
-	const hookRunner = getGlobalHookRunner();
-	emitMessageSentHooks({
-		...params,
-		hookRunner,
-		enabled: hookRunner?.hasHooks("message_sent") ?? false
-	});
+	if (enabled) fireAndForgetHook(Promise.resolve(hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical))), "slack: message_sent plugin hook failed");
+	if (params.sessionKeyForInternalHooks) fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "sent", params.sessionKeyForInternalHooks, toInternalMessageSentContext(canonical))), "slack: message:sent internal hook failed");
 }
 //#endregion
 //#region extensions/slack/src/monitor/replies.ts
@@ -115,9 +82,6 @@ function compactSlackResponseUrlFallback(messages) {
 	flush();
 	return compacted;
 }
-function readSlackReplyBlocks(payload) {
-	return resolveSlackReplyBlocks(payload);
-}
 function sanitizeSlackMonitorReplyPayload(payload) {
 	if (payload.isReasoning === true || typeof payload.text !== "string") return payload.isReasoning === true ? null : payload;
 	const text = sanitizeAssistantVisibleText(payload.text);
@@ -267,37 +231,13 @@ async function deliverReplies(params) {
 	}
 	return latestResult;
 }
-/**
-* Compute effective threadTs for a Slack reply based on replyToMode.
-* - "off": stay in thread if already in one, otherwise main channel
-* - "first": first reply goes to thread, subsequent replies to main channel
-* - "all": all replies go to thread
-*/
-function resolveSlackThreadTs(params) {
-	return createSlackReplyReferencePlanner({
-		replyToMode: params.replyToMode,
-		incomingThreadTs: params.incomingThreadTs,
-		messageTs: params.messageTs,
-		hasReplied: params.hasReplied,
-		isThreadReply: params.isThreadReply
-	}).use();
-}
-function createSlackReplyReferencePlanner(params) {
+function createSlackReplyDeliveryPlan(params) {
 	const effectiveMode = params.isThreadReply ?? Boolean(params.incomingThreadTs && params.incomingThreadTs !== params.messageTs) ? "all" : params.replyToMode;
-	return createReplyReferencePlanner({
+	const replyReference = createReplyReferencePlanner({
 		replyToMode: effectiveMode,
 		existingId: params.incomingThreadTs,
 		startId: params.messageTs,
-		hasReplied: params.hasReplied
-	});
-}
-function createSlackReplyDeliveryPlan(params) {
-	const replyReference = createSlackReplyReferencePlanner({
-		replyToMode: params.replyToMode,
-		incomingThreadTs: params.incomingThreadTs,
-		messageTs: params.messageTs,
-		hasReplied: params.hasRepliedRef.value,
-		isThreadReply: params.isThreadReply
+		hasReplied: params.hasRepliedRef.value
 	});
 	return {
 		peekThreadTs: () => replyReference.peek(),
@@ -507,4 +447,4 @@ async function deliverSlackSlashReplies(params) {
 	}
 }
 //#endregion
-export { resolveSlackThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, sanitizeSlackMonitorReplyPayload as o, deliverSlackSlashReplies as r, emitSlackMessageSentHooks as s, createSlackReplyDeliveryPlan as t };
+export { emitSlackMessageSentHooks as a, sanitizeSlackMonitorReplyPayload as i, deliverReplies as n, deliverSlackSlashReplies as r, createSlackReplyDeliveryPlan as t };