@openclaw/slack 2026.7.2-beta.7 → 2026.7.33

package/dist/.setup/doctor-contract-Dxk57DKz.mjs

@@ -0,0 +1,147 @@
+import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode } from "./streaming-compat-DjlgH-Be.mjs";
+import { asObjectRecord, hasLegacyAccountStreamingAliases, hasLegacyStreamingAliases, normalizeLegacyChannelAliases } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/slack/src/doctor-contract.ts
+function hasLegacySlackStreamingAliases(value) {
+	return hasLegacyStreamingAliases(value, { includeNativeTransport: true });
+}
+function hasLegacySlackChannelAllowAlias(value) {
+	const channels = asObjectRecord(asObjectRecord(value)?.channels);
+	if (!channels) return false;
+	return Object.values(channels).some((channel) => Object.hasOwn(asObjectRecord(channel) ?? {}, "allow"));
+}
+function normalizeSlackChannelAllowAliases(params) {
+	let changed = false;
+	const nextChannels = { ...params.channels };
+	for (const [channelId, channelValue] of Object.entries(params.channels)) {
+		const channel = asObjectRecord(channelValue);
+		if (!channel || !Object.hasOwn(channel, "allow")) continue;
+		const nextChannel = { ...channel };
+		if (nextChannel.enabled === void 0) {
+			nextChannel.enabled = channel.allow;
+			params.changes.push(`Moved ${params.pathPrefix}.${channelId}.allow → ${params.pathPrefix}.${channelId}.enabled.`);
+		} else params.changes.push(`Removed ${params.pathPrefix}.${channelId}.allow (${params.pathPrefix}.${channelId}.enabled already set).`);
+		delete nextChannel.allow;
+		nextChannels[channelId] = nextChannel;
+		changed = true;
+	}
+	return {
+		channels: nextChannels,
+		changed
+	};
+}
+const legacyConfigRules = [
+	{
+		path: ["channels", "slack"],
+		message: "channels.slack.streamMode, channels.slack.streaming (scalar), chunkMode, blockStreaming, blockStreamingCoalesce, and nativeStreaming are legacy; use channels.slack.streaming.{mode,chunkMode,block.enabled,block.coalesce,nativeTransport}.",
+		match: hasLegacySlackStreamingAliases
+	},
+	{
+		path: [
+			"channels",
+			"slack",
+			"accounts"
+		],
+		message: "channels.slack.accounts.<id>.streamMode, streaming (scalar), chunkMode, blockStreaming, blockStreamingCoalesce, and nativeStreaming are legacy; use channels.slack.accounts.<id>.streaming.{mode,chunkMode,block.enabled,block.coalesce,nativeTransport}.",
+		match: (value) => hasLegacyAccountStreamingAliases(value, hasLegacySlackStreamingAliases)
+	},
+	{
+		path: ["channels", "slack"],
+		message: "channels.slack.channels.<id>.allow is legacy; use channels.slack.channels.<id>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacySlackChannelAllowAlias
+	},
+	{
+		path: [
+			"channels",
+			"slack",
+			"accounts"
+		],
+		message: "channels.slack.accounts.<id>.channels.<id>.allow is legacy; use channels.slack.accounts.<id>.channels.<id>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: (value) => {
+			const accounts = asObjectRecord(value);
+			if (!accounts) return false;
+			return Object.values(accounts).some((account) => hasLegacySlackChannelAllowAlias(account));
+		}
+	}
+];
+function normalizeCompatibilityConfig({ cfg }) {
+	const rawEntry = asObjectRecord(cfg.channels?.slack);
+	if (!rawEntry) return {
+		config: cfg,
+		changes: []
+	};
+	const changes = [];
+	let updated;
+	let changed;
+	const aliases = normalizeLegacyChannelAliases({
+		entry: rawEntry,
+		pathPrefix: "channels.slack",
+		changes,
+		normalizeDm: true,
+		normalizeAccountDm: true,
+		resolveStreamingOptions: (entry) => ({
+			resolvedMode: resolveSlackStreamingMode(entry),
+			resolvedNativeTransport: resolveSlackNativeStreaming(entry)
+		})
+	});
+	updated = aliases.entry;
+	changed = aliases.changed;
+	const channels = asObjectRecord(updated.channels);
+	if (channels) {
+		const normalized = normalizeSlackChannelAllowAliases({
+			channels,
+			pathPrefix: "channels.slack.channels",
+			changes
+		});
+		if (normalized.changed) {
+			updated = {
+				...updated,
+				channels: normalized.channels
+			};
+			changed = true;
+		}
+	}
+	const accounts = asObjectRecord(updated.accounts);
+	if (accounts) {
+		let accountsChanged = false;
+		const nextAccounts = { ...accounts };
+		for (const [accountId, accountValue] of Object.entries(accounts)) {
+			const account = asObjectRecord(accountValue);
+			const channelEntries = asObjectRecord(account?.channels);
+			if (!account || !channelEntries) continue;
+			const normalized = normalizeSlackChannelAllowAliases({
+				channels: channelEntries,
+				pathPrefix: `channels.slack.accounts.${accountId}.channels`,
+				changes
+			});
+			if (!normalized.changed) continue;
+			nextAccounts[accountId] = {
+				...account,
+				channels: normalized.channels
+			};
+			accountsChanged = true;
+		}
+		if (accountsChanged) {
+			updated = {
+				...updated,
+				accounts: nextAccounts
+			};
+			changed = true;
+		}
+	}
+	if (!changed) return {
+		config: cfg,
+		changes: []
+	};
+	return {
+		config: {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				slack: updated
+			}
+		},
+		changes
+	};
+}
+//#endregion
+export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/.setup/format-xuAop9a-.mjs

