@openclaw/slack 2026.5.14-beta.2 → 2026.5.16-beta.1

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

@@ -2,25 +2,26 @@ 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-Dg9zcyYT.js";
-import { _ as resolveSlackThreadStarter, g as resolveSlackThreadHistory, l as reactSlackMessage, y as formatSlackFileReference } from "./actions-BibhOXpJ.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 { 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-CjjQ9StM.js";
+import "./send.runtime-BHCPpSj_.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";
 import { logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute, resolveRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-runtime";
-import { buildPendingHistoryContextFromMap, recordPendingHistoryEntryIfEnabled } from "openclaw/plugin-sdk/reply-history";
+import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { buildMentionRegexes, formatInboundEnvelope, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, resolveEnvelopeFormatOptions } from "openclaw/plugin-sdk/channel-inbound";
+import { buildChannelTurnContext, buildMentionRegexes, formatInboundEnvelope, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, resolveEnvelopeFormatOptions, 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 { shouldHandleTextCommands } from "openclaw/plugin-sdk/command-surface";
-import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
+import { recordDroppedChannelTurnHistory } from "openclaw/plugin-sdk/inbound-reply-dispatch";
+import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
 import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 //#region extensions/slack/src/monitor/message-handler/prepare-content.ts
 const SLACK_MENTION_RESOLUTION_CONCURRENCY = 4;
@@ -28,7 +29,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-BibhOXpJ.js").then((n) => n.h);
+	slackMediaModulePromise$1 ??= import("./actions-BCRbHv1Q.js").then((n) => n.h);
 	return slackMediaModulePromise$1;
 }
 function collectUniqueSlackMentionIds$1(texts) {
@@ -190,13 +191,19 @@ async function resolveSlackMessageContent(params) {
 		files: ownFiles,
 		client: params.client,
 		token: params.botToken,
-		maxBytes: params.mediaMaxBytes
+		maxBytes: params.mediaMaxBytes,
+		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
+		totalTimeoutMs: params.mediaTotalTimeoutMs,
+		abortSignal: params.abortSignal
 	})) : Promise.resolve(null);
 	const attachmentContentPromise = params.message.attachments && params.message.attachments.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
 		attachments: params.message.attachments,
 		client: params.client,
 		token: params.botToken,
-		maxBytes: params.mediaMaxBytes
+		maxBytes: params.mediaMaxBytes,
+		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
+		totalTimeoutMs: params.mediaTotalTimeoutMs,
+		abortSignal: params.abortSignal
 	})) : Promise.resolve(null);
 	const [media, attachmentContent] = await Promise.all([mediaPromise, attachmentContentPromise]);
 	const mergedMedia = [...media ?? [], ...attachmentContent?.media ?? []];
