@openclaw/slack 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/{provider-DOZHzRWi.js → provider-Cot8h818.js}

@@ -1,29 +1,29 @@
 import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath } from "./registry-bbjH7IHX.js";
-import { a as resolveSlackAccount, d as resolveSlackBotToken, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy, u as resolveSlackAppToken } from "./accounts-BPCiCe8y.js";
-import { F as isSlackExecApprovalAuthorizedSender, N as isSlackApprovalAuthorizedSender, S as isSlackAnyNativeApprovalClientEnabled, a as SLACK_TEXT_LIMIT, c as allowListMatches, d as normalizeSlackAllowOwnerEntry, f as normalizeSlackSlug, l as normalizeAllowList, p as resolveSlackAllowListMatch, u as normalizeAllowListLower, v as truncateSlackText } from "./reply-blocks-CfJqf7eq.js";
-import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-D-22gTp3.js";
-import { c as resolveSlackWebClientOptions } from "./client-DG9cyk55.js";
+import { a as resolveSlackAccount, d as formatSlackBotTokenIdentityWarning, f as resolveSlackAppToken, o as resolveSlackAccountAllowFrom, p as resolveSlackBotToken, s as resolveSlackAccountDmPolicy } from "./accounts-BOJJiHSr.js";
+import { B as isSlackExecApprovalAuthorizedSender, D as isSlackAnyNativeApprovalClientEnabled, R as isSlackApprovalAuthorizedSender, a as SLACK_TEXT_LIMIT, b as truncateSlackText, c as formatSlackError, d as normalizeAllowListLower, f as normalizeSlackAllowOwnerEntry, l as allowListMatches, m as resolveSlackAllowListMatch, p as normalizeSlackSlug, u as normalizeAllowList } from "./reply-blocks-BGQ6zSqM.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-CXpT-vA_.js";
+import { c as resolveSlackWebClientOptions } from "./client-DGxwSL7f.js";
 import { t as getOptionalSlackRuntime } from "./runtime-BOk7xkOl.js";
