@openclaw/slack 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/{relay-source-Blxj8xb4.js → relay-source-mhpMMRG-.js}

@@ -1,8 +1,8 @@
-import { c as formatUnknownError, s as SLACK_SOCKET_RECONNECT_POLICY } from "./provider-DmRizMZt.js";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { f as SLACK_SOCKET_RECONNECT_POLICY, p as formatUnknownError } from "./provider-CUUiwsg2.js";
+import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
-import { Buffer } from "node:buffer";
 import { isIP } from "node:net";
+import { rawDataToString } from "openclaw/plugin-sdk/webhook-ingress";
 import WebSocket from "ws";
 //#region extensions/slack/src/monitor/relay-source.ts
 const SLACK_RELAY_ROUTE_KINDS = /* @__PURE__ */ new Set([
@@ -21,8 +21,7 @@ async function monitorSlackRelaySource(params) {
 			params.setStatus?.({
 				connected: true,
 				lastConnectedAt: Date.now(),
-				healthState: "healthy",
-				lastError: null
+				...params.identityHealth
 			});
 			params.runtime.log?.(`slack relay mode connected gateway_id:${params.config.gatewayId}`);
 			await runRelayWebSocket({
@@ -39,7 +38,7 @@ async function monitorSlackRelaySource(params) {
 			const delayMs = computeBackoff(SLACK_SOCKET_RECONNECT_POLICY, reconnectAttempts);
 			params.setStatus?.({
 				connected: false,
-				healthState: "disconnected",
+				lifecycle: "recovering",
 				lastDisconnect: {
 					at: Date.now(),
 					error: formatUnknownError(err)
@@ -125,7 +124,7 @@ function runRelayWebSocket(params) {
 			const closeReason = formatRelayClose(code, reason);
 			params.setStatus?.({
 				connected: false,
-				healthState: "disconnected",
+				lifecycle: "recovering",
 				lastDisconnect: {
 					at: Date.now(),
 					error: closeReason
@@ -204,20 +203,14 @@ function parseRelayFrame(data) {
 		throw new SlackRelayMalformedFrameError("Slack relay received malformed JSON frame", { cause });
 	}
 }
-function rawDataToString(data) {
-	if (typeof data === "string") return data;
-	if (Buffer.isBuffer(data)) return data.toString("utf8");
-	if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
-	return Buffer.from(data).toString("utf8");
-}
 function extractRelaySlackMessageEvent(frame) {
-	const record = asRecord(frame);
+	const record = asOptionalRecord(frame);
 	if (!record || record.type !== "slack_event") return;
 	const deliveryId = stringValue(record.delivery_id);
-	const routeRecord = asRecord(record.route);
+	const routeRecord = asOptionalRecord(record.route);
 	const routeKind = stringValue(routeRecord?.kind);
 	const routeKey = stringValue(routeRecord?.key);
-	const event = asRecord(asRecord(record.payload)?.event);
+	const event = asOptionalRecord(asOptionalRecord(record.payload)?.event);
 	if (event?.type !== "message" || typeof event.channel !== "string") return;
 	if (!deliveryId || !routeKind || !SLACK_RELAY_ROUTE_KINDS.has(routeKind) || !routeKey) return;
 	return {
@@ -230,12 +223,12 @@ function extractRelaySlackMessageEvent(frame) {
 	};
 }
 function extractRelayHello(frame) {
-	const record = asRecord(frame);
+	const record = asOptionalRecord(frame);
 	if (!record || record.type !== "hello") return;
 	return { identity: extractRelayIdentity(record) };
 }
 function extractRelayIdentity(record) {
-	const identityRecord = asRecord(record.slack_identity) ?? asRecord(record.slackIdentity);
+	const identityRecord = asOptionalRecord(record.slack_identity) ?? asOptionalRecord(record.slackIdentity);
 	if (!identityRecord) return;
 	const username = normalizeOptionalString(identityRecord.username);
 	const iconUrl = normalizeOptionalString(identityRecord.icon_url) ?? normalizeOptionalString(identityRecord.iconUrl);
@@ -262,9 +255,6 @@ function formatRelayClose(code, reason) {
 	const text = reason.toString("utf8");
 	return text ? `Slack relay websocket closed (${code} ${text})` : `Slack relay websocket closed (${code})`;
 }
-function asRecord(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
 function stringValue(value) {
 	return typeof value === "string" ? value : void 0;
 }

package/dist/{replies-4s_Vq_z9.js → replies-SnWyXcsL.js}

@@ -1,6 +1,7 @@
-import { C as hasSlackNativeDataBlock, E as isSlackNativeResponseUrlRejection, L as SLACK_TEXT_LIMIT, T as isSlackInvalidBlocksResponse, f as hasSlackReplyStructuredContent, h as resolveSlackReplyBlocks, j as buildSlackBlocksFallbackText, k as markdownToSlackMrkdwnChunks, m as resolveSlackReplyBlockResolution, x as buildSlackNativeDataAccessibilityText } from "./group-policy-NQZti9t-.js";
-import { d as chunkSlackTextAtHardLimit, r as sendMessageSlack, u as buildSlackNativeDataDeliveryPlan } from "./send-DsLeZpST.js";
-import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-DmRizMZt.js";
+import { A as isSlackInvalidBlocksResponse, E as buildSlackNativeDataAccessibilityText, I as buildSlackBlocksFallbackText, O as hasSlackNativeDataBlock, P as markdownToSlackMrkdwnChunks, U as SLACK_TEXT_LIMIT, _ as hasSlackReplyStructuredContent, b as resolveSlackReplyBlocks, j as isSlackNativeResponseUrlRejection, y as resolveSlackReplyBlockResolution } from "./group-policy-DyfB_ZIE.js";
+import { h as chunkSlackTextAtHardLimit, m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-CtnOxKCc.js";
+import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-CUUiwsg2.js";
+import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";
@@ -64,6 +65,52 @@ function emitSlackMessageSentHooks(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/replies.ts
+function compactSlackResponseUrlFallback(messages) {
+	if (messages.length <= 1) return [...messages];
+	if (messages.every((message) => !message.blocks?.length)) return chunkSlackTextAtHardLimit(messages.map((message) => message.text).join("")).map((text) => ({
+		text,
+		mrkdwn: false
+	}));
+	const compacted = [];
+	let pending;
+	const flush = () => {
+		if (pending) {
+			compacted.push(pending);
+			pending = void 0;
+		}
+	};
+	for (const message of messages) {
+		if (!message.blocks?.length) {
+			flush();
+			compacted.push(message);
+			continue;
+		}
+		if (!pending?.blocks?.length) {
+			pending = {
+				...message,
+				blocks: [...message.blocks]
+			};
+			continue;
+		}
+		const text = `${pending.text}\n\n${message.text}`;
+		const blocks = [...pending.blocks, ...message.blocks];
+		if (text.length > 4e4 || blocks.length > 50) {
+			flush();
+			pending = {
+				...message,
+				blocks: [...message.blocks]
+			};
+			continue;
+		}
+		pending = {
+			text,
+			blocks,
+			mrkdwn: false
+		};
+	}
+	flush();
+	return compacted;
+}
 function readSlackReplyBlocks(payload) {
 	return resolveSlackReplyBlocks(payload);
 }
@@ -75,28 +122,6 @@ function resolveDeliveredSlackReplyThreadTs(params) {
 }
 async function deliverReplies(params) {
 	let latestResult;
-	const sendReply = async (input) => {
-		return await sendMessageSlack(params.target, input.text, {
-			cfg: params.cfg,
-			token: params.token,
-			threadTs: input.threadTs,
-			accountId: params.accountId,
-			...input.mediaUrl ? { mediaUrl: input.mediaUrl } : {},
-			...input.blocks ? { blocks: input.blocks } : {},
-			...input.authoredTextPlacement ? { authoredTextPlacement: input.authoredTextPlacement } : {},
-			...Object.hasOwn(input, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: input.nativeDataFallbackBaseText } : {},
-			...input.textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
-			...input.textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
-			...params.eventScope ? {
-				client: params.eventScope.client,
-				enterpriseEventScope: params.eventScope,
-				textLimit: params.textLimit,
-				...params.mediaMaxBytes !== void 0 ? { mediaMaxBytes: params.mediaMaxBytes } : {}
-			} : {},
-			...params.identity ? { identity: params.identity } : {},
-			...params.metadata ? { metadata: params.metadata } : {}
-		});
-	};
 	for (const payload of params.replies) {
 		if (payload.isReasoning === true) continue;
 		const threadTs = resolveDeliveredSlackReplyThreadTs({
@@ -108,6 +133,31 @@ async function deliverReplies(params) {
 		const textRaw = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
 		const { authoredTextPlacement, segments } = resolveSlackReplyBlockResolution(payload, { materializeAuthoredText: !reply.hasMedia && hasSlackReplyStructuredContent(payload) });
 		if (!textRaw && !reply.hasMedia && segments.length === 0) continue;
+		const acceptedResults = [];
+		const sendReply = async (input) => {
+			return await sendMessageSlack(params.target, input.text, {
+				cfg: params.cfg,
+				token: params.token,
+				threadTs: input.threadTs,
+				accountId: params.accountId,
+				onDeliveryResult: (result) => {
+					acceptedResults.push(result);
+				},
+				...input.mediaUrl ? { mediaUrl: input.mediaUrl } : {},
+				...input.blocks ? { blocks: input.blocks } : {},
+				...input.authoredTextPlacement ? { authoredTextPlacement: input.authoredTextPlacement } : {},
+				...Object.hasOwn(input, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: input.nativeDataFallbackBaseText } : {},
+				...input.textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
+				...input.textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
+				...params.eventScope ? {
+					eventScope: params.eventScope,
+					textLimit: params.textLimit,
+					...params.mediaMaxBytes !== void 0 ? { mediaMaxBytes: params.mediaMaxBytes } : {}
+				} : {},
+				...params.identity ? { identity: params.identity } : {},
+				...params.metadata ? { metadata: params.metadata } : {}
+			});
+		};
 		const emitSent = (content, result) => {
 			if (params.deferMessageSentHooks) return;
 			emitSlackMessageSentHooks({
@@ -205,7 +255,13 @@ async function deliverReplies(params) {
 			}
 		} catch (error) {
 			emitFailed(hookParts.join("\n\n") || textRaw || spokenText || "", error);
-			throw error;
+			if (acceptedResults.length === 0) throw error;
+			const receipt = createMessageReceiptFromOutboundResults({ results: acceptedResults });
+			throw createChannelPartialDeliveryError(error, {
+				messageIds: receipt.platformMessageIds,
+				receipt,
+				visibleReplySent: true
+			});
 		}
 		if (delivered) {
 			emitSent(hookParts.join("\n\n") || textRaw || spokenText || "", reply.hasMedia ? void 0 : lastResult);
@@ -264,13 +320,14 @@ async function deliverSlackSlashReplies(params) {
 			blocks: input.blocks,
 			baseText: input.baseText
 		});
+		const nativeFallback = responseBudget.remaining() === void 0 ? plan.fallbackMessages : compactSlackResponseUrlFallback(plan.fallbackMessages);
 		return {
 			message: {
 				text: plan.accessibilityText,
 				blocks: input.blocks,
 				mrkdwn: false
 			},
-			nativeFallback: plan.fallbackMessages,
+			nativeFallback,
 			...plan.skipOriginalBlocks ? { skipOriginalBlocks: true } : {}
 		};
 	};

package/dist/{resolve-channels-yEqmM-3I.js → resolve-channels-BSpqC8jU.js}

@@ -1,10 +1,29 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as createSlackLookupClient } from "./probe-CgDsSops.js";
+import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
+import { i as createSlackLookupClient } from "./probe-BVA65leh.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";
 //#region extensions/slack/src/resolve-channels.ts
 var resolve_channels_exports = /* @__PURE__ */ __exportAll({ resolveSlackChannelAllowlist: () => resolveSlackChannelAllowlist });
+function resolveWorkspaceQualifiedChannel(input) {
+	if (!/^team:/i.test(input)) return;
+	try {
+		const target = parseSlackTarget(input);
+		if (target?.kind !== "channel" || !target.teamId) return;
+		return {
+			input,
+			resolved: true,
+			id: formatSlackTarget({
+				teamId: target.teamId,
+				kind: "channel",
+				id: target.id
+			})
+		};
+	} catch {
+		return;
+	}
+}
 function parseSlackChannelMention(raw) {
 	const trimmed = raw.trim();
 	if (!trimmed) return {};
@@ -47,20 +66,26 @@ function resolveByName(name, channels) {
 	return matches.find((channel) => !channel.archived) ?? matches[0];
 }
 async function resolveSlackChannelAllowlist(params) {
-	const parsedEntries = params.entries.map((input) => ({
+	const workspaceResolved = params.entries.map(resolveWorkspaceQualifiedChannel);
+	const lookupEntries = params.entries.filter((_, index) => !workspaceResolved[index]);
+	if (lookupEntries.length === 0) return workspaceResolved.filter((entry) => entry !== void 0);
+	const parsedEntries = lookupEntries.map((input) => ({
 		input,
 		parsed: parseSlackChannelMention(input)
 	}));
-	if (parsedEntries.every((entry) => Boolean(entry.parsed.id))) return parsedEntries.map(({ input, parsed }) => ({
-		input,
-		resolved: true,
-		id: parsed.id,
-		name: parsed.name
-	}));
-	const channels = await listSlackChannels(params.client ?? createSlackLookupClient(params.token));
-	return resolveDirectoryAllowlistEntries({
-		entries: params.entries,
-		lookup: channels,
+	if (parsedEntries.every((entry) => Boolean(entry.parsed.id))) {
+		const resolved = parsedEntries.map(({ input, parsed }) => ({
+			input,
+			resolved: true,
+			id: parsed.id,
+			name: parsed.name
+		}));
+		let resolvedIndex = 0;
+		return workspaceResolved.map((entry) => entry ?? resolved[resolvedIndex++]);
+	}
+	const resolved = resolveDirectoryAllowlistEntries({
+		entries: lookupEntries,
+		lookup: await listSlackChannels(params.client ?? createSlackLookupClient(params.token)),
 		parseInput: parseSlackChannelMention,
 		findById: (lookup, id) => lookup.find((channel) => channel.id === id),
 		buildIdResolved: ({ input, parsed, match }) => ({
@@ -87,6 +112,8 @@ async function resolveSlackChannelAllowlist(params) {
 			resolved: false
 		})
 	});
+	let resolvedIndex = 0;
+	return workspaceResolved.map((entry) => entry ?? resolved[resolvedIndex++]);
 }
 //#endregion
 export { resolve_channels_exports as n, resolveSlackChannelAllowlist as t };

package/dist/{resolve-users-BOrt5K-5.js → resolve-users-Dvz9pDe0.js}

@@ -1,10 +1,29 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as createSlackLookupClient } from "./probe-CgDsSops.js";
+import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
+import { i as createSlackLookupClient } from "./probe-BVA65leh.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";
 //#region extensions/slack/src/resolve-users.ts
 var resolve_users_exports = /* @__PURE__ */ __exportAll({ resolveSlackUserAllowlist: () => resolveSlackUserAllowlist });
+function resolveWorkspaceQualifiedUser(input) {
+	if (!/^team:/i.test(input)) return;
+	try {
+		const target = parseSlackTarget(input);
+		if (target?.kind !== "user" || !target.teamId) return;
+		return {
+			input,
+			resolved: true,
+			id: formatSlackTarget({
+				teamId: target.teamId,
+				kind: "user",
+				id: target.id
+			})
+		};
+	} catch {
+		return;
+	}
+}
 function parseSlackUserInput(raw) {
 	const trimmed = raw.trim();
 	if (!trimmed) return {};
@@ -76,10 +95,12 @@ function resolveSlackUserFromMatches(input, matches, parsed) {
 	};
 }
 async function resolveSlackUserAllowlist(params) {
-	const users = await listSlackUsers(params.client ?? createSlackLookupClient(params.token));
-	return resolveDirectoryAllowlistEntries({
-		entries: params.entries,
-		lookup: users,
+	const workspaceResolved = params.entries.map(resolveWorkspaceQualifiedUser);
+	const lookupEntries = params.entries.filter((_, index) => !workspaceResolved[index]);
+	if (lookupEntries.length === 0) return workspaceResolved.filter((entry) => entry !== void 0);
+	const resolved = resolveDirectoryAllowlistEntries({
+		entries: lookupEntries,
+		lookup: await listSlackUsers(params.client ?? createSlackLookupClient(params.token)),
 		parseInput: parseSlackUserInput,
 		findById: (lookup, id) => lookup.find((user) => user.id === id),
 		buildIdResolved: ({ input, parsed, match }) => ({
@@ -113,6 +134,8 @@ async function resolveSlackUserAllowlist(params) {
 			resolved: false
 		})
 	});
+	let resolvedIndex = 0;
+	return workspaceResolved.map((entry) => entry ?? resolved[resolvedIndex++]);
 }
 //#endregion
 export { resolve_users_exports as n, resolveSlackUserAllowlist as t };

package/dist/{runtime-api-QMb-Q5Ko.js → runtime-api-DBi7xc_g.js}

@@ -1,6 +1,6 @@
-import "./target-parsing-N6lHogYZ.js";
-import "./probe-CgDsSops.js";
-import "./config-schema-SgZT6nXV.js";
+import "./target-parsing-BnMD2ZqZ.js";
+import "./probe-BVA65leh.js";
+import "./config-schema-CN3XZRX5.js";
 import "openclaw/plugin-sdk/account-id";
 import { createActionGate as createActionGate$1, imageResultFromFile, jsonResult, readPositiveIntegerParam, readReactionParams, readStringParam, withNormalizedTimestamp } from "openclaw/plugin-sdk/channel-actions";
 import "openclaw/plugin-sdk/channel-status";

package/dist/runtime-api.js

@@ -1,14 +1,14 @@
 import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
-import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, t as listEnabledSlackAccounts } from "./accounts-CHAeNZOX.js";
-import { n as resolveSlackGroupRequireMention, r as resolveSlackGroupToolPolicy } from "./group-policy-NQZti9t-.js";
-import { t as probeSlack } from "./probe-CgDsSops.js";
+import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, t as listEnabledSlackAccounts } from "./accounts-BlzxuYle.js";
+import { i as resolveSlackGroupToolPolicy, r as resolveSlackGroupRequireMention } from "./group-policy-DyfB_ZIE.js";
+import { t as probeSlack } from "./probe-BVA65leh.js";
 import { r as setSlackRuntime } from "./runtime-JSVZSWAj.js";
-import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-D3NuJvva.js";
-import { r as sendMessageSlack } from "./send-DsLeZpST.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-yEqmM-3I.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-BOrt5K-5.js";
-import { t as monitorSlackProvider } from "./provider-DmRizMZt.js";
-import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-DfuYoMjG.js";
-import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-DKunWh3A.js";
-import "./monitor-CmKz0wtI.js";
+import { a as getSlackMemberInfo, c as listSlackReactions, d as readSlackMessages, f as removeOwnSlackReactions, g as unpinSlackMessage, h as sendSlackMessage, l as pinSlackMessage, o as listSlackEmojis, p as removeSlackReaction, r as editSlackMessage, s as listSlackPins, t as deleteSlackMessage, u as reactSlackMessage } from "./actions-DFk0ANVB.js";
+import { r as sendMessageSlack } from "./send-CtnOxKCc.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-BSpqC8jU.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-Dvz9pDe0.js";
+import { t as monitorSlackProvider } from "./provider-CUUiwsg2.js";
+import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-D6jg2CQd.js";
+import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-DjUJQLbq.js";
+import "./monitor-Chrecrb9.js";
 export { deleteSlackMessage, editSlackMessage, getSlackMemberInfo, handleSlackAction, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsLive, listSlackDirectoryPeersLive, listSlackEmojis, listSlackPins, listSlackReactions, monitorSlackProvider, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, registerSlackPluginHttpRoutes, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAppToken, resolveSlackBotToken, resolveSlackChannelAllowlist, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackUserAllowlist, sendMessageSlack, sendSlackMessage, setSlackRuntime, slackActionRuntime, unpinSlackMessage };

package/dist/{scopes-BJSrkAp6.js → scopes-BSk4GZvZ.js}

@@ -1,4 +1,4 @@
-import { o as createSlackReadClient, r as formatSlackError } from "./probe-CgDsSops.js";
+import { a as createSlackReadClient, r as formatSlackError } from "./probe-BVA65leh.js";
 import { isRecord, normalizeOptionalString, normalizeStringEntries, sortUniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/scopes.ts
 function collectScopes(value, into) {

package/dist/security-contract-api.js

@@ -1,2 +1,2 @@
-import { t as collectSlackSecurityAuditFindings } from "./security-audit-DR097212.js";
+import { t as collectSlackSecurityAuditFindings } from "./security-audit-B_yKr7MW.js";
 export { collectSlackSecurityAuditFindings };