@openclaw/slack 2026.5.16-beta.2 → 2026.5.16-beta.4

package/dist/{prepare-DSRUr44d.js → prepare-BcznR9ok.js}

@@ -2,11 +2,11 @@ import { l as resolveSlackReplyToMode } from "./accounts-yk5K3wQU.js";
 import { r as parseSlackTarget } from "./target-parsing-CQmv-iSm.js";
 import "./targets-B1tYCAr6.js";
 import { i as normalizeSlackAllowOwnerEntry, o as resolveSlackAllowListMatch, r as normalizeAllowListLower } from "./allow-list-nwXs_eCP.js";
-import { i as hasSlackThreadParticipationWithPersistence, t as sendMessageSlack } from "./send-CxXFbqN1.js";
-import { _ as resolveSlackThreadStarter, g as resolveSlackThreadHistory, l as reactSlackMessage, y as formatSlackFileReference } from "./actions-BCRbHv1Q.js";
+import { i as hasSlackThreadParticipationWithPersistence, t as sendMessageSlack } from "./send-C5PzphgC.js";
+import { _ as resolveSlackThreadStarter, g as resolveSlackThreadHistory, l as reactSlackMessage, y as formatSlackFileReference } from "./actions-Chs6DbrP.js";
 import { t as formatSlackError } from "./errors-C_sW0Zgl.js";
-import { b as readSessionUpdatedAt, c as authorizeSlackBotRoomMessage, d as resolveSlackEffectiveAllowFrom, g as resolveSlackChannelConfig, h as resolveSlackChatType, k as stripSlackMentionsForCommandDetection, m as normalizeSlackChannelType, n as authorizeSlackDirectMessage, o as resolveConversationLabel$1, t as resolveSlackRoomContextHints, u as resolveSlackCommandIngress, w as resolveStorePath, x as resolveChannelContextVisibilityMode } from "./room-context-Cd8jFpS-.js";
-import "./send.runtime-BHCPpSj_.js";
+import { C as resolveChannelContextVisibilityMode, E as resolveStorePath, S as readSessionUpdatedAt, _ as resolveSlackChatType, c as authorizeSlackBotRoomMessage, d as resolveSlackEffectiveAllowFrom, f as buildSlackAssistantThreadMetadata, g as normalizeSlackChannelType, j as stripSlackMentionsForCommandDetection, m as parseSlackAssistantThreadMetadata, n as authorizeSlackDirectMessage, o as resolveConversationLabel$1, t as resolveSlackRoomContextHints, u as resolveSlackCommandIngress, v as resolveSlackChannelConfig } from "./room-context-BI26wVBb.js";
+import "./send.runtime-DsEXD6MR.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
 import { resolveChannelMessageSourceReplyDeliveryMode } from "openclaw/plugin-sdk/channel-message";
