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

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

@@ -1,27 +1,27 @@
 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-T7ZDpUsF.js";
-import { i as hasSlackThreadParticipationWithPersistence, t as sendMessageSlack } from "./send-ioky2Xpy.js";
-import { l as reactSlackMessage } from "./actions-Cqyj7oRr.js";
-import { i as resolveSlackThreadStarter, o as formatSlackFileReference, r as resolveSlackThreadHistory } from "./media-B-nNpS2G.js";
-import { t as formatSlackError } from "./errors-BrtayXHa.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-D0hGOp8m.js";
-import "./send.runtime-DoifekaA.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 { 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 { 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;
@@ -29,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("./media-B-nNpS2G.js").then((n) => n.t);
+	slackMediaModulePromise$1 ??= import("./actions-BCRbHv1Q.js").then((n) => n.h);
 	return slackMediaModulePromise$1;
 }
 function collectUniqueSlackMentionIds$1(texts) {
@@ -191,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 ?? []];
@@ -570,7 +576,7 @@ function formatSlackBotStarterThreadLabel(params) {
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
 let slackMediaModulePromise;
 function loadSlackMediaModule() {
-	slackMediaModulePromise ??= import("./media-B-nNpS2G.js").then((n) => n.t);
+	slackMediaModulePromise ??= import("./actions-BCRbHv1Q.js").then((n) => n.h);
 	return slackMediaModulePromise;
 }
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
@@ -838,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);
@@ -851,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;
@@ -1199,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;
 	}
@@ -1271,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({
@@ -1287,6 +1386,7 @@ async function prepareSlackMessage(params) {
 		storePath,
 		sessionKey
 	});
+	const channelHistory = createChannelHistoryWindow({ historyMap: ctx.channelHistories });
 	const dmHistoryLimit = isDirectMessage ? resolveSlackDmHistoryLimit({
 		account,
 		userId: message.user,
@@ -1316,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,
@@ -1354,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: {
@@ -1465,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/{prepare.test-helpers-BhFHtbz3.js → prepare.test-helpers-CU1qB54Q.js}

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

package/dist/{probe-D1wYA05H.js → probe-FL4sUJsH.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-CiIaOW0V.js";
-import { r as createSlackWebClient } from "./client-8r7r7aZ3.js";
-import { t as formatSlackError } from "./errors-BrtayXHa.js";
+import { r as createSlackWebClient } from "./client-C_IaJbi5.js";
+import { t as formatSlackError } from "./errors-C_sW0Zgl.js";
 import { withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/slack/src/probe.ts
 var probe_exports = /* @__PURE__ */ __exportAll({ probeSlack: () => probeSlack });