@@ -0,0 +1,108 @@
+import { markdownToIR, renderMarkdownIRChunksWithinLimit, renderMarkdownWithMarkers } from "openclaw/plugin-sdk/text-chunking";
+//#region extensions/slack/src/format.ts
+function escapeSlackMrkdwnSegment(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+const SLACK_ANGLE_TOKEN_RE = /<[^>\n]+>/g;
+function isAllowedSlackAngleToken(token) {
+	if (!token.startsWith("<") || !token.endsWith(">")) return false;
+	const inner = token.slice(1, -1);
+	return inner.startsWith("@") || inner.startsWith("#") || inner.startsWith("!") || inner.startsWith("mailto:") || inner.startsWith("tel:") || inner.startsWith("http://") || inner.startsWith("https://") || inner.startsWith("slack://");
+}
+function escapeSlackMrkdwnContent(text) {
+	if (!text) return "";
+	if (!text.includes("&") && !text.includes("<") && !text.includes(">")) return text;
+	SLACK_ANGLE_TOKEN_RE.lastIndex = 0;
+	const out = [];
+	let lastIndex = 0;
+	for (let match = SLACK_ANGLE_TOKEN_RE.exec(text); match; match = SLACK_ANGLE_TOKEN_RE.exec(text)) {
+		const matchIndex = match.index ?? 0;
+		out.push(escapeSlackMrkdwnSegment(text.slice(lastIndex, matchIndex)));
+		const token = match[0] ?? "";
+		out.push(isAllowedSlackAngleToken(token) ? token : escapeSlackMrkdwnSegment(token));
+		lastIndex = matchIndex + token.length;
+	}
+	out.push(escapeSlackMrkdwnSegment(text.slice(lastIndex)));
+	return out.join("");
+}
+function escapeSlackMrkdwnText(text) {
+	if (!text) return "";
+	if (!text.includes("&") && !text.includes("<") && !text.includes(">")) return text;
+	return text.split("\n").map((line) => {
+		if (line.startsWith("> ")) return `> ${escapeSlackMrkdwnContent(line.slice(2))}`;
+		return escapeSlackMrkdwnContent(line);
+	}).join("\n");
+}
+function buildSlackLink(link, text) {
+	const href = link.href.trim();
+	if (!href) return null;
+	const trimmedLabel = text.slice(link.start, link.end).trim();
+	const comparableHref = href.startsWith("mailto:") ? href.slice(7) : href;
+	if (!(trimmedLabel.length > 0 && trimmedLabel !== href && trimmedLabel !== comparableHref)) return null;
+	const safeHref = escapeSlackMrkdwnSegment(href);
+	return {
+		start: link.start,
+		end: link.end,
+		open: `<${safeHref}|`,
+		close: ">"
+	};
+}
+function buildSlackRenderOptions() {
+	return {
+		styleMarkers: {
+			bold: {
+				open: "*",
+				close: "*"
+			},
+			italic: {
+				open: "_",
+				close: "_"
+			},
+			strikethrough: {
+				open: "~",
+				close: "~"
+			},
+			code: {
+				open: "`",
+				close: "`"
+			},
+			code_block: {
+				open: "```\n",
+				close: "```"
+			}
+		},
+		escapeText: escapeSlackMrkdwnText,
+		buildLink: buildSlackLink
+	};
+}
+function markdownToSlackMrkdwn(markdown, options = {}) {
+	const ir = markdownToIR(markdown ?? "", {
+		linkify: false,
+		autolink: false,
+		headingStyle: "bold",
+		blockquotePrefix: "> ",
+		tableMode: options.tableMode
+	});
+	return renderMarkdownWithMarkers(ir, buildSlackRenderOptions());
+}
+function normalizeSlackOutboundText(markdown) {
+	return markdownToSlackMrkdwn(markdown ?? "");
+}
+function markdownToSlackMrkdwnChunks(markdown, limit, options = {}) {
+	const ir = markdownToIR(markdown ?? "", {
+		linkify: false,
+		autolink: false,
+		headingStyle: "bold",
+		blockquotePrefix: "> ",
+		tableMode: options.tableMode
+	});
+	const renderOptions = buildSlackRenderOptions();
+	return renderMarkdownIRChunksWithinLimit({
+		ir,
+		limit,
+		renderChunk: (chunk) => renderMarkdownWithMarkers(chunk, renderOptions),
+		measureRendered: (rendered) => rendered.length
+	}).map(({ rendered }) => rendered);
+}
+//#endregion
+export { normalizeSlackOutboundText as n, markdownToSlackMrkdwnChunks as t };

package/dist/.setup/interactive-replies-BLw4HEPS.mjs

@@ -0,0 +1,193 @@
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId } from "./accounts-uGn8E6uq.mjs";
+import { normalizeLowercaseStringOrEmpty, normalizeStringEntries, normalizeStringEntriesLower } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/slack/src/interactive-replies.ts
+const SLACK_BUTTON_MAX_ITEMS = 5;
+const SLACK_SELECT_MAX_ITEMS = 100;
+const SLACK_DIRECTIVE_RE = /\[\[(slack_buttons|slack_select):\s*([^\]]+)\]\]/gi;
+const SLACK_OPTIONS_LINE_RE = /^\s*Options:\s*(.+?)\s*\.?\s*$/i;
+const SLACK_AUTO_SELECT_MAX_ITEMS = 12;
+const SLACK_SIMPLE_OPTION_RE = /^[a-z0-9][a-z0-9 _+/-]{0,31}$/i;
+function resolveChoiceDelimiter(value) {
+	const firstDelimiter = value.indexOf(":");
+	if (firstDelimiter === -1) return -1;
+	const prefix = value.slice(0, firstDelimiter);
+	const suffix = value.slice(firstDelimiter + 1);
+	if (!(/\b(?:[01]?\d|2[0-3])$/.test(prefix) && /^[0-5]\d/.test(suffix))) return firstDelimiter;
+	const clockEnd = firstDelimiter + 3;
+	const delimiter = clockEnd + (value.slice(clockEnd).match(/^(?:\s*[-–—]\s*(?:[01]?\d|2[0-3]):[0-5]\d)*\s*/)?.[0] ?? "").length;
+	if (value[delimiter] === ":") return delimiter;
+	return delimiter === value.length ? -1 : firstDelimiter;
+}
+function parseChoice(raw, options) {
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	const delimiter = resolveChoiceDelimiter(trimmed);
+	if (delimiter === -1) return {
+		label: trimmed,
+		value: trimmed
+	};
+	const label = trimmed.slice(0, delimiter).trim();
+	let value = trimmed.slice(delimiter + 1).trim();
+	if (!label || !value) return null;
+	let style;
+	if (options?.allowStyle) {
+		const styleDelimiter = value.lastIndexOf(":");
+		if (styleDelimiter !== -1) {
+			const maybeStyle = normalizeLowercaseStringOrEmpty(value.slice(styleDelimiter + 1));
+			if (maybeStyle === "primary" || maybeStyle === "secondary" || maybeStyle === "success" || maybeStyle === "danger") {
+				const unstyledValue = value.slice(0, styleDelimiter).trim();
+				if (unstyledValue) {
+					value = unstyledValue;
+					style = maybeStyle;
+				}
+			}
+		}
+	}
+	return style ? {
+		label,
+		value,
+		style
+	} : {
+		label,
+		value
+	};
+}
+function parseChoices(raw, maxItems, options) {
+	return raw.split(",").map((entry) => parseChoice(entry, options)).filter((entry) => Boolean(entry)).slice(0, maxItems);
+}
+function buildTextBlock(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return null;
+	return {
+		type: "text",
+		text: trimmed
+	};
+}
+function buildButtonsBlock(raw) {
+	const choices = parseChoices(raw, SLACK_BUTTON_MAX_ITEMS, { allowStyle: true });
+	if (choices.length === 0) return null;
+	return {
+		type: "buttons",
+		buttons: choices.map((choice) => Object.assign({
+			label: choice.label,
+			value: choice.value
+		}, choice.style ? { style: choice.style } : {}))
+	};
+}
+function buildSelectBlock(raw) {
+	const parts = normalizeStringEntries(raw.split("|"));
+	if (parts.length === 0) return null;
+	const [first, second] = parts;
+	const placeholder = parts.length >= 2 ? first : "Choose an option";
+	const choices = parseChoices(parts.length >= 2 ? second : first, SLACK_SELECT_MAX_ITEMS);
+	if (choices.length === 0) return null;
+	return {
+		type: "select",
+		placeholder,
+		options: choices
+	};
+}
+function hasSlackBlocks(payload) {
+	const blocks = (payload.channelData?.slack)?.blocks;
+	if (typeof blocks === "string") return blocks.trim().length > 0;
+	return Array.isArray(blocks) && blocks.length > 0;
+}
+function parseSimpleSlackOptions(raw) {
+	const entries = normalizeStringEntries(raw.split(","));
+	if (entries.length < 2 || entries.length > SLACK_AUTO_SELECT_MAX_ITEMS) return null;
+	if (!entries.every((entry) => SLACK_SIMPLE_OPTION_RE.test(entry))) return null;
+	if (new Set(normalizeStringEntriesLower(entries)).size !== entries.length) return null;
+	return entries.map((entry) => ({
+		label: entry,
+		value: entry
+	}));
+}
+function resolveInteractiveRepliesFromCapabilities(capabilities) {
+	if (!capabilities) return false;
+	if (Array.isArray(capabilities)) return capabilities.some((entry) => normalizeLowercaseStringOrEmpty(String(entry)) === "interactivereplies");
+	if (typeof capabilities === "object") return capabilities.interactiveReplies === true;
+	return false;
+}
+/**
+* @deprecated Only needed for legacy Slack reply directives. New producers should emit presentation payloads.
+*/
+function isSlackInteractiveRepliesEnabled(params) {
+	return resolveInteractiveRepliesFromCapabilities(resolveSlackAccount({
+		cfg: params.cfg,
+		accountId: params.accountId ?? resolveDefaultSlackAccountId(params.cfg)
+	}).config.capabilities);
+}
+/**
+* @deprecated Slack reply directives are legacy. New producers should emit presentation payloads.
+*/
+function compileSlackInteractiveReplies(payload) {
+	const text = payload.text;
+	if (!text) return payload;
+	const generatedBlocks = [];
+	const visibleTextParts = [];
+	let cursor = 0;
+	let matchedDirective = false;
+	let generatedInteractiveBlock = false;
+	SLACK_DIRECTIVE_RE.lastIndex = 0;
+	for (const match of text.matchAll(SLACK_DIRECTIVE_RE)) {
+		matchedDirective = true;
+		const matchText = match[0];
+		const directiveType = match[1];
+		const body = match[2];
+		const index = match.index ?? 0;
+		const precedingText = text.slice(cursor, index);
+		visibleTextParts.push(precedingText);
+		const section = buildTextBlock(precedingText);
+		if (section) generatedBlocks.push(section);
+		const block = normalizeLowercaseStringOrEmpty(directiveType) === "slack_buttons" ? buildButtonsBlock(body) : buildSelectBlock(body);
+		if (block) {
+			generatedInteractiveBlock = true;
+			generatedBlocks.push(block);
+		}
+		cursor = index + matchText.length;
+	}
+	const trailingText = text.slice(cursor);
+	visibleTextParts.push(trailingText);
+	const trailingSection = buildTextBlock(trailingText);
+	if (trailingSection) generatedBlocks.push(trailingSection);
+	const cleanedText = visibleTextParts.join("");
+	if (!matchedDirective || !generatedInteractiveBlock) return parseSlackOptionsLine(payload);
+	return {
+		...payload,
+		text: cleanedText.trim() || void 0,
+		interactive: { blocks: [...payload.interactive?.blocks ?? [], ...generatedBlocks] }
+	};
+}
+/**
+* @deprecated Legacy Slack directive fallback. New producers should emit presentation payloads.
+*/
+function parseSlackOptionsLine(payload) {
+	const text = payload.text;
+	if (!text || payload.interactive?.blocks?.length || hasSlackBlocks(payload)) return payload;
+	const lines = text.split("\n");
+	const lastNonEmptyIndex = [...lines.keys()].toReversed().find((index) => lines[index]?.trim());
+	if (lastNonEmptyIndex == null) return payload;
+	const match = (lines[lastNonEmptyIndex] ?? "").match(SLACK_OPTIONS_LINE_RE);
+	if (!match) return payload;
+	const choices = parseSimpleSlackOptions(match[1] ?? "");
+	if (!choices) return payload;
+	const bodyText = lines.filter((_, index) => index !== lastNonEmptyIndex).join("\n").trim();
+	const generatedBlocks = [];
+	const bodyBlock = buildTextBlock(bodyText);
+	if (bodyBlock) generatedBlocks.push(bodyBlock);
+	generatedBlocks.push(choices.length <= SLACK_BUTTON_MAX_ITEMS ? {
+		type: "buttons",
+		buttons: choices
+	} : {
+		type: "select",
+		placeholder: "Choose an option",
+		options: choices
+	});
+	return {
+		...payload,
+		text: bodyText || void 0,
+		interactive: { blocks: [...payload.interactive?.blocks ?? [], ...generatedBlocks] }
+	};
+}
+//#endregion
+export { isSlackInteractiveRepliesEnabled as n, parseSlackOptionsLine as r, compileSlackInteractiveReplies as t };