@@ -15,10 +15,11 @@ import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute, resolveRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-runtime";
 import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { buildChannelTurnContext, buildMentionRegexes, formatInboundEnvelope, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, resolveEnvelopeFormatOptions, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
+import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, formatInboundEnvelope, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, resolveEnvelopeFormatOptions, resolveUnmentionedGroupInboundPolicy, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist, shouldIncludeSupplementalContext } from "openclaw/plugin-sdk/security-runtime";
 import { resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
+import { isAbortRequestText } from "openclaw/plugin-sdk/command-primitives-runtime";
 import { shouldHandleTextCommands } from "openclaw/plugin-sdk/command-surface";
 import { recordDroppedChannelTurnHistory } from "openclaw/plugin-sdk/inbound-reply-dispatch";
 import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
@@ -29,7 +30,7 @@ const SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE = 20;
 const SLACK_USER_MENTION_RE$1 = /<@([A-Z0-9]+)(?:\|[^>]+)?>/gi;
 let slackMediaModulePromise$1;
 function loadSlackMediaModule$1() {
-	slackMediaModulePromise$1 ??= import("./actions-BCRbHv1Q.js").then((n) => n.h);
+	slackMediaModulePromise$1 ??= import("./actions-Chs6DbrP.js").then((n) => n.h);
 	return slackMediaModulePromise$1;
 }
 function collectUniqueSlackMentionIds$1(texts) {
@@ -442,7 +443,7 @@ function resolveSlackInitialAgentRoute(params) {
 	});
 }
 function resolveSlackRoutingContext(params) {
-	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, seedTopLevelRoomThread } = params;
+	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, seedTopLevelRoomThread, assistantThreadTs } = params;
 	let route = resolveSlackInitialAgentRoute({
 		ctx,
 		account,
@@ -460,17 +461,18 @@ function resolveSlackRoutingContext(params) {
 	const isThreadReply = threadContext.isThreadReply;
 	const autoThreadId = !isThreadReply && replyToMode === "all" && threadContext.messageTs ? threadContext.messageTs : void 0;
 	const seedCandidateThreadId = threadContext.incomingThreadTs ?? threadContext.messageTs;
-	const routedThreadId = (isDirectMessage ? isThreadReply ? threadTs : void 0 : isRoomish ? isThreadReply && threadTs ? threadTs : void 0 : isThreadReply ? threadTs : autoThreadId) ?? (isRoomish ? !isThreadReply && isRoom && seedTopLevelRoomThread && replyToMode !== "off" && seedCandidateThreadId ? seedCandidateThreadId : void 0 : void 0);
+	const routedThreadId = (isDirectMessage ? assistantThreadTs : isRoomish ? isThreadReply && threadTs ? threadTs : void 0 : isThreadReply ? threadTs : autoThreadId) ?? (isRoomish ? !isThreadReply && isRoom && seedTopLevelRoomThread && replyToMode !== "off" && seedCandidateThreadId ? seedCandidateThreadId : void 0 : void 0);
 	const baseConversationId = resolveSlackBaseConversationId({
 		message,
 		isDirectMessage
 	});
-	const boundThreadRoute = routedThreadId ? resolveRuntimeConversationBindingRoute({
+	const runtimeBindingThreadId = routedThreadId ?? (isDirectMessage && isThreadReply ? threadTs : void 0);
+	const boundThreadRoute = runtimeBindingThreadId ? resolveRuntimeConversationBindingRoute({
 		route,
 		conversation: {
 			channel: "slack",
 			accountId: account.accountId,
-			conversationId: routedThreadId,
+			conversationId: runtimeBindingThreadId,
 			parentConversationId: baseConversationId
 		}
 	}) : null;
@@ -576,7 +578,7 @@ function formatSlackBotStarterThreadLabel(params) {
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
 let slackMediaModulePromise;
 function loadSlackMediaModule() {
-	slackMediaModulePromise ??= import("./actions-BCRbHv1Q.js").then((n) => n.h);
+	slackMediaModulePromise ??= import("./actions-Chs6DbrP.js").then((n) => n.h);
 	return slackMediaModulePromise;
 }
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
@@ -686,7 +688,7 @@ async function resolveSlackThreadContextData(params) {
 		logVerbose("slack: retained current-bot thread starter as assistant root context");
 	}
 	const threadInitialHistoryLimit = params.account.config?.thread?.initialHistoryLimit ?? 20;
-	if (threadInitialHistoryLimit > 0 && !threadSessionPreviousTimestamp) {
+	if (threadInitialHistoryLimit > 0 && (!threadSessionPreviousTimestamp || params.forceInitialHistory)) {
 		const currentBotRootTs = starter?.ts ?? params.threadTs;
 		const threadHistoryWithBotRoot = ensureSlackThreadHistoryHasBotRoot({
 			history: await resolveSlackThreadHistory({
@@ -848,6 +850,76 @@ const SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS = 4;
 const SLACK_HISTORY_MEDIA_MAX_BYTES = 10 * 1024 * 1024;
 const SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS = 1e3;
 const SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS = 3e3;
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function recordString(record, key) {
+	return normalizeOptionalString(record?.[key]);
+}
+function recordNullableString(record, key) {
+	if (!record || !(key in record)) return;
+	if (record[key] === null) return null;
+	return normalizeOptionalString(record[key]);
+}
+function mergeSlackAssistantThreadContext(primary, fallback) {
+	if (!primary) return fallback;
+	if (!fallback) return primary;
+	return {
+		assistantChannelId: primary.assistantChannelId || fallback.assistantChannelId,
+		threadTs: primary.threadTs || fallback.threadTs,
+		userId: primary.userId ?? fallback.userId,
+		channelId: primary.channelId ?? fallback.channelId,
+		teamId: primary.teamId ?? fallback.teamId,
+		enterpriseId: primary.enterpriseId !== void 0 ? primary.enterpriseId : fallback.enterpriseId
+	};
+}
+function hasSlackAssistantThreadMetadata(context) {
+	return Boolean(context?.channelId || context?.teamId || context?.enterpriseId !== void 0);
+}
+function resolveSlackMessageAssistantThreadContext(message) {
+	const thread = asRecord(message.assistant_thread);
+	if (!thread) return;
+	const context = asRecord(thread.context);
+	const assistantChannelId = recordString(thread, "channel_id") ?? message.channel;
+	const threadTs = recordString(thread, "thread_ts") ?? message.thread_ts ?? message.ts;
+	if (!assistantChannelId || !threadTs) return;
+	return {
+		assistantChannelId,
+		threadTs,
+		userId: recordString(thread, "user_id") ?? message.user,
+		channelId: recordString(context, "channel_id"),
+		teamId: recordString(context, "team_id"),
+		enterpriseId: recordNullableString(context, "enterprise_id")
+	};
+}
+async function restoreSlackAssistantThreadContextFromMetadata(params) {
+	const threadTs = params.message.thread_ts;
+	const parentUserId = params.message.parent_user_id?.trim();
+	if (!params.message.channel || !threadTs || !parentUserId || parentUserId !== params.ctx.botUserId && parentUserId !== params.ctx.botId) return;
+	try {
+		const response = await params.ctx.app.client.conversations.replies({
+			channel: params.message.channel,
+			ts: threadTs,
+			oldest: threadTs,
+			include_all_metadata: true,
+			limit: 4
+		});
+		for (const message of response.messages ?? []) {
+			const context = parseSlackAssistantThreadMetadata(message.metadata);
+			if (!context) continue;
+			return {
+				assistantChannelId: params.message.channel,
+				threadTs,
+				userId: params.message.user,
+				channelId: context.channelId,
+				teamId: context.teamId,
+				enterpriseId: context.enterpriseId
+			};
+		}
+	} catch (err) {
+		logVerbose(`slack assistant context restore failed channel=${params.message.channel} ts=${threadTs}: ${formatErrorMessage(err)}`);
+	}
+}
 function resolveCachedMentionRegexes(ctx, agentId) {
 	const key = normalizeOptionalString(agentId) ?? "__default__";
 	let byAgent = mentionRegexCache.get(ctx);
@@ -1092,7 +1164,19 @@ async function prepareSlackMessage(params) {
 		source: opts.source
 	});
 	const channelRequireMention = channelConfig?.requireMention ?? ctx.defaultRequireMention ?? true;
-	const willImplicitlyThreadReply = isRoom && !channelRequireMention && resolveSlackReplyToMode(account, isDirectMessage ? "direct" : isGroupDm ? "group" : "channel") !== "off";
+	const channelChatType = isDirectMessage ? "direct" : isGroupDm ? "group" : "channel";
+	const messageAssistantThreadContext = resolveSlackMessageAssistantThreadContext(message);
+	const assistantContextLookupChannelId = messageAssistantThreadContext?.assistantChannelId ?? message.channel;
+	const assistantContextLookupThreadTs = messageAssistantThreadContext?.threadTs ?? message.thread_ts ?? message.ts;
+	const cachedAssistantThreadContext = isDirectMessage ? ctx.getSlackAssistantThreadContext(assistantContextLookupChannelId, assistantContextLookupThreadTs) : void 0;
+	const restoredAssistantThreadContext = isDirectMessage && !cachedAssistantThreadContext && !hasSlackAssistantThreadMetadata(messageAssistantThreadContext) ? await restoreSlackAssistantThreadContextFromMetadata({
+		ctx,
+		message
+	}) : void 0;
+	const assistantThreadContext = mergeSlackAssistantThreadContext(messageAssistantThreadContext, cachedAssistantThreadContext ?? restoredAssistantThreadContext);
+	const assistantThreadContextToCache = messageAssistantThreadContext || restoredAssistantThreadContext ? assistantThreadContext : void 0;
+	if (assistantThreadContextToCache) ctx.saveSlackAssistantThreadContext(assistantThreadContextToCache);
+	const willImplicitlyThreadReply = isRoom && !channelRequireMention && resolveSlackReplyToMode(account, channelChatType) !== "off";
 	const seedTopLevelRoomThreadBySource = opts.source === "app_mention" || opts.wasMentioned === true || explicitlyMentioned || willImplicitlyThreadReply;
 	let routing = resolveSlackRoutingContext({
 		ctx,
@@ -1102,7 +1186,8 @@ async function prepareSlackMessage(params) {
 		isGroupDm,
 		isRoom,
 		isRoomish,
-		seedTopLevelRoomThread: seedTopLevelRoomThreadBySource
+		seedTopLevelRoomThread: seedTopLevelRoomThreadBySource,
+		assistantThreadTs: assistantThreadContext?.threadTs
 	});
 	const resolveWasMentioned = (mentionRegexes) => opts.wasMentioned ?? (!isDirectMessage && matchesMentionWithExplicit({
 		text: messageText,
@@ -1125,7 +1210,8 @@ async function prepareSlackMessage(params) {
 			isGroupDm,
 			isRoom,
 			isRoomish,
-			seedTopLevelRoomThread: true
+			seedTopLevelRoomThread: true,
+			assistantThreadTs: assistantThreadContext?.threadTs
 		});
 		mentionRegexes = resolveCachedMentionRegexes(ctx, routing.route.agentId);
 		wasMentioned = resolveWasMentioned(mentionRegexes);
@@ -1150,6 +1236,7 @@ async function prepareSlackMessage(params) {
 			return null;
 		}
 	}
+	const directThreadRoutedToDmSession = !assistantThreadContext && isDirectMessage && isThreadReply && threadTs && runtimeBinding?.conversation.conversationId !== threadTs;
 	let implicitMentionKinds = [];
 	if (!isDirectMessage && ctx.botUserId && message.thread_ts && !ctx.threadRequireExplicitMention && !wasMentioned) {
 		const replyToBotKinds = implicitMentionKindWhen("reply_to_bot", message.parent_user_id === ctx.botUserId);
@@ -1189,6 +1276,7 @@ async function prepareSlackMessage(params) {
 	const canDetectMention = Boolean(ctx.botUserId) || mentionRegexes.length > 0;
 	const textForCommandDetection = stripSlackMentionsForCommandDetection(message.text ?? "");
 	const hasControlCommandInMessage = hasControlCommand(textForCommandDetection, cfg);
+	const hasAbortRequest = isAbortRequestText(textForCommandDetection);
 	const channelUsersAllowlistConfigured = isRoom && Array.isArray(channelConfig?.users) && channelConfig.users.length > 0;
 	const messageIngress = await resolveSlackCommandIngress({
 		ctx,
@@ -1330,6 +1418,16 @@ async function prepareSlackMessage(params) {
 	if (!resolvedMessageContent) return null;
 	const { rawBody, effectiveDirectMedia } = resolvedMessageContent;
 	const chatType = resolveSlackChatType(conversation.resolvedChannelType);
+	const inboundEventKind = classifyChannelInboundEvent({
+		conversation: { kind: chatType },
+		unmentionedGroupPolicy: resolveUnmentionedGroupInboundPolicy({
+			cfg,
+			agentId: route.agentId
+		}),
+		wasMentioned: effectiveWasMentioned,
+		hasControlCommand: hasControlCommandInMessage,
+		hasAbortRequest
+	});
 	const ackReaction = resolveAckReaction(cfg, route.agentId, {
 		channel: "slack",
 		accountId: account.accountId
@@ -1337,7 +1435,10 @@ async function prepareSlackMessage(params) {
 	const ackReactionValue = ackReaction ?? "";
 	const sourceRepliesAreToolOnly = resolveChannelMessageSourceReplyDeliveryMode({
 		cfg,
-		ctx: { ChatType: chatType }
+		ctx: {
+			ChatType: chatType,
+			InboundEventKind: inboundEventKind
+		}
 	}) === "message_tool_only";
 	const statusReactionsExplicitlyEnabled = cfg.messages?.statusReactions?.enabled === true;
 	const shouldAckReaction$1 = () => Boolean(ackReaction && shouldAckReaction({
@@ -1446,6 +1547,7 @@ async function prepareSlackMessage(params) {
 		roomLabel,
 		storePath,
 		sessionKey,
+		forceInitialHistory: Boolean(directThreadRoutedToDmSession),
 		allowFromLower: threadContextAllowFromLower,
 		allowNameMatching: ctx.allowNameMatching,
 		contextVisibilityMode,
@@ -1458,7 +1560,9 @@ async function prepareSlackMessage(params) {
 		limit: ctx.historyLimit
 	}) : dmHistoryContext.inboundHistory;
 	const commandBody = textForCommandDetection.trim();
-	const ctxPayload = buildChannelTurnContext({
+	const supplementalThreadHistoryBody = directThreadRoutedToDmSession && !threadHistoryBody ? threadStarterBody : threadHistoryBody;
+	const effectiveMessageThreadId = assistantThreadContext?.threadTs ?? threadContext.messageThreadId;
+	const ctxPayload = buildChannelInboundEventContext({
 		channel: "slack",
 		provider: "slack",
 		surface: "slack",
@@ -1476,7 +1580,7 @@ async function prepareSlackMessage(params) {
 			id: message.channel,
 			label: envelopeFrom,
 			spaceId: ctx.teamId || void 0,
-			threadId: threadContext.messageThreadId,
+			threadId: directThreadRoutedToDmSession ? void 0 : effectiveMessageThreadId,
 			nativeChannelId: message.channel,
 			routePeer: {
 				kind: chatType,
@@ -1493,10 +1597,11 @@ async function prepareSlackMessage(params) {
 			to: slackTo,
 			originatingTo: slackTo,
 			replyToId: threadContext.replyToId,
-			messageThreadId: threadContext.messageThreadId,
+			messageThreadId: directThreadRoutedToDmSession ? void 0 : effectiveMessageThreadId,
 			nativeChannelId: message.channel
 		},
 		message: {
+			inboundEventKind,
 			body: combinedBody,
 			bodyForAgent: rawBody,
 			rawBody,
@@ -1523,16 +1628,21 @@ async function prepareSlackMessage(params) {
 		media: toInboundMediaFacts(effectiveMedia),
 		supplemental: {
 			thread: {
-				starterBody: !threadSessionPreviousTimestamp ? threadStarterBody : void 0,
-				historyBody: threadHistoryBody,
-				label: threadLabel
+				starterBody: !directThreadRoutedToDmSession && !threadSessionPreviousTimestamp ? threadStarterBody : void 0,
+				historyBody: supplementalThreadHistoryBody,
+				label: directThreadRoutedToDmSession ? void 0 : threadLabel
 			},
 			groupSystemPrompt
 		},
 		extra: {
 			GroupSubject: isRoomish ? roomLabel : void 0,
 			UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : void 0,
-			IsFirstThreadTurn: isThreadReply && threadTs && !threadSessionPreviousTimestamp ? true : void 0,
+			TransportThreadId: directThreadRoutedToDmSession ? threadContext.messageThreadId : void 0,
+			SlackAssistantThread: assistantThreadContext ? true : void 0,
+			SlackAssistantThreadContextChannelId: assistantThreadContext?.channelId,
+			SlackAssistantThreadContextTeamId: assistantThreadContext?.teamId,
+			SlackAssistantThreadContextEnterpriseId: assistantThreadContext?.enterpriseId ?? void 0,
+			IsFirstThreadTurn: isThreadReply && threadTs && !directThreadRoutedToDmSession && !threadSessionPreviousTimestamp ? true : void 0,
 			...buildSlackMentionContextPayload({
 				isRoomish,
 				effectiveWasMentioned,
@@ -1581,7 +1691,7 @@ async function prepareSlackMessage(params) {
 					channel: "slack",
 					to: `user:${message.user}`,
 					accountId: route.accountId,
-					threadId: threadContext.messageThreadId,
+					threadId: effectiveMessageThreadId,
 					mainDmOwnerPin: pinnedMainDmOwner && message.user ? {
 						ownerRecipient: pinnedMainDmOwner,
 						senderRecipient: normalizeLowercaseStringOrEmpty(message.user),
@@ -1606,6 +1716,8 @@ async function prepareSlackMessage(params) {
 			} : void 0
 		},
 		replyToMode,
+		...assistantThreadContext?.threadTs ? { forcedReplyThreadTs: assistantThreadContext.threadTs } : {},
+		...assistantThreadContext ? { slackMessageMetadata: buildSlackAssistantThreadMetadata(assistantThreadContext) } : {},
 		requireMention: shouldRequireMention,
 		isDirectMessage,
 		isRoomish,

package/dist/{prepare.test-helpers-CU1qB54Q.js → prepare.test-helpers-D807wdul.js}

@@ -1,4 +1,4 @@
-import { f as createSlackMonitorContext } from "./room-context-Cd8jFpS-.js";
+import { p as createSlackMonitorContext } from "./room-context-BI26wVBb.js";
 import "openclaw/plugin-sdk/temp-path";
 //#region extensions/slack/src/monitor/message-handler/prepare.test-helpers.ts
 function createInboundSlackTestContext(params) {

package/dist/{provider-bKg1hkf5.js → provider-BFnE2bgI.js}

@@ -8,7 +8,7 @@ import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath } from ".
 import { t as formatSlackError } from "./errors-C_sW0Zgl.js";
 import { t as resolveSlackChannelAllowlist } from "./resolve-channels-B_eKaOkE.js";
 import { t as resolveSlackUserAllowlist } from "./resolve-users-BzBAJwvq.js";
-import { C as resolveOpenProviderRuntimeGroupPolicy, D as buildSlackSlashCommandMatcher, E as warnMissingProviderGroupPolicyFallbackOnce, O as resolveSlackSlashCommandConfig, S as resolveDefaultGroupPolicy, _ as resolveSlackChannelLabel, d as resolveSlackEffectiveAllowFrom, f as createSlackMonitorContext, g as resolveSlackChannelConfig, h as resolveSlackChatType, i as parsePluginBindingApprovalCustomId, k as stripSlackMentionsForCommandDetection, l as authorizeSlackSystemEventSender, m as normalizeSlackChannelType, n as authorizeSlackDirectMessage, p as isSlackChannelAllowedByPolicy, r as buildPluginBindingResolvedText, s as resolvePluginConversationBindingApproval, t as resolveSlackRoomContextHints, u as resolveSlackCommandIngress, v as getRuntimeConfig$1, y as isDangerousNameMatchingEnabled } from "./room-context-Cd8jFpS-.js";
+import { A as resolveSlackSlashCommandConfig, O as warnMissingProviderGroupPolicyFallbackOnce, T as resolveOpenProviderRuntimeGroupPolicy, _ as resolveSlackChatType, b as getRuntimeConfig$1, d as resolveSlackEffectiveAllowFrom, f as buildSlackAssistantThreadMetadata, g as normalizeSlackChannelType, h as isSlackChannelAllowedByPolicy, i as parsePluginBindingApprovalCustomId, j as stripSlackMentionsForCommandDetection, k as buildSlackSlashCommandMatcher, l as authorizeSlackSystemEventSender, n as authorizeSlackDirectMessage, p as createSlackMonitorContext, r as buildPluginBindingResolvedText, s as resolvePluginConversationBindingApproval, t as resolveSlackRoomContextHints, u as resolveSlackCommandIngress, v as resolveSlackChannelConfig, w as resolveDefaultGroupPolicy, x as isDangerousNameMatchingEnabled, y as resolveSlackChannelLabel } from "./room-context-BI26wVBb.js";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeAccountId, normalizeMainKey } from "openclaw/plugin-sdk/routing";
@@ -37,6 +37,112 @@ import { requestHeartbeat } from "openclaw/plugin-sdk/heartbeat-runtime";
 import { createInteractiveConversationBindingHelpers, dispatchPluginInteractiveHandler } from "openclaw/plugin-sdk/plugin-runtime";
 import { createChannelInboundDebouncer, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
 import { generateSecureToken } from "openclaw/plugin-sdk/secure-random-runtime";
+//#region extensions/slack/src/monitor/events/assistant.ts
+const DEFAULT_ASSISTANT_PROMPTS = [
+	{
+		title: "What can you do?",
+		message: "What can you help me with?"
+	},
+	{
+		title: "Summarize this channel",
+		message: "Summarize the recent activity in this channel."
+	},
+	{
+		title: "Draft a reply",
+		message: "Help me draft a reply."
+	}
+];
+function normalizeAssistantThread(event, getPrevious) {
+	const thread = event.assistant_thread;
+	if (!thread) return null;
+	const channelId = thread.channel_id?.trim();
+	const threadTs = thread.thread_ts?.trim();
+	if (!channelId || !threadTs) return null;
+	const previous = getPrevious?.(channelId, threadTs);
+	const threadContext = thread.context;
+	const eventContext = event.context;
+	const resolveContextString = (key, previousValue) => threadContext?.[key]?.trim() || eventContext?.[key]?.trim() || previousValue;
+	const enterpriseId = (() => {
+		if (threadContext && "enterprise_id" in threadContext) return threadContext.enterprise_id === null ? null : threadContext.enterprise_id?.trim() || previous?.enterpriseId;
+		if (eventContext && "enterprise_id" in eventContext) return eventContext.enterprise_id === null ? null : eventContext.enterprise_id?.trim() || previous?.enterpriseId;
+		return previous?.enterpriseId;
+	})();
+	return {
+		assistantChannelId: channelId,
+		threadTs,
+		userId: thread.user_id?.trim() || previous?.userId,
+		channelId: resolveContextString("channel_id", previous?.channelId),
+		teamId: resolveContextString("team_id", previous?.teamId),
+		enterpriseId
+	};
+}
+async function persistAssistantThreadMetadata(params) {
+	const { ctx, assistantThread } = params;
+	try {
+		const initialMessage = ((await ctx.app.client.conversations.replies({
+			token: ctx.botToken,
+			channel: assistantThread.assistantChannelId,
+			ts: assistantThread.threadTs,
+			oldest: assistantThread.threadTs,
+			include_all_metadata: true,
+			limit: 4
+		})).messages ?? []).find((message) => !message.subtype && message.user === ctx.botUserId && message.ts);
+		if (!initialMessage?.ts) return;
+		await ctx.app.client.chat.update({
+			token: ctx.botToken,
+			channel: assistantThread.assistantChannelId,
+			ts: initialMessage.ts,
+			text: initialMessage.text ?? "",
+			blocks: Array.isArray(initialMessage.blocks) ? initialMessage.blocks : [],
+			metadata: buildSlackAssistantThreadMetadata(assistantThread)
+		});
+	} catch (err) {
+		logVerbose(`slack assistant thread metadata persist failed for channel ${assistantThread.assistantChannelId}: ${formatErrorMessage(err)}`);
+	}
+}
+function registerSlackAssistantEvents(params) {
+	const { ctx, trackEvent } = params;
+	const slackApp = ctx.app;
+	slackApp.event("assistant_thread_started", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
+			const assistantThread = normalizeAssistantThread(event, ctx.getSlackAssistantThreadContext);
+			if (!assistantThread) {
+				logVerbose("slack assistant_thread_started dropped: missing assistant thread channel/thread");
+				return;
+			}
+			ctx.saveSlackAssistantThreadContext(assistantThread);
+			await ctx.setSlackAssistantSuggestedPrompts({
+				channelId: assistantThread.assistantChannelId,
+				threadTs: assistantThread.threadTs,
+				title: "Try asking",
+				prompts: DEFAULT_ASSISTANT_PROMPTS
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack assistant_thread_started handler failed: ${formatErrorMessage(err)}`));
+		}
+	});
+	slackApp.event("assistant_thread_context_changed", async ({ event, body }) => {
+		try {
+			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
+			const assistantThread = normalizeAssistantThread(event, ctx.getSlackAssistantThreadContext);
+			if (!assistantThread) {
+				logVerbose("slack assistant_thread_context_changed dropped: missing assistant thread channel/thread");
+				return;
+			}
+			ctx.saveSlackAssistantThreadContext(assistantThread);
+			await persistAssistantThreadMetadata({
+				ctx,
+				assistantThread
+			});
+		} catch (err) {
+			ctx.runtime.error?.(danger(`slack assistant_thread_context_changed handler failed: ${formatErrorMessage(err)}`));
+		}
+	});
+}
+//#endregion
 //#region extensions/slack/src/channel-migration.ts
 function resolveAccountChannels(cfg, accountId) {
 	if (!accountId) return {};
@@ -1418,7 +1524,10 @@ function resolveAssistantMessageChangedInbound(params) {
 		message,
 		botUserId: params.ctx.botUserId
 	});
-	if (!senderId) return;
+	if (!senderId) {
+		if (shouldLogVerbose()) logVerbose(`slack: assistant_app_thread message_changed in DM channel=${changed.channel} dropped: no sender resolved from metadata`);
+		return;
+	}
 	return {
 		type: "message",
 		channel: changed.channel ?? params.event.channel,
@@ -1428,6 +1537,7 @@ function resolveAssistantMessageChangedInbound(params) {
 		ts: asString(message.ts) ?? asString(changed.event_ts),
 		thread_ts: asString(message.thread_ts),
 		event_ts: changed.event_ts,
+		assistant_thread: asRecord$1(message.assistant_thread) ?? asRecord$1(changed.assistant_thread),
 		files: Array.isArray(message.files) ? message.files : void 0,
 		attachments: Array.isArray(message.attachments) ? message.attachments : void 0
 	};
@@ -1642,6 +1752,10 @@ function registerSlackMonitorEvents(params) {
 		ctx: params.ctx,
 		trackEvent: params.trackEvent
 	});
+	registerSlackAssistantEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/debounce-key.ts
@@ -1761,7 +1875,7 @@ function createSlackThreadTsResolver(params) {
 //#region extensions/slack/src/monitor/message-handler.ts
 let slackMessagePipelinePromise;
 function loadSlackMessagePipeline() {
-	slackMessagePipelinePromise ??= import("./pipeline.runtime-CakcaQh9.js");
+	slackMessagePipelinePromise ??= import("./pipeline.runtime-Bq754VH8.js");
 	return slackMessagePipelinePromise;
 }
 const APP_MENTION_RETRY_TTL_MS = 6e4;
@@ -2303,7 +2417,7 @@ function loadSlashCommandsRuntime() {
 	return slashCommandsRuntimePromise;
 }
 function loadSlashDispatchRuntime() {
-	slashDispatchRuntimePromise ??= import("./slash-dispatch.runtime-Cg7uU92H.js");
+	slashDispatchRuntimePromise ??= import("./slash-dispatch.runtime-CcbE1HtP.js");
 	return slashDispatchRuntimePromise;
 }
 function loadSlackPluginCommandsRuntime() {

package/dist/{replies-Fg1T3ZzU.js → replies-2ve_YcHy.js}

@@ -1,7 +1,7 @@
 import { t as resolveSlackReplyBlocks } from "./reply-blocks-BFaJ_ejG.js";
 import { o as SLACK_TEXT_LIMIT } from "./thread-ts-As_dcNbD.js";
-import { o as markdownToSlackMrkdwnChunks, t as sendMessageSlack } from "./send-CxXFbqN1.js";
-import "./send.runtime-BHCPpSj_.js";
+import { o as markdownToSlackMrkdwnChunks, t as sendMessageSlack } from "./send-C5PzphgC.js";
+import "./send.runtime-DsEXD6MR.js";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
 import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";
 import { deliverTextOrMediaReply, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
@@ -32,7 +32,8 @@ async function deliverReplies(params) {
 				threadTs,
 				accountId: params.accountId,
 				...slackBlocks?.length ? { blocks: slackBlocks } : {},
-				...params.identity ? { identity: params.identity } : {}
+				...params.identity ? { identity: params.identity } : {},
+				...params.metadata ? { metadata: params.metadata } : {}
 			});
 			params.runtime.log?.(`delivered reply to ${params.target}`);
 			continue;
@@ -51,7 +52,8 @@ async function deliverReplies(params) {
 					token: params.token,
 					threadTs,
 					accountId: params.accountId,
-					...params.identity ? { identity: params.identity } : {}
+					...params.identity ? { identity: params.identity } : {},
+					...params.metadata ? { metadata: params.metadata } : {}
 				});
 			},
 			sendMedia: async ({ mediaUrl, caption }) => {
@@ -61,7 +63,8 @@ async function deliverReplies(params) {
 					mediaUrl,
 					threadTs,
 					accountId: params.accountId,
-					...params.identity ? { identity: params.identity } : {}
+					...params.identity ? { identity: params.identity } : {},
+					...params.metadata ? { metadata: params.metadata } : {}
 				});
 			}
 		}) !== "empty") params.runtime.log?.(`delivered reply to ${params.target}`);