@@ -569,7 +576,7 @@ function formatSlackBotStarterThreadLabel(params) {
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
 let slackMediaModulePromise;
 function loadSlackMediaModule() {
-	slackMediaModulePromise ??= import("./actions-BibhOXpJ.js").then((n) => n.h);
+	slackMediaModulePromise ??= import("./actions-BCRbHv1Q.js").then((n) => n.h);
 	return slackMediaModulePromise;
 }
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
@@ -837,6 +844,10 @@ const SLACK_ANY_MENTION_RE = /<@[^>]+>|<!subteam\^[^>]+>/;
 const SLACK_USER_MENTION_RE = /<@([^>|]+)(?:\|[^>]+)?>/g;
 const SLACK_SUBTEAM_MENTION_RE = /<!subteam\^([^>|]+)(?:\|[^>]+)?>/g;
 const SLACK_SUBTEAM_MENTION_MARKER = "<!subteam^";
+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 resolveCachedMentionRegexes(ctx, agentId) {
 	const key = normalizeOptionalString(agentId) ?? "__default__";
 	let byAgent = mentionRegexCache.get(ctx);
@@ -850,6 +861,60 @@ function resolveCachedMentionRegexes(ctx, agentId) {
 	byAgent.set(key, built);
 	return built;
 }
+function isSlackImageFileCandidate(file) {
+	if ((file.mimetype?.split(";")[0]?.trim().toLowerCase())?.startsWith("image/")) return true;
+	return Boolean(mimeTypeFromFilePath(file.name)?.startsWith("image/"));
+}
+function sliceSlackImageFileCandidates(files, limit) {
+	if (limit <= 0 || !files?.length) return [];
+	return files.filter(isSlackImageFileCandidate).slice(0, limit);
+}
+function sliceSlackHistoryAttachmentCandidates(attachments, limit) {
+	if (limit <= 0 || !attachments?.length) return [];
+	const out = [];
+	let remaining = limit;
+	for (const attachment of attachments) {
+		if (attachment.is_share !== true) continue;
+		const hasImageUrl = Boolean(normalizeOptionalString(attachment.image_url));
+		const files = sliceSlackImageFileCandidates(attachment.files, remaining - (hasImageUrl ? 1 : 0));
+		if (!hasImageUrl && files.length === 0) continue;
+		out.push({
+			...attachment,
+			files
+		});
+		remaining -= (hasImageUrl ? 1 : 0) + files.length;
+		if (remaining <= 0) break;
+	}
+	return out;
+}
+function buildSlackHistoryMediaCandidateMessage(message) {
+	const files = sliceSlackImageFileCandidates(message.files, SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS);
+	const attachments = sliceSlackHistoryAttachmentCandidates(message.attachments, Math.max(0, SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS - files.length));
+	if (files.length === 0 && attachments.length === 0) return null;
+	return {
+		...message,
+		files,
+		attachments
+	};
+}
+async function resolveSlackHistoryMediaForPendingRecord(params) {
+	const mediaMessage = buildSlackHistoryMediaCandidateMessage(params.message);
+	if (!mediaMessage) return [];
+	return toInboundMediaFacts((await resolveSlackMessageContent({
+		message: mediaMessage,
+		isThreadReply: params.isThreadReply,
+		threadStarter: params.threadStarter,
+		isBotMessage: params.isBotMessage,
+		client: params.ctx.app.client,
+		botToken: params.ctx.botToken,
+		mediaMaxBytes: Math.min(params.ctx.mediaMaxBytes, SLACK_HISTORY_MEDIA_MAX_BYTES),
+		mediaReadIdleTimeoutMs: SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS,
+		mediaTotalTimeoutMs: SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS
+	}))?.effectiveDirectMedia, {
+		kind: "image",
+		messageId: params.message.ts
+	});
+}
 function collectUniqueSlackMentionIds(text, regex) {
 	const ids = [];
 	regex.lastIndex = 0;
@@ -1198,18 +1263,52 @@ async function prepareSlackMessage(params) {
 			reason: "no-mention"
 		}, "skipping channel message");
 		const pendingText = (message.text ?? "").trim();
+		const historyMediaCandidate = buildSlackHistoryMediaCandidateMessage(message);
 		const fallbackFile = message.files?.length ? `[Slack file: ${formatSlackFileReference(message.files[0])}]` : "";
-		const pendingBody = pendingText || fallbackFile;
-		recordPendingHistoryEntryIfEnabled({
-			historyMap: ctx.channelHistories,
-			historyKey,
-			limit: ctx.historyLimit,
-			entry: pendingBody ? {
-				sender: await resolveSenderName(),
-				body: pendingBody,
-				timestamp: message.ts ? Math.round(Number(message.ts) * 1e3) : void 0,
-				messageId: message.ts
-			} : null
+		const pendingBody = pendingText || fallbackFile || (!fallbackFile && historyMediaCandidate ? "[Slack media attachment]" : "");
+		const skippedThreadStarter = historyMediaCandidate && isThreadReply && threadTs ? await resolveSlackThreadStarter({
+			channelId: message.channel,
+			threadTs,
+			client: ctx.app.client
+		}) : null;
+		const timestamp = message.ts ? Math.round(Number(message.ts) * 1e3) : void 0;
+		const senderName = pendingBody ? await resolveSenderName() : void 0;
+		await recordDroppedChannelTurnHistory({
+			input: {
+				id: message.ts ?? `${message.channel}:${Date.now()}`,
+				timestamp,
+				rawText: pendingBody,
+				textForAgent: pendingBody,
+				raw: message
+			},
+			admission: {
+				kind: "drop",
+				reason: "slack-no-mention",
+				recordHistory: true
+			},
+			preflight: {
+				message: pendingBody ? {
+					rawBody: pendingBody,
+					body: pendingBody,
+					bodyForAgent: pendingBody,
+					senderLabel: senderName,
+					envelopeFrom: senderName
+				} : void 0,
+				history: {
+					key: historyKey,
+					historyMap: ctx.channelHistories,
+					limit: ctx.historyLimit,
+					recordOnDrop: true,
+					mediaLimit: SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS
+				},
+				media: () => resolveSlackHistoryMediaForPendingRecord({
+					ctx,
+					message,
+					isThreadReply,
+					threadStarter: skippedThreadStarter,
+					isBotMessage
+				})
+			}
 		});
 		return null;
 	}
@@ -1270,6 +1369,7 @@ async function prepareSlackMessage(params) {
 	enqueueSystemEvent(`${inboundLabel}: ${preview}`, {
 		sessionKey,
 		contextKey: `slack:message:${message.channel}:${message.ts ?? "unknown"}`,
+		forceSenderIsOwnerFalse: true,
 		trusted: false
 	});
 	const envelopeFrom = resolveConversationLabel$1({
@@ -1286,6 +1386,7 @@ async function prepareSlackMessage(params) {
 		storePath,
 		sessionKey
 	});
+	const channelHistory = createChannelHistoryWindow({ historyMap: ctx.channelHistories });
 	const dmHistoryLimit = isDirectMessage ? resolveSlackDmHistoryLimit({
 		account,
 		userId: message.user,
@@ -1315,8 +1416,7 @@ async function prepareSlackMessage(params) {
 		inboundHistory: void 0
 	};
 	if (dmHistoryContext.body) combinedBody = `${dmHistoryContext.body}\n\n${combinedBody}`;
-	if (isRoomish && ctx.historyLimit > 0) combinedBody = buildPendingHistoryContextFromMap({
-		historyMap: ctx.channelHistories,
+	if (isRoomish && ctx.historyLimit > 0) combinedBody = channelHistory.buildPendingContext({
 		historyKey,
 		limit: ctx.historyLimit,
 		currentMessage: combinedBody,
@@ -1353,65 +1453,98 @@ async function prepareSlackMessage(params) {
 		effectiveDirectMedia
 	});
 	const effectiveMedia = effectiveDirectMedia ?? threadStarterMedia;
-	const firstMedia = effectiveMedia?.[0];
-	const inboundHistory = isRoomish && ctx.historyLimit > 0 ? (ctx.channelHistories.get(historyKey) ?? []).map((entry) => ({
-		sender: entry.sender,
-		body: entry.body,
-		timestamp: entry.timestamp
-	})) : dmHistoryContext.inboundHistory;
+	const inboundHistory = isRoomish && ctx.historyLimit > 0 ? channelHistory.buildInboundHistory({
+		historyKey,
+		limit: ctx.historyLimit
+	}) : dmHistoryContext.inboundHistory;
 	const commandBody = textForCommandDetection.trim();
-	const ctxPayload = finalizeInboundContext({
-		Body: combinedBody,
-		BodyForAgent: rawBody,
-		InboundHistory: inboundHistory,
-		RawBody: rawBody,
-		CommandBody: commandBody,
-		BodyForCommands: commandBody,
-		From: slackFrom,
-		To: slackTo,
-		SessionKey: sessionKey,
-		AccountId: route.accountId,
-		ChatType: chatType,
-		ConversationLabel: envelopeFrom,
-		GroupSubject: isRoomish ? roomLabel : void 0,
-		GroupSpace: ctx.teamId || void 0,
-		GroupSystemPrompt: groupSystemPrompt,
-		UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : void 0,
-		SenderName: senderName,
-		SenderId: senderId,
-		Provider: "slack",
-		Surface: "slack",
-		MessageSid: message.ts,
-		ReplyToId: threadContext.replyToId,
-		MessageThreadId: threadContext.messageThreadId,
-		ParentSessionKey: threadKeys.parentSessionKey,
-		ThreadStarterBody: !threadSessionPreviousTimestamp ? threadStarterBody : void 0,
-		ThreadHistoryBody: threadHistoryBody,
-		IsFirstThreadTurn: isThreadReply && threadTs && !threadSessionPreviousTimestamp ? true : void 0,
-		ThreadLabel: threadLabel,
-		Timestamp: message.ts ? Math.round(Number(message.ts) * 1e3) : void 0,
-		...buildSlackMentionContextPayload({
-			isRoomish,
-			effectiveWasMentioned,
-			explicitlyMentioned,
-			mentionedUserIds,
-			mentionedSubteamIds,
-			matchedImplicitMentionKinds,
-			mentionSource
-		}),
-		MediaPath: firstMedia?.path,
-		MediaType: firstMedia?.contentType,
-		MediaUrl: firstMedia?.path,
-		MediaPaths: effectiveMedia && effectiveMedia.length > 0 ? effectiveMedia.map((m) => m.path) : void 0,
-		MediaUrls: effectiveMedia && effectiveMedia.length > 0 ? effectiveMedia.map((m) => m.path) : void 0,
-		MediaTypes: effectiveMedia && effectiveMedia.length > 0 ? effectiveMedia.map((m) => m.contentType ?? "") : void 0,
-		CommandAuthorized: commandAuthorized,
-		OriginatingChannel: "slack",
-		OriginatingTo: slackTo,
-		NativeChannelId: message.channel
+	const ctxPayload = buildChannelTurnContext({
+		channel: "slack",
+		provider: "slack",
+		surface: "slack",
+		accountId: route.accountId,
+		messageId: message.ts,
+		timestamp: message.ts ? Math.round(Number(message.ts) * 1e3) : void 0,
+		from: slackFrom,
+		sender: {
+			id: senderId,
+			name: senderName,
+			displayLabel: senderName
+		},
+		conversation: {
+			kind: chatType,
+			id: message.channel,
+			label: envelopeFrom,
+			spaceId: ctx.teamId || void 0,
+			threadId: threadContext.messageThreadId,
+			nativeChannelId: message.channel,
+			routePeer: {
+				kind: chatType,
+				id: message.channel
+			}
+		},
+		route: {
+			agentId: route.agentId,
+			accountId: route.accountId,
+			routeSessionKey: sessionKey,
+			parentSessionKey: threadKeys.parentSessionKey
+		},
+		reply: {
+			to: slackTo,
+			originatingTo: slackTo,
+			replyToId: threadContext.replyToId,
+			messageThreadId: threadContext.messageThreadId,
+			nativeChannelId: message.channel
+		},
+		message: {
+			body: combinedBody,
+			bodyForAgent: rawBody,
+			rawBody,
+			commandBody,
+			envelopeFrom,
+			inboundHistory
+		},
+		access: {
+			mentions: {
+				canDetectMention: isRoomish,
+				wasMentioned: effectiveWasMentioned,
+				hasAnyMention: explicitlyMentioned || mentionedSubteamIds.length > 0,
+				implicitMentionKinds: matchedImplicitMentionKinds,
+				requireMention: shouldRequireMention,
+				effectiveWasMentioned
+			},
+			commands: {
+				authorized: commandAuthorized,
+				allowTextCommands,
+				useAccessGroups: false,
+				authorizers: []
+			}
+		},
+		media: toInboundMediaFacts(effectiveMedia),
+		supplemental: {
+			thread: {
+				starterBody: !threadSessionPreviousTimestamp ? threadStarterBody : void 0,
+				historyBody: threadHistoryBody,
+				label: threadLabel
+			},
+			groupSystemPrompt
+		},
+		extra: {
+			GroupSubject: isRoomish ? roomLabel : void 0,
+			UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : void 0,
+			IsFirstThreadTurn: isThreadReply && threadTs && !threadSessionPreviousTimestamp ? true : void 0,
+			...buildSlackMentionContextPayload({
+				isRoomish,
+				effectiveWasMentioned,
+				explicitlyMentioned,
+				mentionedUserIds,
+				mentionedSubteamIds,
+				matchedImplicitMentionKinds,
+				mentionSource
+			})
+		}
 	});
-	if (isRoomish && !shouldRequireMention) recordPendingHistoryEntryIfEnabled({
-		historyMap: ctx.channelHistories,
+	if (isRoomish && !shouldRequireMention) channelHistory.record({
 		historyKey,
 		limit: ctx.historyLimit,
 		entry: {
@@ -1464,7 +1597,13 @@ async function prepareSlackMessage(params) {
 						sessionKey
 					}, "failed updating session meta");
 				}
-			}
+			},
+			history: isRoomish && shouldRequireMention ? {
+				isGroup: true,
+				historyKey,
+				historyMap: ctx.channelHistories,
+				limit: ctx.historyLimit
+			} : void 0
 		},
 		replyToMode,
 		requireMention: shouldRequireMention,

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

@@ -121,6 +121,7 @@ function registerSlackChannelEvents(params) {
 		enqueueSystemEvent(`Slack channel ${params.kind}: ${label}.`, {
 			sessionKey,
 			contextKey: `slack:channel:${params.kind}:${params.channelId ?? params.channelName ?? "unknown"}`,
+			forceSenderIsOwnerFalse: true,
 			trusted: false
 		});
 	};
@@ -700,6 +701,7 @@ function enqueueSlackBlockActionEvent(params) {
 			accountId: params.ctx.accountId,
 			threadId: params.parsed.threadTs
 		},
+		forceSenderIsOwnerFalse: true,
 		trusted: false
 	})) requestHeartbeat({
 		source: "hook",
@@ -845,7 +847,8 @@ function parseSlackModalPrivateMetadata(raw) {
 			sessionKey: normalizeOptionalString(parsed.sessionKey),
 			channelId: normalizeOptionalString(parsed.channelId),
 			channelType: normalizeOptionalString(parsed.channelType),
-			userId: normalizeOptionalString(parsed.userId)
+			userId: normalizeOptionalString(parsed.userId),
+			pluginInteractiveData: normalizeOptionalString(parsed.pluginInteractiveData)
 		};
 	} catch {
 		return {};
@@ -853,6 +856,35 @@ function parseSlackModalPrivateMetadata(raw) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/events/interactions.modal.ts
+const OPENCLAW_MODAL_CALLBACK_PREFIX = "openclaw:";
+function resolveSlackModalPluginInteractiveData(params) {
+	const metadataData = params.metadata.pluginInteractiveData?.trim();
+	if (metadataData) return metadataData;
+	if (!params.callbackId.startsWith(OPENCLAW_MODAL_CALLBACK_PREFIX)) return;
+	return params.callbackId.slice(9).trim() || void 0;
+}
+function shouldHandleSlackModalLifecycleBody(body) {
+	const typed = body;
+	if ((typed.view?.callback_id ?? "").startsWith(OPENCLAW_MODAL_CALLBACK_PREFIX)) return true;
+	const metadata = parseSlackModalPrivateMetadata(typed.view?.private_metadata);
+	return Boolean(metadata.pluginInteractiveData?.trim());
+}
+function resolveSlackModalPluginNamespace(data) {
+	if (!data) return;
+	const separatorIndex = data.indexOf(":");
+	return separatorIndex >= 0 ? data.slice(0, separatorIndex) : data;
+}
+function resolveSlackPluginSystemEventPayload(result) {
+	if (!result || typeof result !== "object") return;
+	const systemEvent = result.systemEvent;
+	if (!systemEvent || typeof systemEvent !== "object") return;
+	const typed = systemEvent;
+	const output = {};
+	if (typeof typed.summary === "string" && typed.summary.trim()) output.summary = typed.summary;
+	if (typeof typed.reference === "string" && typed.reference.trim()) output.reference = typed.reference;
+	if (typed.data && typeof typed.data === "object" && !Array.isArray(typed.data)) output.data = typed.data;
+	return Object.keys(output).length > 0 ? output : void 0;
+}
 function resolveModalSessionRouting(params) {
 	const metadata = params.metadata;
 	if (metadata.sessionKey) return {
@@ -899,6 +931,7 @@ function resolveSlackModalEventBase(params) {
 		expectedUserId: metadata.userId,
 		viewId,
 		sessionRouting,
+		stateValues: params.body.view?.state?.values,
 		payload: {
 			actionId: `view:${callbackId}`,
 			callbackId,
@@ -918,12 +951,68 @@ function resolveSlackModalEventBase(params) {
 		}
 	};
 }
+async function dispatchSlackModalPluginInteractiveHandler(params) {
+	if (!params.data) return {
+		matched: false,
+		handled: false,
+		duplicate: false
+	};
+	const isViewClosed = params.interactionType === "view_closed";
+	const interactionId = [
+		params.interactionType,
+		params.payload.callbackId,
+		params.payload.viewId,
+		params.payload.userId
+	].filter(Boolean).join(":");
+	const result = await dispatchSlackPluginInteractiveHandler({
+		data: params.data,
+		interactionId,
+		ctx: {
+			accountId: params.ctx.accountId,
+			interactionId,
+			conversationId: params.sessionRouting.channelId ?? "",
+			parentConversationId: void 0,
+			threadId: void 0,
+			senderId: params.payload.userId,
+			senderUsername: void 0,
+			auth: params.auth,
+			interaction: {
+				kind: params.interactionType,
+				callbackId: params.payload.callbackId,
+				viewId: params.payload.viewId,
+				rootViewId: params.payload.rootViewId,
+				previousViewId: params.payload.previousViewId,
+				externalId: params.payload.externalId,
+				isStackedView: params.payload.isStackedView,
+				isCleared: isViewClosed ? params.body.is_cleared === true : void 0,
+				inputs: params.payload.inputs,
+				stateValues: params.stateValues,
+				triggerId: params.body.trigger_id
+			}
+		},
+		respond: {
+			acknowledge: async () => {},
+			reply: async () => {},
+			followUp: async () => {},
+			editMessage: async () => {}
+		}
+	});
+	return {
+		...result,
+		namespace: result.matched ? resolveSlackModalPluginNamespace(params.data) : void 0,
+		systemEvent: result.matched ? resolveSlackPluginSystemEventPayload(result.result) : void 0
+	};
+}
 async function emitSlackModalLifecycleEvent(params) {
-	const { callbackId, userId, expectedUserId, viewId, sessionRouting, payload } = resolveSlackModalEventBase({
+	const { callbackId, userId, expectedUserId, viewId, sessionRouting, stateValues, payload } = resolveSlackModalEventBase({
 		ctx: params.ctx,
 		body: params.body,
 		summarizeViewState: params.summarizeViewState
 	});
+	const pluginInteractiveData = resolveSlackModalPluginInteractiveData({
+		callbackId,
+		metadata: parseSlackModalPrivateMetadata(params.body.view?.private_metadata)
+	});
 	const isViewClosed = params.interactionType === "view_closed";
 	const isCleared = params.body.is_cleared === true;
 	const eventPayload = isViewClosed ? {
@@ -937,6 +1026,20 @@ async function emitSlackModalLifecycleEvent(params) {
 	if (isViewClosed) params.ctx.runtime.log?.(`slack:interaction view_closed callback=${callbackId} user=${userId} cleared=${isCleared}`);
 	else params.ctx.runtime.log?.(`slack:interaction view_submission callback=${callbackId} user=${userId} inputs=${payload.inputs.length}`);
 	if (!expectedUserId) {
+		if (pluginInteractiveData) try {
+			await dispatchSlackModalPluginInteractiveHandler({
+				ctx: params.ctx,
+				body: params.body,
+				interactionType: params.interactionType,
+				data: pluginInteractiveData,
+				auth: { isAuthorizedSender: false },
+				payload,
+				stateValues,
+				sessionRouting
+			});
+		} catch (error) {
+			params.ctx.runtime.log?.(`slack:interaction modal plugin dispatch failed callback=${callbackId} error=${error instanceof Error ? error.message : String(error)}`);
+		}
 		params.ctx.runtime.log?.(`slack:interaction drop modal callback=${callbackId} user=${userId} reason=missing-expected-user`);
 		return;
 	}
@@ -952,7 +1055,31 @@ async function emitSlackModalLifecycleEvent(params) {
 		params.ctx.runtime.log?.(`slack:interaction drop modal callback=${callbackId} user=${userId} reason=${auth.reason ?? "unauthorized"}`);
 		return;
 	}
-	enqueueSystemEvent(params.formatSystemEvent(eventPayload), {
+	let pluginDispatch;
+	try {
+		pluginDispatch = await dispatchSlackModalPluginInteractiveHandler({
+			ctx: params.ctx,
+			body: params.body,
+			interactionType: params.interactionType,
+			data: pluginInteractiveData,
+			auth: { isAuthorizedSender: auth.allowed },
+			payload,
+			stateValues,
+			sessionRouting
+		});
+	} catch (error) {
+		params.ctx.runtime.log?.(`slack:interaction modal plugin dispatch failed callback=${callbackId} error=${error instanceof Error ? error.message : String(error)}`);
+	}
+	const pluginEventFields = pluginDispatch?.matched === true ? {
+		pluginHandled: pluginDispatch.handled,
+		pluginNamespace: pluginDispatch.namespace,
+		pluginDuplicate: pluginDispatch.duplicate || void 0,
+		pluginSystemEvent: pluginDispatch.systemEvent
+	} : {};
+	enqueueSystemEvent(params.formatSystemEvent({
+		...eventPayload,
+		...pluginEventFields
+	}), {
 		sessionKey: sessionRouting.sessionKey,
 		contextKey: [
 			params.contextPrefix,
@@ -964,6 +1091,7 @@ async function emitSlackModalLifecycleEvent(params) {
 }
 function registerModalLifecycleHandler(params) {
 	params.register(params.matcher, async ({ ack, body }) => {
+		if (!shouldHandleSlackModalLifecycleBody(body)) return;
 		await ack();
 		if (params.ctx.shouldDropMismatchedSlackEvent?.(body)) {
 			params.ctx.runtime.log?.(`slack:interaction drop ${params.interactionType} payload (mismatched app/team)`);
@@ -982,7 +1110,6 @@ function registerModalLifecycleHandler(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/events/interactions.ts
-const OPENCLAW_ACTION_PREFIX = "openclaw:";
 const SLACK_INTERACTION_EVENT_PREFIX = "Slack interaction: ";
 const REDACTED_INTERACTION_VALUE = "[redacted]";
 const SLACK_INTERACTION_EVENT_MAX_CHARS = 2400;
@@ -1058,6 +1185,10 @@ function buildCompactSlackInteractionPayload(payload) {
 		selectedDateTime: payload.selectedDateTime,
 		workflowId: payload.workflowId,
 		routedChannelType: payload.routedChannelType,
+		pluginHandled: payload.pluginHandled,
+		pluginNamespace: payload.pluginNamespace,
+		pluginDuplicate: payload.pluginDuplicate,
+		pluginSystemEvent: payload.pluginSystemEvent,
 		inputs: compactInputs.length > 0 ? compactInputs : void 0,
 		inputsOmitted: rawInputs.length > SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS ? rawInputs.length - SLACK_INTERACTION_COMPACT_INPUTS_MAX_ITEMS : void 0,
 		payloadTruncated: true
@@ -1103,7 +1234,7 @@ function registerSlackInteractionEvents(params) {
 		formatSystemEvent: formatSlackInteractionSystemEvent
 	});
 	if (typeof ctx.app.view !== "function") return;
-	const modalMatcher = new RegExp(`^${OPENCLAW_ACTION_PREFIX}`);
+	const modalMatcher = /.*/;
 	registerModalLifecycleHandler({
 		register: (matcher, handler) => ctx.app.view(matcher, handler),
 		matcher: modalMatcher,
@@ -1464,6 +1595,7 @@ function registerSlackReactionEvents(params) {
 			enqueueSystemEvent(authorLabel ? `${baseText} from ${authorLabel}` : baseText, {
 				sessionKey: ingressContext.sessionKey,
 				contextKey: `slack:reaction:${action}:${item.channel}:${item.ts}:${event.user}:${emojiLabel}`,
+				forceSenderIsOwnerFalse: true,
 				trusted: false
 			});
 		} catch (err) {
@@ -1629,7 +1761,7 @@ function createSlackThreadTsResolver(params) {
 //#region extensions/slack/src/monitor/message-handler.ts
 let slackMessagePipelinePromise;
 function loadSlackMessagePipeline() {
-	slackMessagePipelinePromise ??= import("./pipeline.runtime-Dft2-QU4.js");
+	slackMessagePipelinePromise ??= import("./pipeline.runtime-CakcaQh9.js");
 	return slackMessagePipelinePromise;
 }
 const APP_MENTION_RETRY_TTL_MS = 6e4;
@@ -2171,7 +2303,7 @@ function loadSlashCommandsRuntime() {
 	return slashCommandsRuntimePromise;
 }
 function loadSlashDispatchRuntime() {
-	slashDispatchRuntimePromise ??= import("./slash-dispatch.runtime-Bz_OkRcR.js");
+	slashDispatchRuntimePromise ??= import("./slash-dispatch.runtime-Cg7uU92H.js");
 	return slashDispatchRuntimePromise;
 }
 function loadSlackPluginCommandsRuntime() {

package/dist/{replies-D0QXXSPP.js → replies-Fg1T3ZzU.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-Dg9zcyYT.js";
-import "./send.runtime-CjjQ9StM.js";
+import { o as markdownToSlackMrkdwnChunks, t as sendMessageSlack } from "./send-CxXFbqN1.js";
+import "./send.runtime-BHCPpSj_.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";