-import { n as setSlackDefaultSendIdentity } from "./send-Dg6U9K7_.js";
-import { t as formatSlackError } from "./errors-CZtmv-h0.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-eniB45fy.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-DDKzl37a.js";
-import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-DAE6BTN3.js";
+import { i as setSlackDefaultSendIdentity } from "./send-DKDXoeoV.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-CstkChBE.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-C3NP2c-Q.js";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-Dj-puVPb.js";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
-import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, normalizeStringEntriesLower, normalizeUniqueTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, normalizeStringEntriesLower, normalizeUniqueTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeAccountId, normalizeMainKey, resolveAgentRoute, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
 import { createChannelMessageReplyPipeline } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { computeBackoff, createNonExitingRuntime, createSubsystemLogger, danger, getChildLogger, logVerbose, shouldLogVerbose, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { chunkItems } from "openclaw/plugin-sdk/text-chunking";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
 import { parseExecApprovalCommandText } from "openclaw/plugin-sdk/approval-reply-runtime";
-import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, formatAllowlistMatchMeta, mergeAllowlist, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
-import { computeBackoff, createNonExitingRuntime, createSubsystemLogger, danger, getChildLogger, logVerbose, shouldLogVerbose, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, formatAllowlistMatchMeta, mergeAllowlist, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
+import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { asDateTimestampMs, parseFiniteNumber, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
-import { createDedupeCache, resolveGlobalDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
+import { createDedupeCache, createPersistentDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 import { buildPluginBindingResolvedText, parsePluginBindingApprovalCustomId, recordInboundSession, resolveConversationLabel as resolveConversationLabel$1, resolvePluginConversationBindingApproval, resolveRuntimeConversationBindingRoute, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
 import { resolveNativeCommandsEnabled, resolveNativeSkillsEnabled } from "openclaw/plugin-sdk/native-command-config-runtime";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
@@ -109,7 +109,7 @@ function buildSlackAssistantThreadMetadata(context) {
 function parseSlackAssistantThreadMetadata(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
 	const metadata = value;
-	if (metadata.event_type !== "assistant_thread_context") return;
+	if (metadata.event_type !== SLACK_ASSISTANT_THREAD_CONTEXT_METADATA_EVENT) return;
 	const payload = metadata.event_payload;
 	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return;
 	const record = payload;
@@ -282,7 +282,8 @@ function createSlackMonitorContext(params) {
 				token: params.botToken,
 				channel_id: p.channelId,
 				thread_ts: p.threadTs,
-				status: p.status
+				status: p.status,
+				...p.loadingMessages?.length ? { loading_messages: p.loadingMessages.slice(0, 10) } : {}
 			});
 		} catch (err) {
 			logVerbose(`slack status update failed for channel ${p.channelId}: ${formatSlackError(err)}`);
@@ -636,10 +637,11 @@ function registerSlackChannelEvents(params) {
 			trackEvent?.();
 			const payload = event;
 			const channelId = payload.channel?.id;
+			const channelName = payload.channel?.name_normalized ?? payload.channel?.name;
 			enqueueChannelSystemEvent({
 				kind: "renamed",
 				channelId,
-				channelName: payload.channel?.name_normalized ?? payload.channel?.name
+				channelName
 			});
 		} catch (err) {
 			ctx.runtime.error?.(danger(`slack channel rename handler failed: ${formatErrorMessage(err)}`));
@@ -1271,6 +1273,11 @@ function buildSlackPluginInteractionData(params) {
 function isSlackReplyActionId(actionId) {
 	return actionId === "openclaw:reply_button" || actionId === "openclaw:reply_select" || actionId.startsWith(`openclaw:reply_button:`) || actionId.startsWith(`openclaw:reply_select:`);
 }
+function isSlackReplyLinkAction(parsed) {
+	if (parsed.actionId === "openclaw:reply_link" || parsed.actionId.startsWith(`openclaw:reply_link:`)) return true;
+	const legacyUrl = normalizeOptionalString(parsed.typedAction.url);
+	return Boolean(legacyUrl && isSlackReplyActionId(parsed.actionId));
+}
 function buildSlackPluginInteractionId(params) {
 	const primaryValue = normalizeOptionalString(params.summary.value) || params.summary.selectedValues?.map((value) => normalizeOptionalString(value)).find(Boolean) || "";
 	return [
@@ -1299,7 +1306,7 @@ function parseSlackBlockAction(params) {
 		userId: typedBody.user?.id ?? "unknown",
 		channelId: typedBody.channel?.id ?? typedBody.container?.channel_id,
 		messageTs: typedBody.message?.ts ?? typedBody.container?.message_ts,
-		threadTs: typedBody.container?.thread_ts,
+		threadTs: typedBody.container?.thread_ts ?? typedBody.message?.thread_ts,
 		actionSummary: summarizeAction(typedAction)
 	};
 }
@@ -1622,6 +1629,7 @@ async function handleSlackBlockAction(params) {
 		log: params.ctx.runtime.log
 	});
 	if (!parsed) return;
+	if (isSlackReplyLinkAction(parsed)) return;
 	params.trackEvent?.();
 	const pluginInteractionData = buildSlackPluginInteractionData({
 		actionId: parsed.actionId,
@@ -2065,7 +2073,7 @@ const SLACK_INTERACTION_EVENT_MAX_CHARS = 2400;
 const SLACK_INTERACTION_STRING_MAX_CHARS = 160;
 const SLACK_INTERACTION_ARRAY_MAX_ITEMS = 64;
 const SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS = 3;
-const SLACK_INTERACTION_REDACTED_KEYS = new Set([
+const SLACK_INTERACTION_REDACTED_KEYS = /* @__PURE__ */ new Set([
 	"triggerId",
 	"responseUrl",
 	"workflowTriggerUrl",
@@ -2614,75 +2622,30 @@ function registerSlackMonitorEvents(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/inbound-delivery-state.ts
-const TTL_MS = 1440 * 60 * 1e3;
-const MAX_ENTRIES = 2e4;
-const PERSISTENT_MAX_ENTRIES = 2e4;
-const PERSISTENT_NAMESPACE = "slack.inbound-deliveries";
-const deliveredMessages = resolveGlobalDedupeCache(Symbol.for("openclaw.slackInboundDeliveries"), {
-	ttlMs: TTL_MS,
-	maxSize: MAX_ENTRIES
+const deliveredMessages = createPersistentDedupeCache({
+	globalKey: Symbol.for("openclaw.slackInboundDeliveries"),
+	ttlMs: 1440 * 60 * 1e3,
+	maxSize: 2e4,
+	persistent: {
+		namespace: "slack.inbound-deliveries",
+		maxEntries: 2e4,
+		openStore: (options) => getOptionalSlackRuntime()?.state.openKeyedStore(options),
+		logError: (error) => {
+			try {
+				getOptionalSlackRuntime()?.logging.getChildLogger({
+					plugin: "slack",
+					feature: "inbound-delivery-state"
+				}).warn("Slack persistent inbound delivery state failed", { error: String(error) });
+			} catch {}
+		}
+	}
 });
-let persistentStore;
-let persistentStoreDisabled = false;
 function makeKey(accountId, channelId, ts) {
 	return `${accountId}:${channelId}:${ts}`;
 }
-function reportPersistentInboundDeliveryError(error) {
-	try {
-		getOptionalSlackRuntime()?.logging.getChildLogger({
-			plugin: "slack",
-			feature: "inbound-delivery-state"
-		}).warn("Slack persistent inbound delivery state failed", { error: String(error) });
-	} catch {}
-}
-function disablePersistentInboundDelivery(error) {
-	persistentStoreDisabled = true;
-	persistentStore = void 0;
-	reportPersistentInboundDeliveryError(error);
-}
-function getPersistentInboundDeliveryStore() {
-	if (persistentStoreDisabled) return;
-	if (persistentStore) return persistentStore;
-	const runtime = getOptionalSlackRuntime();
-	if (!runtime) return;
-	try {
-		persistentStore = runtime.state.openKeyedStore({
-			namespace: PERSISTENT_NAMESPACE,
-			maxEntries: PERSISTENT_MAX_ENTRIES,
-			defaultTtlMs: TTL_MS
-		});
-		return persistentStore;
-	} catch (error) {
-		disablePersistentInboundDelivery(error);
-		return;
-	}
-}
-async function lookupPersistentInboundDelivery(key) {
-	const store = getPersistentInboundDeliveryStore();
-	if (!store) return false;
-	try {
-		return Boolean(await store.lookup(key));
-	} catch (error) {
-		disablePersistentInboundDelivery(error);
-		return false;
-	}
-}
-async function rememberPersistentInboundDelivery(key, deliveredAt) {
-	const store = getPersistentInboundDeliveryStore();
-	if (!store) return;
-	try {
-		await store.register(key, { deliveredAt });
-	} catch (error) {
-		disablePersistentInboundDelivery(error);
-	}
-}
 async function hasSlackInboundMessageDelivery(params) {
 	if (!params.accountId || !params.channelId || !params.ts) return false;
-	const key = makeKey(params.accountId, params.channelId, params.ts);
-	if (deliveredMessages.peek(key)) return true;
-	const found = await lookupPersistentInboundDelivery(key);
-	if (found) deliveredMessages.check(key);
-	return found;
+	return await deliveredMessages.lookup(makeKey(params.accountId, params.channelId, params.ts));
 }
 async function recordSlackInboundMessageDeliveries(params) {
 	if (!params.accountId || params.messages.length === 0) return;
@@ -2692,9 +2655,7 @@ async function recordSlackInboundMessageDeliveries(params) {
 		if (!message.channel || !message.ts) continue;
 		keys.add(makeKey(params.accountId, message.channel, message.ts));
 	}
-	if (keys.size === 0) return;
-	for (const key of keys) deliveredMessages.check(key, deliveredAt);
-	await Promise.all(Array.from(keys, (key) => rememberPersistentInboundDelivery(key, deliveredAt)));
+	await Promise.all(Array.from(keys, (key) => deliveredMessages.register(key, { deliveredAt }, { at: deliveredAt })));
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/debounce-key.ts
@@ -2740,7 +2701,8 @@ async function resolveThreadTsFromHistory(params) {
 			inclusive: true,
 			limit: 1
 		});
-		return normalizeThreadTs((response.messages?.find((entry) => entry.ts === params.messageTs) ?? response.messages?.[0])?.thread_ts);
+		const message = response.messages?.find((entry) => entry.ts === params.messageTs) ?? response.messages?.[0];
+		return normalizeThreadTs(message?.thread_ts);
 	} catch (err) {
 		if (shouldLogVerbose()) logVerbose(`slack inbound: failed to resolve thread_ts via conversations.history for channel=${params.channelId} ts=${params.messageTs}: ${formatSlackError(err)}`);
 		return;
@@ -2820,11 +2782,7 @@ function createSlackThreadTsResolver(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler.ts
-let slackMessagePipelinePromise;
-function loadSlackMessagePipeline() {
-	slackMessagePipelinePromise ??= import("./pipeline.runtime-BKICBY52.js");
-	return slackMessagePipelinePromise;
-}
+const loadSlackMessagePipeline = createLazyRuntimeModule(() => import("./pipeline.runtime-0wEFX2CS.js"));
 function createSlackDispatchCompletion() {
 	let resolve;
 	let reject;
@@ -2838,12 +2796,19 @@ function createSlackDispatchCompletion() {
 	};
 }
 const APP_MENTION_RETRY_TTL_MS = 6e4;
+const RETRYABLE_FLUSH_MAX_ATTEMPTS = 3;
+const RETRYABLE_FLUSH_RETRY_DELAY_MS = 1e3;
+const REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE = /reply session initialization conflicted for \S+/u;
 var SlackRetryableInboundError = class extends Error {
 	constructor(message, options) {
 		super(message, options);
 		this.name = "SlackRetryableInboundError";
 	}
 };
+function isRetryableSlackInboundError(error) {
+	if (error instanceof SlackRetryableInboundError) return true;
+	return collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE.test(formatErrorMessage(candidate)));
+}
 function shouldDebounceSlackMessage(message, cfg) {
 	return shouldDebounceTextInbound({
 		text: stripSlackMentionsForCommandDetection(message.text ?? ""),
@@ -2863,6 +2828,29 @@ function createSlackMessageHandler(params) {
 		buildKey: (entry) => buildSlackDebounceKey(entry.message, ctx.accountId),
 		shouldDebounce: (entry) => shouldDebounceSlackMessage(entry.message, ctx.cfg),
 		onFlush: async (entries) => {
+			const retryEntries = (sourceError) => {
+				if (!isRetryableSlackInboundError(sourceError)) return false;
+				const nextEntries = entries.map((entry) => {
+					if (entry.opts.dispatchCompletion) return null;
+					const retryAttempt = entry.opts.retryAttempt ?? 0;
+					if (retryAttempt >= RETRYABLE_FLUSH_MAX_ATTEMPTS) return null;
+					const { dispatchCompletion: _dispatchCompletion, ...retryOpts } = entry.opts;
+					return {
+						...entry,
+						opts: {
+							...retryOpts,
+							retryAttempt: retryAttempt + 1
+						}
+					};
+				}).filter((entry) => entry !== null);
+				if (nextEntries.length === 0) return false;
+				setTimeout(() => {
+					for (const entry of nextEntries) enqueueSlackMessage(entry.message, entry.opts).catch((err) => {
+						ctx.runtime.error?.(`slack inbound retry enqueue failed: ${formatErrorMessage(err)}`);
+					});
+				}, RETRYABLE_FLUSH_RETRY_DELAY_MS).unref?.();
+				return true;
+			};
 			const completions = entries.map((entry) => entry.opts.dispatchCompletion).filter((completion) => completion !== void 0);
 			try {
 				await (async () => {
@@ -2887,26 +2875,36 @@ function createSlackMessageHandler(params) {
 					try {
 						const { prepareSlackMessage, dispatchPreparedSlackMessage } = await loadSlackMessagePipeline();
 						const { dispatchCompletion: _completion, awaitDispatch: _awaitDispatch, ...lastOpts } = last.opts;
-						const prepared = await prepareSlackMessage({
-							ctx,
-							account,
-							message: syntheticMessage,
-							opts: {
-								...lastOpts,
-								wasMentioned: combinedMentioned || last.opts.wasMentioned
+						const appMentionRetryKey = seenMessageKey && lastOpts.source === "app_mention" && !ctx.botUserId ? seenMessageKey : void 0;
+						if (appMentionRetryKey) appMentionPreparingKeys.add(appMentionRetryKey);
+						const prepared = await (async () => {
+							try {
+								const result = await prepareSlackMessage({
+									ctx,
+									account,
+									message: syntheticMessage,
+									opts: {
+										...lastOpts,
+										wasMentioned: combinedMentioned || last.opts.wasMentioned,
+										...seenMessageKey && lastOpts.source === "message" ? { shouldRecordDroppedHistory: () => !appMentionPreparingKeys.has(seenMessageKey) && !appMentionDispatchedKeys.has(seenMessageKey) } : {}
+									}
+								});
+								if (result && seenMessageKey) {
+									pruneAppMentionRetryKeys(Date.now());
+									if (last.opts.source === "app_mention") rememberExpiringAppMentionKey(appMentionDispatchedKeys, seenMessageKey);
+									else if (last.opts.source === "message" && appMentionDispatchedKeys.has(seenMessageKey)) {
+										appMentionDispatchedKeys.delete(seenMessageKey);
+										appMentionRetryKeys.delete(seenMessageKey);
+										return null;
+									}
+									appMentionRetryKeys.delete(seenMessageKey);
+								}
+								return result;
+							} finally {
+								if (appMentionRetryKey) appMentionPreparingKeys.delete(appMentionRetryKey);
 							}
-						});
+						})();
 						if (!prepared) return;
-						if (seenMessageKey) {
-							pruneAppMentionRetryKeys(Date.now());
-							if (last.opts.source === "app_mention") rememberExpiringAppMentionKey(appMentionDispatchedKeys, seenMessageKey);
-							else if (last.opts.source === "message" && appMentionDispatchedKeys.has(seenMessageKey)) {
-								appMentionDispatchedKeys.delete(seenMessageKey);
-								appMentionRetryKeys.delete(seenMessageKey);
-								return;
-							}
-							appMentionRetryKeys.delete(seenMessageKey);
-						}
 						if (entries.length > 1) {
 							const ids = entries.map((entry) => entry.message.ts).filter(Boolean);
 							if (ids.length > 0) {
@@ -2922,22 +2920,24 @@ function createSlackMessageHandler(params) {
 								messages: entries.map((entry) => entry.message)
 							});
 						} catch (error) {
-							if (!(error instanceof SlackRetryableInboundError)) await recordSlackInboundMessageDeliveries({
+							if (!isRetryableSlackInboundError(error)) await recordSlackInboundMessageDeliveries({
 								accountId: ctx.accountId,
 								messages: entries.map((entry) => entry.message)
 							});
 							throw error;
 						}
 					} catch (error) {
-						if (error instanceof SlackRetryableInboundError) {
-							if (seenMessageKey) appMentionDispatchedKeys.delete(seenMessageKey);
-							ctx.releaseSeenMessage(last.message.channel, last.message.ts);
+						if (isRetryableSlackInboundError(error)) for (const entry of entries) {
+							const entrySeenKey = buildSeenMessageKey(entry.message.channel, entry.message.ts);
+							if (entrySeenKey) appMentionDispatchedKeys.delete(entrySeenKey);
+							ctx.releaseSeenMessage(entry.message.channel, entry.message.ts);
 						}
 						throw error;
 					}
 				})();
 				for (const completion of completions) completion.resolve();
 			} catch (error) {
+				retryEntries(error);
 				for (const completion of completions) completion.reject(error);
 				throw error;
 			}
@@ -2949,6 +2949,7 @@ function createSlackMessageHandler(params) {
 	const threadTsResolver = createSlackThreadTsResolver({ client: ctx.app.client });
 	const pendingTopLevelDebounceKeys = /* @__PURE__ */ new Map();
 	const appMentionRetryKeys = /* @__PURE__ */ new Map();
+	const appMentionPreparingKeys = /* @__PURE__ */ new Set();
 	const appMentionDispatchedKeys = /* @__PURE__ */ new Map();
 	const pruneAppMentionRetryKeys = (rawNow) => {
 		const now = asDateTimestampMs(rawNow);
@@ -2976,7 +2977,7 @@ function createSlackMessageHandler(params) {
 		appMentionRetryKeys.delete(key);
 		return true;
 	};
-	return async (message, opts) => {
+	async function enqueueSlackMessage(message, opts) {
 		if (opts.source === "message" && message.type !== "message") return;
 		if (opts.source === "message" && message.subtype && message.subtype !== "file_share" && message.subtype !== "bot_message" && message.subtype !== "thread_broadcast") return;
 		const seenMessageKey = buildSeenMessageKey(message.channel, message.ts);
@@ -3021,7 +3022,10 @@ function createSlackMessageHandler(params) {
 				} } : {}
 			}
 		});
-		await dispatchCompletion?.promise;
+		return dispatchCompletion;
+	}
+	return async (message, opts) => {
+		await (await enqueueSlackMessage(message, opts))?.promise;
 	};
 }
 //#endregion
@@ -3034,6 +3038,8 @@ const SLACK_SOCKET_RECONNECT_POLICY = {
 	factor: 1.8,
 	jitter: .25
 };
+const SLACK_SOCKET_SHARED_CONNECTION_DOCS_URL = "https://docs.slack.dev/apis/events-api/using-socket-mode#using-multiple-connections";
+const SLACK_SOCKET_HELLO_MARKER = Buffer.from("\"hello\"");
 function getSocketEmitter(app) {
 	const receiver = app.receiver;
 	const client = receiver && typeof receiver === "object" ? receiver.client : void 0;
@@ -3046,6 +3052,45 @@ function getSocketEmitter(app) {
 		off: (event, listener) => off.call(client, event, listener)
 	};
 }
+function isBufferArray(value) {
+	return Array.isArray(value) && value.every((entry) => Buffer.isBuffer(entry));
+}
+function resolveSlackSocketModeConnectionCount(message) {
+	const buffer = Buffer.isBuffer(message) ? message : message instanceof ArrayBuffer ? Buffer.from(message) : isBufferArray(message) ? Buffer.concat(message) : void 0;
+	if (!buffer?.includes(SLACK_SOCKET_HELLO_MARKER)) return;
+	let payload;
+	try {
+		payload = JSON.parse(buffer.toString("utf8"));
+	} catch {
+		return;
+	}
+	const count = isRecord(payload) && payload.type === "hello" ? payload.num_connections : void 0;
+	return typeof count === "number" && Number.isSafeInteger(count) && count >= 0 ? count : void 0;
+}
+function formatSlackSocketModeSharedConnectionWarning(activeConnections) {
+	return [
+		`slack socket mode reports ${activeConnections} active connections for this Slack app`,
+		"Slack may deliver each event to any one connection",
+		"ensure every OpenClaw gateway sharing this app has equivalent routing and authorization, or use a separate Slack app per gateway, one relay ingress, or HTTP Request URLs behind a load balancer",
+		`See ${SLACK_SOCKET_SHARED_CONNECTION_DOCS_URL}`
+	].join("; ");
+}
+function registerSlackSocketModeConnectionDiagnostics(params) {
+	const emitter = getSocketEmitter(params.app);
+	if (!emitter) return () => {};
+	let hasWarned = false;
+	const listener = (message, isBinary) => {
+		if (isBinary === true || hasWarned) return;
+		const activeConnections = resolveSlackSocketModeConnectionCount(message);
+		if (activeConnections === void 0 || activeConnections <= 1) return;
+		hasWarned = true;
+		params.onSharedConnection(activeConnections);
+	};
+	emitter.on("ws_message", listener);
+	return () => {
+		emitter.off("ws_message", listener);
+	};
+}
 function waitForSlackSocketDisconnect(app, abortSignal) {
 	return new Promise((resolve) => {
 		const emitter = getSocketEmitter(app);
@@ -3242,7 +3287,7 @@ function shouldSkipOpenClawSlackSelfEvent(args) {
 	if (message?.subtype === "bot_message" && botId && message.bot_id === botId) return true;
 	const event = asOptionalRecord(args.event);
 	if (event?.type === "message" && event.subtype === "message_changed" && event.user === botUserId) return false;
-	const eventsWhichShouldBeKept = new Set(["member_joined_channel", "member_left_channel"]);
+	const eventsWhichShouldBeKept = /* @__PURE__ */ new Set(["member_joined_channel", "member_left_channel"]);
 	return Boolean(botUserId && event && event.user === botUserId && typeof event.type === "string" && !eventsWhichShouldBeKept.has(event.type));
 }
 function createSlackBoltApp(params) {
@@ -3392,6 +3437,7 @@ async function authorizeSlackDirectMessage(params) {
 	if (params.ctx.dmPolicy === "pairing") {
 		await createChannelPairingChallengeIssuer({
 			channel: "slack",
+			accountId: params.accountId,
 			upsertPairingRequest: async ({ id, meta }) => await upsertChannelPairingRequest({
 				channel: "slack",
 				id,
@@ -3494,26 +3540,10 @@ const SLACK_COMMAND_ARG_BUTTON_VALUE_MAX = 2e3;
 const SLACK_COMMAND_ARG_CONFIRM_TEXT_MAX = 300;
 const SLACK_HEADER_TEXT_MAX = 150;
 const SLACK_COMMAND_ARG_ACTION_BLOCKS_MAX = 47;
-let slashCommandsRuntimePromise = null;
-let slashDispatchRuntimePromise = null;
-let slackPluginCommandsRuntimePromise = null;
-let slashSkillCommandsRuntimePromise = null;
-function loadSlashCommandsRuntime() {
-	slashCommandsRuntimePromise ??= import("./slash-commands.runtime-BTTMlmwy.js");
-	return slashCommandsRuntimePromise;
-}
-function loadSlashDispatchRuntime() {
-	slashDispatchRuntimePromise ??= import("./slash-dispatch.runtime-C-1pDqWi.js");
-	return slashDispatchRuntimePromise;
-}
-function loadSlackPluginCommandsRuntime() {
-	slackPluginCommandsRuntimePromise ??= import("./slash-plugin-commands.runtime-Dosfcx3X.js");
-	return slackPluginCommandsRuntimePromise;
-}
-function loadSlashSkillCommandsRuntime() {
-	slashSkillCommandsRuntimePromise ??= import("./slash-skill-commands.runtime-CD1J2ODY.js");
-	return slashSkillCommandsRuntimePromise;
-}
+const loadSlashCommandsRuntime = createLazyRuntimeModule(() => import("./slash-commands.runtime-BTTMlmwy.js"));
+const loadSlashDispatchRuntime = createLazyRuntimeModule(() => import("./slash-dispatch.runtime-Ccm3quU1.js"));
+const loadSlackPluginCommandsRuntime = createLazyRuntimeModule(() => import("./slash-plugin-commands.runtime-Dosfcx3X.js"));
+const loadSlashSkillCommandsRuntime = createLazyRuntimeModule(() => import("./slash-skill-commands.runtime-CD1J2ODY.js"));
 function resolveSlackCommandMenuModelContext(params) {
 	if (!params.sessionKey.trim()) return {};
 	try {
@@ -3892,7 +3922,10 @@ async function registerSlackMonitorSlashCommands(params) {
 					agentId: menuRoute.agentId,
 					sessionKey: menuRoute.sessionKey
 				}) : {};
-				const menuModelCatalog = commandDefinition.key === "think" && menuNeedsModelContext ? await loadModelCatalog({ config: cfg }) : void 0;
+				const menuModelCatalog = commandDefinition.key === "think" && menuNeedsModelContext ? await loadModelCatalog({
+					config: cfg,
+					readOnly: true
+				}) : void 0;
 				const menu = resolveCommandArgMenu({
 					command: commandDefinition,
 					args: commandArgs,
@@ -4083,12 +4116,13 @@ async function registerSlackMonitorSlashCommands(params) {
 			const commandDefinition = slashCommandsRuntime.findCommandByNativeName(command.name, "slack");
 			const rawText = cmd.text?.trim() ?? "";
 			const commandArgs = commandDefinition ? slashCommandsRuntime.parseCommandArgs(commandDefinition, rawText) : rawText ? { raw: rawText } : void 0;
+			const prompt = commandDefinition ? slashCommandsRuntime.buildCommandTextFromArgs(commandDefinition, commandArgs) : rawText ? `/${command.name} ${rawText}` : `/${command.name}`;
 			await handleSlashCommand({
 				command: cmd,
 				ack,
 				respond,
 				body,
-				prompt: commandDefinition ? slashCommandsRuntime.buildCommandTextFromArgs(commandDefinition, commandArgs) : rawText ? `/${command.name} ${rawText}` : `/${command.name}`,
+				prompt,
 				commandArgs,
 				commandDefinition: commandDefinition ?? void 0
 			});
@@ -4188,14 +4222,15 @@ async function registerSlackMonitorSlashCommands(params) {
 			const user = body.user;
 			const userName = user && "name" in user && user.name ? user.name : user && "username" in user && user.username ? user.username : user?.id ?? "";
 			const triggerId = "trigger_id" in body ? body.trigger_id : void 0;
+			const commandPayload = {
+				user_id: user?.id ?? "",
+				user_name: userName,
+				channel_id: body.channel?.id ?? "",
+				channel_name: body.channel?.name ?? body.channel?.id ?? "",
+				trigger_id: triggerId
+			};
 			await handleSlashCommand({
-				command: {
-					user_id: user?.id ?? "",
-					user_name: userName,
-					channel_id: body.channel?.id ?? "",
-					channel_name: body.channel?.name ?? body.channel?.id ?? "",
-					trigger_id: triggerId
-				},
+				command: commandPayload,
 				ack: async () => {},
 				respond: respondFn,
 				body,
@@ -4210,7 +4245,6 @@ async function registerSlackMonitorSlashCommands(params) {
 //#endregion
 //#region extensions/slack/src/monitor/provider.ts
 let slackBoltInterop;
-let slackRelaySourcePromise;
 async function getSlackBoltInterop() {
 	if (!slackBoltInterop) {
 		const slackBoltModule = await import("@slack/bolt");
@@ -4221,10 +4255,7 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
-function loadSlackRelaySource() {
-	slackRelaySourcePromise ??= import("./relay-source-BpBIUaF8.js");
-	return slackRelaySourcePromise;
-}
+const loadSlackRelaySource = createLazyRuntimeModule(() => import("./relay-source-CU1LhyBj.js"));
 const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
 function resolveStableSlackUserIdEntry(raw) {
@@ -4386,6 +4417,12 @@ async function monitorSlackProvider(opts = {}) {
 		}
 	} : null;
 	let unregisterHttpHandler = null;
+	const unregisterSocketModeConnectionDiagnostics = slackMode === "socket" ? registerSlackSocketModeConnectionDiagnostics({
+		app,
+		onSharedConnection: (activeConnections) => {
+			runtime.log?.(warn(formatSlackSocketModeSharedConnectionWarning(activeConnections)));
+		}
+	}) : () => {};
 	let botUserId = "";
 	let botId = "";
 	let teamId = "";
@@ -4393,13 +4430,19 @@ async function monitorSlackProvider(opts = {}) {
 	const expectedApiAppIdFromAppToken = slackMode === "socket" ? parseApiAppIdFromAppToken(appToken) : void 0;
 	let authTestFailed = false;
 	let authTestError;
+	let authIdentityWarning;
 	try {
 		const auth = await app.client.auth.test();
-		botUserId = auth.user_id ?? "";
-		botId = auth.bot_id ?? "";
+		const authUserId = normalizeOptionalString(auth.user_id) ?? "";
+		botId = normalizeOptionalString(auth.bot_id) ?? "";
+		botUserId = botId ? authUserId : "";
 		teamId = auth.team_id ?? "";
 		apiAppId = auth.api_app_id ?? "";
-		if (!botUserId) {
+		authIdentityWarning = formatSlackBotTokenIdentityWarning({
+			auth,
+			accountId: account.accountId
+		});
+		if (!authUserId) {
 			authTestFailed = true;
 			authTestError = "auth.test returned no user_id";
 		}
@@ -4407,7 +4450,8 @@ async function monitorSlackProvider(opts = {}) {
 		authTestFailed = true;
 		authTestError = err instanceof Error ? err.message : String(err);
 	}
-	if (authTestFailed) runtime.log?.(warn(`[${account.accountId}] slack auth.test failed at boot (${authTestError ?? "unknown error"}); explicit bot-mention detection will be disabled until restart with a valid bot token`));
+	if (authTestFailed) runtime.log?.(warn(`[${account.accountId}] slack auth.test failed at boot (${authTestError ?? "unknown error"}); explicit bot-mention detection will be disabled until restart with a valid bot token; required-mention channels will fail closed without another trusted activation signal`));
+	if (authIdentityWarning) runtime.log?.(warn(authIdentityWarning));
 	if (apiAppId && expectedApiAppIdFromAppToken && apiAppId !== expectedApiAppIdFromAppToken) runtime.error?.(`slack token mismatch: bot token api_app_id=${apiAppId} but app token looks like api_app_id=${expectedApiAppIdFromAppToken}`);
 	const ctx = createSlackMonitorContext({
 		cfg,
@@ -4663,6 +4707,7 @@ async function monitorSlackProvider(opts = {}) {
 	} finally {
 		if (slackMode === "relay") setSlackDefaultSendIdentity(account.accountId, void 0);
 		opts.abortSignal?.removeEventListener("abort", stopOnAbort);
+		unregisterSocketModeConnectionDiagnostics();
 		unregisterHttpHandler?.();
 		await gracefulStop();
 	}

package/dist/{relay-source-BpBIUaF8.js → relay-source-CU1LhyBj.js}

@@ -1,11 +1,11 @@
-import { a as SLACK_SOCKET_RECONNECT_POLICY, o as formatUnknownError } from "./provider-DOZHzRWi.js";
+import { a as SLACK_SOCKET_RECONNECT_POLICY, o as formatUnknownError } from "./provider-Cot8h818.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { Buffer } from "node:buffer";
 import { isIP } from "node:net";
 import WebSocket from "ws";
 //#region extensions/slack/src/monitor/relay-source.ts
-const SLACK_RELAY_ROUTE_KINDS = new Set([
+const SLACK_RELAY_ROUTE_KINDS = /* @__PURE__ */ new Set([
 	"user_group",
 	"thread_affinity",
 	"channel_default"

package/dist/{replies-CMZq3Lcb.js → replies-Bbx6pG_B.js}

@@ -1,6 +1,7 @@
-import { a as SLACK_TEXT_LIMIT, t as resolveSlackReplyBlocks } from "./reply-blocks-CfJqf7eq.js";
-import { s as markdownToSlackMrkdwnChunks, t as sendMessageSlack } from "./send-Dg6U9K7_.js";
-import "./provider-DOZHzRWi.js";
+import { a as SLACK_TEXT_LIMIT, t as resolveSlackReplyBlocks } from "./reply-blocks-BGQ6zSqM.js";
+import { r as sendMessageSlack } from "./send-DKDXoeoV.js";
+import { t as markdownToSlackMrkdwnChunks } from "./format-YCNoNkM2.js";
+import "./provider-Cot8h818.js";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";