package/dist/.setup/message-tool-api-D2m68v1f.mjs

@@ -0,0 +1,128 @@
+import { a as resolveSlackAccount, t as listEnabledSlackAccounts } from "./accounts-uGn8E6uq.mjs";
+import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.mjs";
+import { n as isSlackInteractiveRepliesEnabled } from "./interactive-replies-BLw4HEPS.mjs";
+import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
+import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
+import { Type } from "typebox";
+//#region extensions/slack/src/message-actions.ts
+function listSlackMessageActions(cfg, accountId) {
+	const accounts = (accountId ? [resolveSlackAccount({
+		cfg,
+		accountId
+	})] : listEnabledSlackAccounts(cfg)).filter((account) => account.enabled && account.botTokenSource !== "none");
+	if (accounts.length === 0) return [];
+	const isActionEnabled = (key, defaultValue = true) => {
+		for (const account of accounts) if (createActionGate(account.actions ?? cfg.channels?.slack?.actions)(key, defaultValue)) return true;
+		return false;
+	};
+	const actions = /* @__PURE__ */ new Set(["send"]);
+	if (isActionEnabled("reactions")) {
+		actions.add("react");
+		actions.add("reactions");
+	}
+	if (isActionEnabled("messages")) {
+		actions.add("read");
+		actions.add("edit");
+		actions.add("delete");
+		actions.add("download-file");
+		actions.add("upload-file");
+	}
+	if (isActionEnabled("pins")) {
+		actions.add("pin");
+		actions.add("unpin");
+		actions.add("list-pins");
+	}
+	if (isActionEnabled("memberInfo")) actions.add("member-info");
+	if (isActionEnabled("emojiList")) actions.add("emoji-list");
+	return Array.from(actions);
+}
+function extractSlackToolSend(args) {
+	const action = args.action;
+	if (action !== "sendMessage" && action !== "uploadFile" && action !== "send" && action !== "upload-file") return null;
+	const extracted = extractToolSend(args, action);
+	if (!extracted) return null;
+	const nativeThreadTs = typeof args.threadTs === "string" ? normalizeSlackThreadTsCandidate(args.threadTs) : void 0;
+	const replyTo = typeof args.replyTo === "string" ? normalizeSlackThreadTsCandidate(args.replyTo) : void 0;
+	const threadTs = action === "send" ? resolveSlackThreadTsValue({
+		replyToId: replyTo,
+		threadId: extracted.threadId
+	}) : action === "upload-file" ? normalizeSlackThreadTsCandidate(extracted.threadId) ?? replyTo : nativeThreadTs ?? normalizeSlackThreadTsCandidate(extracted.threadId);
+	const threadSuppressed = extracted.threadSuppressed === true || args.topLevel === true || args.threadTs === null;
+	return {
+		...extracted,
+		threadId: threadTs ?? extracted.threadId,
+		...!threadTs && !extracted.threadId && !threadSuppressed ? { threadImplicit: true } : {},
+		...threadSuppressed ? { threadSuppressed: true } : {}
+	};
+}
+//#endregion
+//#region extensions/slack/src/message-tool-api.ts
+const SLACK_MESSAGE_ID_ACTIONS = [
+	"react",
+	"reactions",
+	"edit",
+	"delete",
+	"pin",
+	"unpin"
+];
+function createSlackFileActionSchema() {
+	return { fileId: Type.Optional(Type.String({ description: "Slack file id, starting with \"F\" (for example F0B0LTT8M36). Required for action=\"download-file\". Read it from inbound Slack file metadata at event.files[].id. This is not the Slack message timestamp/messageId." })) };
+}
+function createSlackReactionEmojiSchema() {
+	return { emoji: Type.Optional(Type.String({ description: "Slack emoji shortcode name (for example \"white_check_mark\" or \"+1\") or common emoji character (for example \"✅\"). Colons are optional around shortcodes." })) };
+}
+function createSlackMessageIdActionSchema() {
+	const description = "Slack message timestamp/message id (for example \"1777423717.666499\"). Used by react, reactions, edit, delete, pin, and unpin actions. React defaults to the current inbound message when available. Not used by download-file, which requires fileId from event.files[].id.";
+	return {
+		messageId: Type.Optional(Type.String({ description })),
+		message_id: Type.Optional(Type.String({ description: `${description} Alias for messageId.` }))
+	};
+}
+function createSlackSendActionSchema() {
+	return {
+		topLevel: Type.Optional(Type.Boolean({ description: "Slack-only opt-out for action=\"send\" from a threaded same-channel context. Set true to post a new parent-channel message instead of inheriting the current Slack thread. `threadId: null` is accepted as the same top-level request." })),
+		replyBroadcast: Type.Optional(Type.Boolean({ description: "Slack-only opt-in for action=\"send\" thread replies. Set true with threadId or replyTo on text/block sends to also broadcast the reply to the parent channel. Not supported for media or upload-file." }))
+	};
+}
+function createSlackTopLevelActionSchema() {
+	return { topLevel: Type.Optional(Type.Boolean({ description: "Slack-only opt-out from threaded same-channel context. Set true to post at the channel root instead of inheriting the current Slack thread." })) };
+}
+function describeSlackMessageTool({ cfg, accountId }) {
+	const actions = listSlackMessageActions(cfg, accountId);
+	const capabilities = /* @__PURE__ */ new Set();
+	const schema = [];
+	if (actions.includes("send")) capabilities.add("presentation");
+	if (isSlackInteractiveRepliesEnabled({
+		cfg,
+		accountId
+	})) capabilities.add("presentation");
+	if (actions.includes("download-file")) schema.push({
+		properties: createSlackFileActionSchema(),
+		actions: ["download-file"]
+	});
+	if (actions.includes("send")) schema.push({
+		properties: createSlackSendActionSchema(),
+		actions: ["send"]
+	});
+	if (actions.includes("upload-file")) schema.push({
+		properties: createSlackTopLevelActionSchema(),
+		actions: ["upload-file"]
+	});
+	if (actions.includes("react")) schema.push({
+		properties: createSlackReactionEmojiSchema(),
+		actions: ["react", "reactions"]
+	});
+	const messageIdActions = [];
+	for (const action of SLACK_MESSAGE_ID_ACTIONS) if (actions.includes(action)) messageIdActions.push(action);
+	if (messageIdActions.length > 0) schema.push({
+		properties: createSlackMessageIdActionSchema(),
+		actions: messageIdActions
+	});
+	return {
+		actions,
+		capabilities: Array.from(capabilities),
+		schema: schema.length > 0 ? schema : null
+	};
+}
+//#endregion
+export { extractSlackToolSend as n, listSlackMessageActions as r, describeSlackMessageTool as t };

package/dist/.setup/monitor-jTrujB_u.mjs

@@ -0,0 +1,13 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { S as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-Bjv1R5E2.mjs";
+import { t as isSlackChannelAllowedByPolicy } from "./policy-C6VVHqUf.mjs";
+import { o as resolveSlackThreadTs } from "./replies-BO37R07g.mjs";
+//#region extensions/slack/src/monitor.ts
+var monitor_exports = /* @__PURE__ */ __exportAll({
+	buildSlackSlashCommandMatcher: () => buildSlackSlashCommandMatcher,
+	isSlackChannelAllowedByPolicy: () => isSlackChannelAllowedByPolicy,
+	monitorSlackProvider: () => monitorSlackProvider,
+	resolveSlackThreadTs: () => resolveSlackThreadTs
+});
+//#endregion
+export { monitor_exports as t };