@openclaw/slack 2026.11.3 → 2026.11.5-beta.2

package/dist/.setup/{account-inspect-CmkKiSb9.mjs → account-inspect-BLVha-ov.mjs}

@@ -1,17 +1,20 @@
 import { t as hasSlackAccountCredentials } from "./account-configured-zcR9TJJN.mjs";
-import { a as mergeSlackAccountConfig, g as buildSlackAccountSurfaceFields, o as resolveDefaultSlackAccountId } from "./accounts-msihSF3-.mjs";
+import { _ as buildSlackAccountSurfaceFields, a as mergeSlackAccountConfig, o as resolveDefaultSlackAccountId } from "./accounts-CGJScKtk.mjs";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
-import { hasConfiguredSecretInput, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { normalizeSecretInputString, resolveSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/account-inspect.ts
 function inspectSlackToken(value, envToken) {
-	const token = normalizeSecretInputString(value);
-	if (token || hasConfiguredSecretInput(value)) return {
-		token,
+	const credential = resolveSecretInputString({
+		value,
+		path: "Slack token",
+		mode: "inspect"
+	});
+	return credential.status !== "missing" ? {
+		token: credential.value,
 		source: "config",
-		status: token ? "available" : "configured_unavailable"
-	};
-	return envToken ? {
+		status: credential.status
+	} : envToken ? {
 		token: envToken,
 		source: "env",
 		status: "available"

package/dist/.setup/{accounts-msihSF3-.mjs → accounts-CGJScKtk.mjs}

@@ -4,6 +4,7 @@ import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, normalizeAccountId } from
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { mapAllowFromEntries, normalizeChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-helpers";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { resolveAccountEntry } from "openclaw/plugin-sdk/routing";
 import { normalizeChatType } from "openclaw/plugin-sdk/account-core";
 //#region extensions/slack/src/account-surface-fields.ts
@@ -59,6 +60,7 @@ var accounts_exports = /* @__PURE__ */ __exportAll({
 	resolveSlackAccountAllowFrom: () => resolveSlackAccountAllowFrom,
 	resolveSlackAccountDmPolicy: () => resolveSlackAccountDmPolicy,
 	resolveSlackConfigAccessorAccount: () => resolveSlackConfigAccessorAccount,
+	resolveSlackMarkdownOptions: () => resolveSlackMarkdownOptions,
 	resolveSlackOperationToken: () => resolveSlackOperationToken,
 	resolveSlackReplyToMode: () => resolveSlackReplyToMode
 });
@@ -82,6 +84,13 @@ const { listAccountIds, resolveDefaultAccountId, resolveAccountConfig: resolveMe
 });
 const listSlackAccountIds = listAccountIds;
 const resolveDefaultSlackAccountId = resolveDefaultAccountId;
+function resolveSlackMarkdownOptions(params) {
+	return { tableMode: resolveMarkdownTableMode({
+		cfg: params.cfg,
+		channel: "slack",
+		accountId: params.accountId ?? resolveDefaultSlackAccountId(params.cfg)
+	}) };
+}
 function resolveSlackAccountConfig(cfg, accountId) {
 	return resolveAccountEntry(cfg.channels?.slack?.accounts, accountId);
 }
@@ -186,4 +195,4 @@ function listEnabledSlackAccounts(cfg) {
 	})).filter((account) => account.enabled);
 }
 //#endregion
-export { mergeSlackAccountConfig as a, resolveSlackAccountAllowFrom as c, resolveSlackOperationToken as d, resolveSlackReplyToMode as f, buildSlackAccountSurfaceFields as g, resolveSlackBotToken as h, listSlackAccountIds as i, resolveSlackAccountDmPolicy as l, resolveSlackAppToken as m, hasImplicitDefaultSlackAccount as n, resolveDefaultSlackAccountId as o, formatSlackBotTokenIdentityWarning as p, listEnabledSlackAccounts as r, resolveSlackAccount as s, accounts_exports as t, resolveSlackConfigAccessorAccount as u };
+export { buildSlackAccountSurfaceFields as _, mergeSlackAccountConfig as a, resolveSlackAccountAllowFrom as c, resolveSlackMarkdownOptions as d, resolveSlackOperationToken as f, resolveSlackBotToken as g, resolveSlackAppToken as h, listSlackAccountIds as i, resolveSlackAccountDmPolicy as l, formatSlackBotTokenIdentityWarning as m, hasImplicitDefaultSlackAccount as n, resolveDefaultSlackAccountId as o, resolveSlackReplyToMode as p, listEnabledSlackAccounts as r, resolveSlackAccount as s, accounts_exports as t, resolveSlackConfigAccessorAccount as u };

package/dist/.setup/{action-runtime-ChRfnnBu.mjs → action-runtime-D01wBhx5.mjs}

@@ -1,12 +1,11 @@
-import { a as parseSlackTarget, n as formatSlackTarget, o as resolveSlackChannelId } from "./target-parsing-FFE26kOV.mjs";
-import { t as slackContextTargetsMatch } from "./targets-C6LZQL1Q.mjs";
-import { Ht as resolveSlackAutoThreadId, Vt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, b as hasSlackNativeDataBlock, ht as parseSlackBlocksInput, jt as getSlackInstallationKind, m as assertSlackDetachedTargetAllowed, r as buildSlackChannelIdCandidates } from "./session-status-Dv8wNBEt.mjs";
-import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-yhn48xf5.mjs";
-import { t as mergeSlackSendResults } from "./send-results-eeOu_HYm.mjs";
+import { a as parseSlackTarget, n as formatSlackTarget, o as resolveSlackChannelId } from "./target-parsing-Bx2UZniD.mjs";
+import { t as slackContextTargetsMatch } from "./targets-D-ASeWHy.mjs";
+import { Kt as getSlackInstallationKind, O as hasSlackNativeDataBlock, S as assertSlackDetachedTargetAllowed, c as buildSlackChannelIdCandidates, in as resolveSlackThreadTsFromContext, nn as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, nt as parseSlackBlocksInput, u as hasPotentialSlackNamedPolicy } from "./probe-DANukR3O.mjs";
+import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-DxhGRvc2.mjs";
+import { t as mergeSlackSendResults } from "./send-results-BGxlroJ-.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createLazyRuntimeMethodBinder, createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { isSingleUseReplyToMode } from "openclaw/plugin-sdk/reply-reference";
 import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";
 import { createActionGate, imageResultFromFile, jsonResult, readPositiveIntegerParam, readReactionParams, readStringParam, withNormalizedTimestamp } from "openclaw/plugin-sdk/channel-actions";
 import { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
@@ -30,15 +29,17 @@ const SLACK_REACTION_RESULT_LIMIT = 100;
 function readSlackResultLimit(params) {
 	return Math.min(readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." }) ?? SLACK_REACTION_RESULT_LIMIT, SLACK_REACTION_RESULT_LIMIT);
 }
-const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions-By7tvpvv.mjs").then((n) => n.t));
+const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions-D5S6D_BU.mjs").then((n) => n.t));
 const bindSlackAction = createLazyRuntimeMethodBinder(loadSlackActionsRuntime);
-const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts-msihSF3-.mjs").then((n) => n.t));
-const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-BEFP2ORi.mjs").then((n) => n.t));
+const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts-CGJScKtk.mjs").then((n) => n.t));
+const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-B5P3w9eA.mjs").then((n) => n.t));
 const bindSlackChannelType = createLazyRuntimeMethodBinder(loadSlackChannelTypeRuntime);
 const slackActionRuntime = {
+	createSlackChannel: bindSlackAction((runtime) => runtime.createSlackChannel),
 	deleteSlackMessage: bindSlackAction((runtime) => runtime.deleteSlackMessage),
 	downloadSlackFile: bindSlackAction((runtime) => runtime.downloadSlackFile),
 	editSlackMessage: bindSlackAction((runtime) => runtime.editSlackMessage),
+	editSlackRenderedMessage: bindSlackAction((runtime) => runtime.editSlackRenderedMessage),
 	getSlackMemberInfo: bindSlackAction((runtime) => runtime.getSlackMemberInfo),
 	listSlackEmojis: bindSlackAction((runtime) => runtime.listSlackEmojis),
 	listSlackPins: bindSlackAction((runtime) => runtime.listSlackPins),
@@ -54,25 +55,6 @@ const slackActionRuntime = {
 	sendSlackMessage: bindSlackAction((runtime) => runtime.sendSlackMessage),
 	unpinSlackMessage: bindSlackAction((runtime) => runtime.unpinSlackMessage)
 };
-function resolveThreadTsFromContext(explicitThreadTs, targetChannel, context, opts) {
-	if (explicitThreadTs) return explicitThreadTs;
-	if (opts?.suppressImplicitThread) return;
-	const threadTs = resolveSlackAutoThreadId({
-		to: targetChannel,
-		toolContext: context
-	});
-	if (isSingleUseReplyToMode(context?.replyToMode ?? "off") && !context?.hasRepliedRef) return;
-	return threadTs;
-}
-function hasPotentialSlackNamedPolicy(params) {
-	if (params.allowNameMatching !== true) return false;
-	return Object.entries(params.channels ?? {}).some(([key, entry]) => {
-		if (entry == null || key === "*") return false;
-		const named = !/^(?:channel:)?[CDG][A-Z0-9]+$/i.test(key);
-		const entryAllows = entry.enabled !== false;
-		return named && (params.decision === "allow" ? entryAllows : !entryAllows);
-	});
-}
 function resolveSlackDmReadAllowed(account) {
 	const dmPolicy = account.config.dmPolicy ?? "pairing";
 	return account.config.dm?.enabled !== false && dmPolicy !== "disabled";
@@ -272,6 +254,7 @@ async function handleSlackAction(params, cfg, context) {
 	const actionConfig = account.actions ?? cfg.channels?.slack?.actions;
 	const isActionEnabled = createActionGate(actionConfig);
 	const botToken = account.botToken?.trim();
+	if (action === "createChannel" && !isActionEnabled("channels", false)) throw new Error("Slack channel creation is disabled.");
 	const buildActionOpts = (operation, teamId) => {
 		const token = resolveSlackOperationToken(account, operation);
 		if (!token && account.identity === "user") throw new Error(`Slack operation token missing for account "${account.accountId}".`);
@@ -294,6 +277,22 @@ async function handleSlackAction(params, cfg, context) {
 			context
 		});
 	};
+	if (action === "createChannel") {
+		const teamId = readStringParam(params, "teamId") ?? resolveTrustedCurrentSlackTeamId({
+			account,
+			context
+		});
+		const inviteUserId = normalizeOptionalLowercaseString(context?.currentChannelProvider) === "slack" && context?.requesterAccountId && normalizeAccountId(context.requesterAccountId) === normalizeAccountId(account.accountId) ? context?.requesterSenderId : void 0;
+		assertSlackDetachedTargetAllowed(account.accountId, teamId);
+		const result = await slackActionRuntime.createSlackChannel(readStringParam(params, "name", { required: true }), {
+			...buildActionOpts("write", teamId),
+			inviteUserId
+		});
+		return jsonResult({
+			ok: true,
+			...result
+		});
+	}
 	if (reactionsActions.has(action)) {
 		if (!isActionEnabled("reactions")) throw new Error("Slack reactions are disabled.");
 		const target = resolveChannelTarget();
@@ -336,7 +335,7 @@ async function handleSlackAction(params, cfg, context) {
 		if (!isActionEnabled("messages")) throw new Error("Slack messages are disabled.");
 		const sentResults = [];
 		const buildSendOpts = (destination, forceDocument) => {
-			const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), destination, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
+			const threadTs = resolveSlackThreadTsFromContext(readStringParam(params, "threadTs"), destination, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
 			return {
 				...buildActionOpts("write"),
 				mediaAccess: context?.mediaAccess,
@@ -396,8 +395,7 @@ async function handleSlackAction(params, cfg, context) {
 					...nativeDataFallbackBaseText !== void 0 ? { nativeDataFallbackBaseText } : {}
 				};
 				const sendContentAndBlocks = async () => {
-					const shouldSplitLongContent = content && content.length > 8e3 && !hasSlackNativeDataBlock(blocks);
-					if (content && shouldSplitLongContent) {
+					if (content && content.length > 8e3 && !hasSlackNativeDataBlock(blocks)) {
 						const { replyBroadcast: _replyBroadcast, ...blockSendOpts } = sendOpts;
 						await sendSlackMessage(destination, "", {
 							...blockSendOpts,
@@ -416,16 +414,13 @@ async function handleSlackAction(params, cfg, context) {
 				});
 				if (preparedMessages?.length) for (const [index, message] of preparedMessages.entries()) await sendSlackMessage(destination, message.text, {
 					...baseSendOpts,
-					...index === 0 && replyBroadcast ? { replyBroadcast: true } : {},
-					...message.blocks ? { blocks: message.blocks } : {},
-					...message.authoredTextPlacement ? { authoredTextPlacement: message.authoredTextPlacement } : {},
-					...Object.hasOwn(message, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: message.nativeDataFallbackBaseText } : {},
-					...message.textIsSlackPlainText ? { textIsSlackPlainText: true } : {}
+					...message,
+					...index === 0 && replyBroadcast ? { replyBroadcast: true } : {}
 				});
 				else if (blocks) await sendContentAndBlocks();
 				else await sendSlackMessage(destination, content ?? "", {
 					...sendOpts,
-					mediaUrl: mediaUrl ?? void 0,
+					mediaUrl,
 					blocks
 				});
 				return jsonResult({
@@ -464,7 +459,7 @@ async function handleSlackAction(params, cfg, context) {
 				if (!content && !blocks) throw new Error("Slack editMessage requires content or blocks.");
 				await assertReadTargetAllowed(target);
 				const writeOpts = buildActionOpts("write", target.teamId);
-				await slackActionRuntime.editSlackMessage(channelId, messageId, content ?? "", {
+				await (context?.preparedEditText === void 0 ? slackActionRuntime.editSlackMessage : slackActionRuntime.editSlackRenderedMessage)(channelId, messageId, context?.preparedEditText ?? content ?? "", {
 					...writeOpts,
 					blocks
 				});
@@ -492,10 +487,10 @@ async function handleSlackAction(params, cfg, context) {
 				const result = await slackActionRuntime.readSlackMessages(channelId, {
 					...readOpts,
 					limit,
-					before: before ?? void 0,
-					after: after ?? void 0,
-					threadId: threadId ?? void 0,
-					messageId: messageId ?? void 0
+					before,
+					after,
+					threadId,
+					messageId
 				});
 				const messages = result.messages.map((message) => withNormalizedTimestamp(message, message.ts));
 				return jsonResult({
@@ -515,14 +510,12 @@ async function handleSlackAction(params, cfg, context) {
 				await assertReadTargetAllowed(target);
 				const threadId = readStringParam(params, "threadId") ?? readStringParam(params, "replyTo");
 				const maxBytes = account.config?.mediaMaxMb ? account.config.mediaMaxMb * 1024 * 1024 : 20971520;
-				const readToken = resolveSlackOperationToken(account, "read");
 				const readOpts = buildActionOpts("read", target.teamId);
 				const downloaded = await slackActionRuntime.downloadSlackFile(fileId, {
 					...readOpts,
-					...readToken && !readOpts.token ? { token: readToken } : {},
 					maxBytes,
 					channelId,
-					threadId: threadId ?? void 0
+					threadId
 				});
 				if (!downloaded) return jsonResult({
 					ok: false,

package/dist/.setup/action-runtime.runtime-VQGaR6g8.mjs

@@ -0,0 +1 @@
+export { t as handleSlackAction } from "./action-runtime-D01wBhx5.mjs";

package/dist/.setup/{actions-By7tvpvv.mjs → actions-D5S6D_BU.mjs}

@@ -1,13 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { h as resolveSlackBotToken, o as resolveDefaultSlackAccountId, s as resolveSlackAccount } from "./accounts-msihSF3-.mjs";
-import { n as formatSlackTarget } from "./target-parsing-FFE26kOV.mjs";
-import { D as buildSlackCompleteBlocksFallbackText, E as buildSlackBlocksFallbackText, F as truncateSlackTextByUtf8Bytes, N as countSlackTextUtf8Bytes, O as renderSlackBlockFallbackText, Q as normalizeSlackOutboundText, T as stripSlackNativeDataBlocks, Vt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, _ as appendSlackNativeDataPlainTextFallback, b as hasSlackNativeDataBlock, g as appendSlackNativeDataFallbackText, gt as validateSlackBlocksArray, k as SLACK_EDIT_TEXT_MAX_BYTES, m as assertSlackDetachedTargetAllowed, st as escapeSlackMrkdwn, x as isSlackInvalidBlocksError } from "./session-status-Dv8wNBEt.mjs";
-import { _ as getSlackWriteClient, h as createSlackWriteClient, u as createSlackLookupClient } from "./probe-IiHogLQN.mjs";
-import { m as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-C-8wY0lK.mjs";
+import { g as resolveSlackBotToken, o as resolveDefaultSlackAccountId, s as resolveSlackAccount } from "./accounts-CGJScKtk.mjs";
+import { n as formatSlackTarget } from "./target-parsing-Bx2UZniD.mjs";
+import { I as truncateSlackTextByUtf8Bytes, N as stripSlackNativeDataBlocks, O as hasSlackNativeDataBlock, P as countSlackTextUtf8Bytes, S as assertSlackDetachedTargetAllowed, T as appendSlackNativeDataPlainTextFallback, Tt as escapeSlackMrkdwn, at as buildSlackCompleteBlocksFallbackText, it as buildSlackBlocksFallbackText, k as isSlackInvalidBlocksError, nn as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, ot as renderSlackBlockFallbackText, rt as validateSlackBlocksArray, vt as SLACK_EDIT_TEXT_MAX_BYTES, w as appendSlackNativeDataFallbackText, wt as normalizeSlackOutboundText } from "./probe-DANukR3O.mjs";
+import { c as createSlackWriteClient, r as createSlackLookupClient, u as getSlackWriteClient } from "./cursor-pages-CATAzbTT.mjs";
+import { h as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-yK6_-px6.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { asOptionalObjectRecord, asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readNonBlankString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createSubsystemLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { createSubsystemLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { captureChannelReadAuthority as captureChannelReadAuthority$1 } from "openclaw/plugin-sdk/fetch-runtime";
 import { fetchWithRuntimeDispatcher as fetchWithRuntimeDispatcher$1 } from "openclaw/plugin-sdk/runtime-fetch";
 import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
@@ -21,12 +21,13 @@ import { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
 import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
 import { saveRemoteMedia, unlinkIfExists } from "openclaw/plugin-sdk/media-runtime";
 //#region extensions/slack/src/conversation-open.ts
+const slackTeamIdSchema = z.string().trim().regex(/^T[A-Z0-9]+$/i).optional();
 function parseSlackConversationOpenInput(userIds, teamId) {
 	const users = z.array(z.string().trim().regex(/^[UW][A-Z0-9]+$/)).min(1).max(8).parse(userIds);
 	if (new Set(users).size !== users.length) throw new Error("Slack conversation-open requires distinct userIds.");
 	return {
 		users,
-		teamId: teamId === void 0 ? void 0 : z.string().trim().regex(/^T[A-Z0-9]+$/i).parse(teamId)
+		teamId: slackTeamIdSchema.parse(teamId)
 	};
 }
 async function openSlackConversationWithClient(client, input) {
@@ -232,7 +233,6 @@ async function saveSlackMedia(params) {
 	const timeoutAbortController = totalTimeoutMs ? new AbortController() : void 0;
 	const abortSignals = [params.abortSignal, timeoutAbortController?.signal].filter((signal) => Boolean(signal));
 	const signal = abortSignals.length > 1 ? AbortSignal.any(abortSignals) : abortSignals[0];
-	let timedOut = false;
 	const savePromise = saveRemoteMedia({
 		url,
 		fetchImpl: createSlackMediaFetch(params.govSlack, params.assertReadAuthority),
@@ -249,13 +249,9 @@ async function saveSlackMedia(params) {
 		maxBytes: params.maxBytes,
 		ssrfPolicy: params.govSlack ? SLACK_GOV_MEDIA_SSRF_POLICY : SLACK_MEDIA_SSRF_POLICY,
 		readIdleTimeoutMs: params.readIdleTimeoutMs ?? 6e4
-	}).catch((error) => {
-		if (timedOut) return new Promise(() => {});
-		throw error;
 	});
 	if (!totalTimeoutMs) return await savePromise;
 	return await raceWithTimeout(savePromise, totalTimeoutMs, () => {
-		timedOut = true;
 		timeoutAbortController?.abort();
 		throw new Error(`slack media download timed out after ${totalTimeoutMs}ms`);
 	}, { ref: false });
@@ -289,34 +285,6 @@ async function looksLikeHtmlFile(filePath) {
 const MAX_SLACK_MEDIA_CONCURRENCY = 3;
 const MAX_SLACK_FORWARDED_ATTACHMENTS = 8;
 const SLACK_MEDIA_LIMIT_REASON = `omitted: 8-file limit`;
-function formatSlackMediaFailure(error) {
-	return redactToolPayloadText(formatErrorMessage(error)).replace(/\s+/g, " ").slice(0, 200);
-}
-async function fetchFreshSlackFileUrl(params) {
-	if (!params.file.id || !params.client) return null;
-	const assertCurrent = captureSlackMediaReadGuard(params);
-	try {
-		assertCurrent?.();
-		const info = await params.client.files.info({ file: params.file.id });
-		assertCurrent?.();
-		const freshFile = info.file;
-		if (freshFile && params.isRefreshedFileAllowed?.(freshFile) === false) {
-			logVerbose(`slack: refreshed file metadata rejected for file id=${params.file.id}`);
-			return null;
-		}
-		const freshUrl = freshFile?.url_private_download ?? freshFile?.url_private;
-		if (freshUrl) {
-			logVerbose(`slack: refreshed file URL via files.info for file id=${params.file.id}`);
-			return freshUrl;
-		}
-		logVerbose(`slack: files.info returned no private URL for file id=${params.file.id}`);
-		return null;
-	} catch (error) {
-		assertCurrent?.();
-		logVerbose(`slack: files.info failed for file id=${params.file.id}: ${formatErrorMessage(error)}`);
-		return null;
-	}
-}
 async function downloadSlackMediaFile(params) {
 	const assertReadAuthority = captureSlackMediaReadGuard(params);
 	assertReadAuthority?.();
@@ -359,13 +327,29 @@ async function resolveSlackMedia(params) {
 	const files = params.files ?? [];
 	const limitedFiles = files.length > 8 ? files.slice(0, 8) : files;
 	for (const file of files.slice(8)) params.unavailableFiles?.set(file, SLACK_MEDIA_LIMIT_REASON);
-	const refreshFileUrl = (file) => fetchFreshSlackFileUrl({
-		file,
-		client: params.client,
-		isRefreshedFileAllowed: params.isRefreshedFileAllowed,
-		assertCurrent: params.assertCurrent,
-		abortSignal: params.abortSignal
-	});
+	const refreshFileUrl = async (file) => {
+		const { client, isRefreshedFileAllowed } = params;
+		if (!file.id || !client) return null;
+		const assertRefreshCurrent = captureSlackMediaReadGuard(params);
+		try {
+			assertRefreshCurrent?.();
+			const info = await client.files.info({ file: file.id });
+			assertRefreshCurrent?.();
+			const freshFile = info.file;
+			if (freshFile && isRefreshedFileAllowed?.(freshFile) === false) {
+				logVerbose(`slack: refreshed file metadata rejected for file id=${file.id}`);
+				return null;
+			}
+			const freshUrl = freshFile?.url_private_download ?? freshFile?.url_private;
+			if (freshUrl) return freshUrl;
+			logVerbose(`slack: files.info returned no private URL for file id=${file.id}`);
+			return null;
+		} catch {
+			assertRefreshCurrent?.();
+			logVerbose(`slack: files.info failed for file id=${file.id}`);
+			return null;
+		}
+	};
 	const { results, hasError, firstError } = await runTasksWithConcurrency({
 		tasks: limitedFiles.map((file) => async () => {
 			assertCurrent?.();
@@ -383,13 +367,16 @@ async function resolveSlackMedia(params) {
 						govSlack
 					});
 				} catch (error) {
-					reason = formatSlackMediaFailure(error);
+					reason = redactToolPayloadText(formatErrorMessage(error)).replace(/\s+/g, " ").slice(0, 200);
 				}
 				assertCurrent?.();
 				url = attempt === 0 && eventUrl ? await refreshFileUrl(file) : null;
 			}
 			params.unavailableFiles?.set(file, reason);
-			slackMediaLog.warn(`slack: file ${formatSlackFileReference(file)} unavailable (${reason})`);
+			slackMediaLog.warn("slack: file unavailable", {
+				fileId: file.id,
+				reason: reason === "no private download URL" ? "missing-url" : "download-failed"
+			});
 			return null;
 		}),
 		limit: MAX_SLACK_MEDIA_CONCURRENCY,
@@ -464,9 +451,9 @@ async function resolveSlackAttachmentContent(params) {
 						...saved.fileName ? { fileName: saved.fileName } : {},
 						placeholder: `[Forwarded image: ${label}]`
 					});
-				} catch (error) {
+				} catch {
 					unavailableMediaCount += 1;
-					slackMediaLog.warn(`slack: forwarded image unavailable (${formatSlackMediaFailure(error)})`);
+					slackMediaLog.warn("slack: forwarded image unavailable");
 				}
 				attachmentMedia.push(...await resolveFiles(att.files) ?? []);
 			}
@@ -497,6 +484,7 @@ async function resolveSlackAttachmentContent(params) {
 //#endregion
 //#region extensions/slack/src/actions.ts
 var actions_exports = /* @__PURE__ */ __exportAll({
+	createSlackChannel: () => createSlackChannel,
 	deleteSlackMessage: () => deleteSlackMessage,
 	downloadSlackFile: () => downloadSlackFile,
 	editSlackMessage: () => editSlackMessage,
@@ -506,6 +494,7 @@ var actions_exports = /* @__PURE__ */ __exportAll({
 	listSlackPins: () => listSlackPins,
 	listSlackReactions: () => listSlackReactions,
 	openSlackConversation: () => openSlackConversation,
+	parseSlackChannelCreateInput: () => parseSlackChannelCreateInput,
 	pinSlackMessage: () => pinSlackMessage,
 	reactSlackMessage: () => reactSlackMessage,
 	readSlackMessages: () => readSlackMessages,
@@ -616,17 +605,58 @@ async function getClient(opts = {}, mode = "read") {
 	}).accountId : normalizeAccountId(opts.accountId);
 	assertSlackDetachedTargetAllowed(accountId, opts.teamId);
 	const token = resolveToken(opts.token, opts.accountId, opts.cfg);
+	const clientTeamId = opts.omitTeamId ? void 0 : opts.teamId;
 	if (mode === "write") {
-		if (opts.assertDirectAdapterHandoff) return createSlackWriteClient(token, { teamId: opts.teamId }, opts.assertDirectAdapterHandoff);
-		return getSlackWriteClient(token, { teamId: opts.teamId });
+		if (opts.assertDirectAdapterHandoff) return createSlackWriteClient(token, { teamId: clientTeamId }, opts.assertDirectAdapterHandoff);
+		return getSlackWriteClient(token, { teamId: clientTeamId });
 	}
-	return createSlackLookupClient(token, { teamId: opts.teamId }, opts.assertDirectAdapterHandoff);
+	return createSlackLookupClient(token, { teamId: clientTeamId }, opts.assertDirectAdapterHandoff);
 }
 async function resolveBotUserId(client) {
 	const auth = await client.auth.test();
 	if (!auth?.user_id) throw new Error("Failed to resolve Slack bot user id");
 	return auth.user_id;
 }
+function parseSlackChannelCreateInput(name, teamId, inviteUserId) {
+	return {
+		name: z.string().trim().regex(/^[a-z0-9][a-z0-9_-]{0,79}$/).parse(name),
+		teamId: slackTeamIdSchema.parse(teamId),
+		inviteUserId: inviteUserId === void 0 ? void 0 : z.string().trim().regex(/^[UW][A-Z0-9]+$/i).parse(inviteUserId)
+	};
+}
+async function createSlackChannel(name, opts = {}) {
+	const input = parseSlackChannelCreateInput(name, opts.teamId, opts.inviteUserId);
+	const result = await (await getClient(opts, "write")).conversations.create({
+		name: input.name,
+		team_id: input.teamId
+	});
+	const channelId = result.channel?.id?.trim();
+	if (!channelId || !/^C[A-Z0-9]+$/i.test(channelId)) throw new Error("Slack conversations.create did not return a valid public channel ID.");
+	let inviteWarning;
+	if (input.inviteUserId) try {
+		await (await getClient({
+			...opts,
+			omitTeamId: true
+		}, "write")).conversations.invite({
+			channel: channelId,
+			users: input.inviteUserId
+		});
+	} catch (error) {
+		inviteWarning = `${error instanceof Error && /missing_scope/i.test(error.message) ? "Slack is missing the invitation permission" : "Slack rejected the invitation"}; the requesting user can join the returned public channel, or an operator can reauthorize the Slack app and retry.`;
+	}
+	return {
+		channelId,
+		name: result.channel?.name?.trim() || input.name,
+		target: formatSlackTarget({
+			teamId: input.teamId,
+			kind: "channel",
+			id: channelId,
+			explicitKind: true
+		}),
+		...input.inviteUserId && !inviteWarning ? { invitedUserId: input.inviteUserId } : {},
+		...inviteWarning ? { inviteWarning } : {}
+	};
+}
 function createSlackReactionUpdater(method, unchangedError) {
 	return async (channelId, messageId, emoji, opts = {}) => {
 		const client = await getClient(opts, "write");
@@ -653,7 +683,6 @@ async function removeOwnSlackReactions(channelId, messageId, opts = {}) {
 		if (!name) continue;
 		if ((reaction?.users ?? []).includes(userId)) toRemove.add(name);
 	}
-	if (toRemove.size === 0) return [];
 	await Promise.all(Array.from(toRemove, (name) => removeSlackReaction(channelId, messageId, name, { client })));
 	return Array.from(toRemove);
 }
@@ -667,26 +696,10 @@ async function listSlackReactions(channelId, messageId, opts = {}) {
 async function sendSlackMessage(to, content, opts) {
 	const onDeliveryResult = Object.getOwnPropertyDescriptor(opts, SLACK_PRIVATE_ACTION_DELIVERY_RESULT)?.value;
 	return await sendMessageSlack(to, content, {
-		accountId: opts.accountId,
-		cfg: opts.cfg,
-		token: opts.token,
-		mediaUrl: opts.mediaUrl,
-		...opts.forceDocument ? { forceDocument: true } : {},
-		mediaAccess: opts.mediaAccess,
-		mediaLocalRoots: opts.mediaLocalRoots,
-		mediaReadFile: opts.mediaReadFile,
-		client: opts.client,
-		assertDirectAdapterHandoff: opts.assertDirectAdapterHandoff,
-		threadTs: opts.threadTs,
-		replyBroadcast: opts.replyBroadcast,
-		...opts.textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
-		...opts.textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
-		...opts.authoredTextPlacement ? { authoredTextPlacement: opts.authoredTextPlacement } : {},
-		...Object.hasOwn(opts, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: opts.nativeDataFallbackBaseText } : {},
-		...opts.uploadFileName ? { uploadFileName: opts.uploadFileName } : {},
-		...opts.uploadTitle ? { uploadTitle: opts.uploadTitle } : {},
-		...typeof onDeliveryResult === "function" ? { onDeliveryResult } : {},
-		blocks: opts.blocks
+		...opts,
+		uploadFileName: opts.uploadFileName || void 0,
+		uploadTitle: opts.uploadTitle || void 0,
+		onDeliveryResult: typeof onDeliveryResult === "function" ? onDeliveryResult : void 0
 	});
 }
 async function editSlackMessage(channelId, messageId, content, opts = {}) {
@@ -720,7 +733,7 @@ async function editSlackRenderedMessage(channelId, messageId, content, opts = {}
 		if (!hasNativeData || !isSlackInvalidBlocksError(error)) throw error;
 		logVerbose("slack edit: native data block rejected, retrying with text fallback");
 		const survivorBlocks = stripSlackNativeDataBlocks(blocks);
-		const survivorText = buildSlackBlocksFallbackText(survivorBlocks) ?? "";
+		const survivorText = buildSlackBlocksFallbackText(survivorBlocks);
 		const authoredEditText = content.trim();
 		const baseText = authoredEditText && !survivorText.includes(authoredEditText) ? authoredEditText : "";
 		const fallbackPlan = buildSlackNativeDataDeliveryPlan({

package/dist/.setup/{approval-handler.runtime-D8ArtDQt.mjs → approval-handler.runtime-Buw5jh2Y.mjs}

@@ -1,15 +1,15 @@
-import { a as parseSlackTarget } from "./target-parsing-FFE26kOV.mjs";
-import { F as truncateSlackTextByUtf8Bytes, Lt as normalizeSlackApproverId, P as truncateSlackText, Tt as shouldHandleSlackNativeApprovalRequest, _t as isSlackAnyNativeApprovalClientEnabled, ct as SLACK_APPROVAL_HEADER_BLOCK_ID, k as SLACK_EDIT_TEXT_MAX_BYTES, n as setSlackSessionStatus } from "./session-status-Dv8wNBEt.mjs";
-import { g as getSlackListenerWriteClient } from "./probe-IiHogLQN.mjs";
-import { s as resolveSlackReplyBlocks } from "./reply-blocks-Ca-raz2z.mjs";
-import { t as sendMessageSlack } from "./send-C-8wY0lK.mjs";
-import { n as runSlackApprovalMessageUpdate } from "./approval-message-updates-DT7XBPbV.mjs";
+import { a as parseSlackTarget } from "./target-parsing-Bx2UZniD.mjs";
+import { Et as isSlackAnyNativeApprovalClientEnabled, F as truncateSlackText, I as truncateSlackTextByUtf8Bytes, Pt as shouldHandleSlackNativeApprovalRequest, Q as SLACK_APPROVAL_HEADER_BLOCK_ID, Qt as normalizeSlackApproverId, i as setSlackSessionStatus, vt as SLACK_EDIT_TEXT_MAX_BYTES } from "./probe-DANukR3O.mjs";
+import { o as resolveSlackReplyBlocks } from "./reply-blocks-BzsXUUUL.mjs";
+import { l as getSlackListenerWriteClient } from "./cursor-pages-CATAzbTT.mjs";
+import { t as sendMessageSlack } from "./send-yK6_-px6.mjs";
+import { n as runSlackApprovalMessageUpdate } from "./approval-message-updates-pmXcve5E.mjs";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
 import { buildApprovalPresentationFromActionDescriptors } from "openclaw/plugin-sdk/approval-reply-runtime";
 import { logError } from "openclaw/plugin-sdk/logging-core";
-import { createChannelApprovalNativeRuntimeAdapterAsync } from "openclaw/plugin-sdk/approval-handler-runtime";
 import { formatChannelApprovalResolvedLabel } from "openclaw/plugin-sdk/approval-runtime";
+import { createChannelApprovalNativeRuntimeAdapterAsync } from "openclaw/plugin-sdk/approval-handler-runtime";
 //#region extensions/slack/src/approval-handler.runtime.ts
 const SLACK_CONTEXT_ELEMENTS_MAX = 10;
 const SLACK_TEXT_OBJECT_MAX = 3e3;
@@ -22,9 +22,6 @@ function resolveHandlerContext(params) {
 		context
 	};
 }
-function truncateSlackMrkdwn(text, maxChars) {
-	return truncateSlackText(text, Math.max(0, Math.floor(maxChars)), "preserve");
-}
 function buildSlackCodeBlock(text) {
 	let fence = "```";
 	while (text.includes(fence)) fence += "`";
@@ -40,7 +37,7 @@ function buildSlackMetadataContextBlock(lines) {
 	const visibleLineCount = lines.length > SLACK_CONTEXT_ELEMENTS_MAX ? 9 : lines.length;
 	const elements = lines.slice(0, visibleLineCount).map((line) => ({
 		type: "mrkdwn",
-		text: truncateSlackMrkdwn(line, SLACK_TEXT_OBJECT_MAX)
+		text: truncateSlackText(line, SLACK_TEXT_OBJECT_MAX, "preserve")
 	}));
 	if (lines.length > SLACK_CONTEXT_ELEMENTS_MAX) elements.push({
 		type: "mrkdwn",
@@ -95,8 +92,8 @@ function buildSlackApprovalPayload(input) {
 		renderBody(bodyText),
 		...metadataLines
 	].join("\n");
-	const headerDescription = isPlugin && phase === "pending" ? truncateSlackMrkdwn(description, 2600) : description;
-	const blocks = [buildSlackApprovalSection(`${heading}\n${headerDescription}`, phase === "pending" ? SLACK_APPROVAL_HEADER_BLOCK_ID : void 0), buildSlackApprovalSection(`${bodyLabel}\n${renderBody(truncateSlackMrkdwn(bodyText, 2600))}`)];
+	const headerDescription = isPlugin && phase === "pending" ? truncateSlackText(description, 2600, "preserve") : description;
+	const blocks = [buildSlackApprovalSection(`${heading}\n${headerDescription}`, phase === "pending" ? SLACK_APPROVAL_HEADER_BLOCK_ID : void 0), buildSlackApprovalSection(`${bodyLabel}\n${renderBody(truncateSlackText(bodyText, 2600, "preserve"))}`)];
 	const metadataBlock = buildSlackMetadataContextBlock(metadataLines);
 	if (metadataBlock) blocks.push(metadataBlock);
 	if (phase === "pending") blocks.push(...resolveSlackReplyBlocks({
@@ -108,22 +105,6 @@ function buildSlackApprovalPayload(input) {
 		blocks
 	};
 }
-async function updateMessage(client, accountId, { channelId, messageTs }, { text, blocks }) {
-	try {
-		await runSlackApprovalMessageUpdate({
-			accountId,
-			channelId,
-			messageTs
-		}, () => client.chat.update({
-			channel: channelId,
-			ts: messageTs,
-			text: truncateSlackTextByUtf8Bytes(text, SLACK_EDIT_TEXT_MAX_BYTES),
-			blocks
-		}));
-	} catch (err) {
-		logError(`slack approvals: failed to update message: ${String(err)}`);
-	}
-}
 const slackApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapterAsync({
 	eventKinds: [
 		"exec",
@@ -229,7 +210,22 @@ const slackApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapterAsyn
 			});
 			if (!resolved) return;
 			const client = resolveApprovalClient(resolved.context, entry.teamId);
-			await updateMessage(client, resolved.accountId, entry, payload);
+			const { channelId, messageTs } = entry;
+			const { text, blocks } = payload;
+			try {
+				await runSlackApprovalMessageUpdate({
+					accountId: resolved.accountId,
+					channelId,
+					messageTs
+				}, () => client.chat.update({
+					channel: channelId,
+					ts: messageTs,
+					text: truncateSlackTextByUtf8Bytes(text, SLACK_EDIT_TEXT_MAX_BYTES),
+					blocks
+				}));
+			} catch (err) {
+				logError(`slack approvals: failed to update message: ${String(err)}`);
+			}
 			await setSlackSessionStatus({
 				client,
 				channelId: entry.channelId,

package/dist/.setup/{approval-message-updates-DT7XBPbV.mjs → approval-message-updates-pmXcve5E.mjs}

@@ -1,4 +1,4 @@
-import { U as isSlackApprovalActionId, lt as decodeSlackApprovalAction } from "./session-status-Dv8wNBEt.mjs";
+import { $ as decodeSlackApprovalAction, W as isSlackApprovalActionId } from "./probe-DANukR3O.mjs";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 //#region extensions/slack/src/approval-message-updates.ts