@openclaw/slack 2026.8.1-beta.2 → 2026.8.1

package/dist/account-configured-sUohAxZr.js

@@ -0,0 +1,33 @@
+import { hasConfiguredAccountValue } from "openclaw/plugin-sdk/account-resolution";
+import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
+//#region extensions/slack/src/account-configured.ts
+function hasSlackAccountCredentials(params) {
+	if (!params.identityTokenConfigured) return false;
+	const mode = params.config.mode ?? "socket";
+	if (mode === "http") return hasConfiguredAccountValue(params.config.signingSecret);
+	if (mode === "relay") {
+		const relay = params.config.relay;
+		return hasConfiguredAccountValue(relay?.url) && hasConfiguredAccountValue(relay?.authToken) && hasConfiguredAccountValue(relay?.gatewayId);
+	}
+	return params.appTokenConfigured;
+}
+function isSlackPluginAccountConfigured(account) {
+	const identityToken = account.identity === "user" ? account.userToken : account.botToken;
+	return hasSlackAccountCredentials({
+		config: account.config,
+		identityTokenConfigured: Boolean(identityToken?.trim()),
+		appTokenConfigured: Boolean(account.appToken?.trim())
+	});
+}
+function isSlackSetupAccountConfigured(account) {
+	if (account.config.mode === "relay") return isSlackPluginAccountConfigured(account);
+	const identityToken = account.identity === "user" ? account.userToken : account.botToken;
+	const configuredIdentityToken = account.identity === "user" ? account.config.userToken : account.config.botToken;
+	return hasSlackAccountCredentials({
+		config: account.config,
+		identityTokenConfigured: Boolean(identityToken?.trim()) || hasConfiguredSecretInput(configuredIdentityToken),
+		appTokenConfigured: Boolean(account.appToken?.trim()) || hasConfiguredSecretInput(account.config.appToken)
+	});
+}
+//#endregion
+export { isSlackPluginAccountConfigured as n, isSlackSetupAccountConfigured as r, hasSlackAccountCredentials as t };

package/dist/account-inspect-CN2hBsim.js

@@ -0,0 +1,87 @@
+import { t as hasSlackAccountCredentials } from "./account-configured-sUohAxZr.js";
+import { i as resolveDefaultSlackAccountId, r as mergeSlackAccountConfig } from "./accounts-Dm_H77gH.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
+import { hasConfiguredSecretInput, normalizeSecretInputString } 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) {
+	const token = normalizeSecretInputString(value);
+	if (token) return {
+		token,
+		source: "config",
+		status: "available"
+	};
+	if (hasConfiguredSecretInput(value)) return {
+		source: "config",
+		status: "configured_unavailable"
+	};
+	return {
+		source: "none",
+		status: "missing"
+	};
+}
+function resolveInspectedSlackToken(configured, envToken) {
+	return configured.status === "missing" && envToken ? {
+		token: envToken,
+		source: "env",
+		status: "available"
+	} : configured;
+}
+function inspectSlackAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSlackAccountId(params.cfg));
+	const merged = mergeSlackAccountConfig(params.cfg, accountId);
+	const enabled = params.cfg.channels?.slack?.enabled !== false && merged.enabled !== false;
+	const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
+	const mode = merged.mode ?? "socket";
+	const identity = merged.postAs ?? "bot";
+	const isHttpMode = mode === "http";
+	const isRelayMode = mode === "relay";
+	const configBot = inspectSlackToken(merged.botToken);
+	const configApp = inspectSlackToken(merged.appToken);
+	const configSigningSecret = inspectSlackToken(merged.signingSecret);
+	const configUser = inspectSlackToken(merged.userToken);
+	const envBot = allowEnv ? normalizeSecretInputString(params.envBotToken ?? process.env.SLACK_BOT_TOKEN) : void 0;
+	const envApp = allowEnv && !isRelayMode ? normalizeSecretInputString(params.envAppToken ?? process.env.SLACK_APP_TOKEN) : void 0;
+	const envUser = allowEnv ? normalizeSecretInputString(params.envUserToken ?? process.env.SLACK_USER_TOKEN) : void 0;
+	const botCredential = resolveInspectedSlackToken(configBot, envBot);
+	const appCredential = resolveInspectedSlackToken(configApp, envApp);
+	const userCredential = resolveInspectedSlackToken(configUser, envUser);
+	return {
+		accountId,
+		enabled,
+		...identity === "user" ? { identity } : {},
+		name: normalizeOptionalString(merged.name),
+		mode,
+		botToken: botCredential.token,
+		appToken: appCredential.token,
+		...isHttpMode ? { signingSecret: configSigningSecret.token } : {},
+		userToken: userCredential.token,
+		botTokenSource: botCredential.source,
+		appTokenSource: appCredential.source,
+		...isHttpMode ? { signingSecretSource: configSigningSecret.source } : {},
+		userTokenSource: userCredential.source,
+		botTokenStatus: botCredential.status,
+		appTokenStatus: appCredential.status,
+		...isHttpMode ? { signingSecretStatus: configSigningSecret.status } : {},
+		userTokenStatus: userCredential.status,
+		configured: hasSlackAccountCredentials({
+			config: merged,
+			identityTokenConfigured: (identity === "user" ? userCredential : botCredential).status !== "missing",
+			appTokenConfigured: appCredential.status !== "missing"
+		}),
+		config: merged,
+		groupPolicy: merged.groupPolicy,
+		textChunkLimit: merged.textChunkLimit,
+		mediaMaxMb: merged.mediaMaxMb,
+		reactionNotifications: merged.reactionNotifications,
+		reactionAllowlist: merged.reactionAllowlist,
+		replyToMode: merged.replyToMode,
+		replyToModeByChatType: merged.replyToModeByChatType,
+		actions: merged.actions,
+		slashCommand: merged.slashCommand,
+		dm: merged.dm,
+		channels: merged.channels
+	};
+}
+//#endregion
+export { inspectSlackAccount as t };

package/dist/account-inspect-api.js

@@ -1,4 +1,4 @@
-import { t as inspectSlackAccount } from "./account-inspect-Drw2gAiN.js";
+import { t as inspectSlackAccount } from "./account-inspect-CN2hBsim.js";
 //#region extensions/slack/account-inspect-api.ts
 function inspectSlackReadOnlyAccount(cfg, accountId) {
 	return inspectSlackAccount({

package/dist/{accounts-CK4AVI2_.js → accounts-Dm_H77gH.js}

@@ -1,3 +1,4 @@
+import { t as hasSlackAccountCredentials } from "./account-configured-sUohAxZr.js";
 import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -39,19 +40,19 @@ function resolveSlackOperationToken(account, operation) {
 	return account.config.userTokenReadOnly === false ? botToken ?? userToken : botToken;
 }
 const { listAccountIds, resolveDefaultAccountId, resolveAccountConfig: resolveMergedSlackAccountConfig } = createAccountListHelpers("slack", {
-	nestedObjectKeys: ["botLoopProtection", "relay"],
+	nestedObjectKeys: [
+		"botLoopProtection",
+		"presenceEvents",
+		"relay"
+	],
 	hasImplicitDefaultAccount: (cfg) => {
 		const slack = cfg.channels?.slack;
-		if (slack?.postAs === "user") {
-			if (!(hasConfiguredAccountValue(slack.userToken) || hasConfiguredAccountValue(process.env.SLACK_USER_TOKEN))) return false;
-			if (slack.mode === "http") return hasConfiguredAccountValue(slack.signingSecret);
-			if (slack.mode === "relay") return hasConfiguredAccountValue(slack.relay?.url) && hasConfiguredAccountValue(slack.relay?.authToken) && hasConfiguredAccountValue(slack.relay?.gatewayId);
-			return hasConfiguredAccountValue(slack.appToken) || hasConfiguredAccountValue(process.env.SLACK_APP_TOKEN);
-		}
-		if (!(hasConfiguredAccountValue(slack?.botToken) || hasConfiguredAccountValue(process.env.SLACK_BOT_TOKEN))) return false;
-		if (slack?.mode === "http") return hasConfiguredAccountValue(slack.signingSecret);
-		if (slack?.mode === "relay") return hasConfiguredAccountValue(slack.relay?.url) && hasConfiguredAccountValue(slack.relay?.authToken) && hasConfiguredAccountValue(slack.relay?.gatewayId);
-		return hasConfiguredAccountValue(slack?.appToken) || hasConfiguredAccountValue(process.env.SLACK_APP_TOKEN);
+		const userIdentity = slack?.postAs === "user";
+		return hasSlackAccountCredentials({
+			config: slack ?? {},
+			identityTokenConfigured: hasConfiguredAccountValue(userIdentity ? slack?.userToken : slack?.botToken) || hasConfiguredAccountValue(userIdentity ? process.env.SLACK_USER_TOKEN : process.env.SLACK_BOT_TOKEN),
+			appTokenConfigured: hasConfiguredAccountValue(slack?.appToken) || hasConfiguredAccountValue(process.env.SLACK_APP_TOKEN)
+		});
 	}
 });
 const listSlackAccountIds = listAccountIds;

package/dist/{accounts.runtime-Cb7QwWBz.js → accounts.runtime-DRuEK6mL.js}

@@ -1,2 +1,2 @@
-import { a as resolveSlackAccount, l as resolveSlackOperationToken, o as resolveSlackAccountAllowFrom } from "./accounts-CK4AVI2_.js";
+import { a as resolveSlackAccount, l as resolveSlackOperationToken, o as resolveSlackAccountAllowFrom } from "./accounts-Dm_H77gH.js";
 export { resolveSlackAccount, resolveSlackAccountAllowFrom, resolveSlackOperationToken };

package/dist/{action-runtime-BkGe7ny_.js → action-runtime-044ldvNL.js}

@@ -1,16 +1,18 @@
 import { a as parseSlackTarget, n as formatSlackTarget, o as resolveSlackChannelId } from "./target-parsing-BnMD2ZqZ.js";
 import { t as slackContextTargetsMatch } from "./targets-Cx5W_n3W.js";
-import { St as getSlackInstallationKind, T as hasSlackNativeDataBlock, lt as parseSlackBlocksInput, p as assertSlackDetachedTargetAllowed, t as buildSlackChannelIdCandidates } from "./group-policy-c4RP9bjc.js";
-import { a as readPositiveIntegerParam, c as withNormalizedTimestamp, n as imageResultFromFile, o as readReactionParams, r as jsonResult, s as readStringParam, t as createActionGate } from "./runtime-api-Cj9nxBNv.js";
-import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-TapwbeaT.js";
+import { At as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, b as hasSlackNativeDataBlock, c as assertSlackDetachedTargetAllowed, jt as resolveSlackAutoThreadId, ot as parseSlackBlocksInput, t as buildSlackChannelIdCandidates, yt as getSlackInstallationKind } from "./group-policy-BdwszjYn.js";
+import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-CtQVbde1.js";
+import { t as mergeSlackSendResults } from "./send-results-eeOu_HYm.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { 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";
 //#region extensions/slack/src/action-runtime.ts
 const messagingActions = /* @__PURE__ */ new Set([
+	"openConversation",
 	"sendMessage",
 	"uploadFile",
 	"editMessage",
@@ -24,10 +26,10 @@ const pinActions = /* @__PURE__ */ new Set([
 	"unpinMessage",
 	"listPins"
 ]);
-const SLACK_REACTION_USER_LIMIT = 100;
-const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions.runtime-DLFyUkvg.js"));
-const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts.runtime-Cb7QwWBz.js"));
-const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-B9MSdoGN.js").then((n) => n.t));
+const SLACK_REACTION_RESULT_LIMIT = 100;
+const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions-BI7JkfVm.js").then((n) => n.t));
+const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts.runtime-DRuEK6mL.js"));
+const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-DlFSKeIZ.js").then((n) => n.t));
 function createLazySlackAction(key) {
 	return (async (...args) => {
 		const action = (await loadSlackActionsRuntime())[key];
@@ -42,6 +44,7 @@ const slackActionRuntime = {
 	listSlackEmojis: createLazySlackAction("listSlackEmojis"),
 	listSlackPins: createLazySlackAction("listSlackPins"),
 	listSlackReactions: createLazySlackAction("listSlackReactions"),
+	openSlackConversation: createLazySlackAction("openSlackConversation"),
 	parseSlackBlocksInput,
 	pinSlackMessage: createLazySlackAction("pinSlackMessage"),
 	reactSlackMessage: createLazySlackAction("reactSlackMessage"),
@@ -54,26 +57,15 @@ const slackActionRuntime = {
 	sendSlackMessage: createLazySlackAction("sendSlackMessage"),
 	unpinSlackMessage: createLazySlackAction("unpinSlackMessage")
 };
-/**
-* Resolve threadTs for a Slack message based on context and replyToMode.
-* - "all": always inject threadTs
-* - "first"/"batched": inject only for the first eligible message (updates hasRepliedRef)
-* - "off": never auto-inject
-*/
 function resolveThreadTsFromContext(explicitThreadTs, targetChannel, context, opts) {
 	if (explicitThreadTs) return explicitThreadTs;
 	if (opts?.suppressImplicitThread) return;
-	if (!context?.currentChannelId && !context?.currentMessagingTarget) return;
-	if (!slackContextTargetsMatch(targetChannel, context)) return;
-	if (!context.currentThreadTs) {
-		if (context.sameChannelThreadRequired) throw new Error("Slack thread context is required for same-channel replies from a threaded Slack turn. Set topLevel=true or threadId=null to post at the channel root.");
-		return;
-	}
-	if (context.replyToMode === "all") return context.currentThreadTs;
-	if (isSingleUseReplyToMode(context.replyToMode ?? "off") && context.hasRepliedRef && !context.hasRepliedRef.value) {
-		context.hasRepliedRef.value = true;
-		return context.currentThreadTs;
-	}
+	const threadTs = resolveSlackAutoThreadId({
+		to: targetChannel,
+		toolContext: context
+	});
+	if (isSingleUseReplyToMode(context?.replyToMode ?? "off") && !context?.hasRepliedRef) return;
+	return threadTs;
 }
 function readSlackBlocksParam(params) {
 	return slackActionRuntime.parseSlackBlocksInput(params.blocks);
@@ -340,7 +332,7 @@ async function handleSlackAction(params, cfg, context) {
 			});
 		}
 		await assertReadTargetAllowed(target);
-		const limit = Math.min(readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." }) ?? SLACK_REACTION_USER_LIMIT, SLACK_REACTION_USER_LIMIT);
+		const limit = Math.min(readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." }) ?? SLACK_REACTION_RESULT_LIMIT, SLACK_REACTION_RESULT_LIMIT);
 		return jsonResult({
 			ok: true,
 			reactions: (await slackActionRuntime.listSlackReactions(channelId, messageId, readOpts))?.map((reaction) => reaction.users ? Object.assign({}, reaction, { users: reaction.users.slice(0, limit) }) : reaction)
@@ -348,7 +340,31 @@ async function handleSlackAction(params, cfg, context) {
 	}
 	if (messagingActions.has(action)) {
 		if (!isActionEnabled("messages")) throw new Error("Slack messages are disabled.");
+		const sentResults = [];
+		const sendSlackMessage = async (target, content, options) => {
+			const replyReference = context?.hasRepliedRef && slackContextTargetsMatch(target, context) ? context.hasRepliedRef : void 0;
+			const result = await slackActionRuntime.sendSlackMessage(target, content, {
+				...options,
+				...replyReference ? { [SLACK_PRIVATE_ACTION_DELIVERY_RESULT]: () => {
+					replyReference.value = true;
+				} } : {}
+			});
+			if (replyReference) replyReference.value = true;
+			sentResults.push(result);
+			return result;
+		};
 		switch (action) {
+			case "openConversation": {
+				const teamId = readStringParam(params, "teamId") ?? resolveTrustedCurrentSlackTeamId({
+					account,
+					context
+				});
+				assertSlackDetachedTargetAllowed(account.accountId, teamId);
+				return jsonResult({
+					ok: true,
+					...await slackActionRuntime.openSlackConversation(params.userIds, buildActionOpts("write", teamId))
+				});
+			}
 			case "sendMessage": {
 				const destination = resolveSlackActionTarget(account, readStringParam(params, "to", { required: true }), context).routingTarget;
 				const content = readStringParam(params, "content", { allowEmpty: true });
@@ -385,48 +401,38 @@ async function handleSlackAction(params, cfg, context) {
 					const shouldSplitLongContent = content && content.length > 8e3 && !hasSlackNativeDataBlock(blocks);
 					if (content && shouldSplitLongContent) {
 						const { replyBroadcast: _replyBroadcast, ...blockSendOpts } = sendOpts;
-						await slackActionRuntime.sendSlackMessage(destination, "", {
+						await sendSlackMessage(destination, "", {
 							...blockSendOpts,
 							blocks
 						});
-						return await slackActionRuntime.sendSlackMessage(destination, content, sendOpts);
+						return await sendSlackMessage(destination, content, sendOpts);
 					}
-					return await slackActionRuntime.sendSlackMessage(destination, content ?? "", {
+					return await sendSlackMessage(destination, content ?? "", {
 						...sendOpts,
 						blocks
 					});
 				};
-				const result = preparedMessages?.length ? await (async () => {
-					let lastResult;
-					if (mediaUrl) lastResult = await slackActionRuntime.sendSlackMessage(destination, "", {
-						...baseSendOpts,
-						mediaUrl
-					});
-					for (const [index, message] of preparedMessages.entries()) lastResult = await slackActionRuntime.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 } : {}
-					});
-					if (!lastResult) throw new Error("Slack prepared message plan produced no delivery.");
-					return lastResult;
-				})() : blocks ? await (async () => {
-					if (mediaUrl) await slackActionRuntime.sendSlackMessage(destination, "", {
-						...sendOpts,
-						mediaUrl
-					});
-					return await sendContentAndBlocks();
-				})() : await slackActionRuntime.sendSlackMessage(destination, content ?? "", {
+				if (mediaUrl && (preparedMessages?.length || blocks)) await sendSlackMessage(destination, "", {
+					...preparedMessages?.length ? baseSendOpts : sendOpts,
+					mediaUrl
+				});
+				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 } : {}
+				});
+				else if (blocks) await sendContentAndBlocks();
+				else await sendSlackMessage(destination, content ?? "", {
 					...sendOpts,
 					mediaUrl: mediaUrl ?? void 0,
 					blocks
 				});
-				if (context?.hasRepliedRef && slackContextTargetsMatch(destination, context)) context.hasRepliedRef.value = true;
 				return jsonResult({
 					ok: true,
-					result
+					result: mergeSlackSendResults(sentResults)
 				});
 			}
 			case "uploadFile": {
@@ -441,21 +447,19 @@ async function handleSlackAction(params, cfg, context) {
 				const forceDocument = readBooleanParam(params, "forceDocument") === true;
 				if (readBooleanParam(params, "replyBroadcast")) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
 				const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), destination, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
-				const result = await slackActionRuntime.sendSlackMessage(destination, initialComment ?? "", {
-					...buildActionOpts("write"),
-					mediaUrl: filePath,
-					mediaAccess: context?.mediaAccess,
-					mediaLocalRoots: context?.mediaLocalRoots,
-					mediaReadFile: context?.mediaReadFile,
-					threadTs: threadTs ?? void 0,
-					...forceDocument ? { forceDocument: true } : {},
-					...filename ? { uploadFileName: filename } : {},
-					...title ? { uploadTitle: title } : {}
-				});
-				if (context?.hasRepliedRef && slackContextTargetsMatch(destination, context)) context.hasRepliedRef.value = true;
 				return jsonResult({
 					ok: true,
-					result
+					result: await sendSlackMessage(destination, initialComment ?? "", {
+						...buildActionOpts("write"),
+						mediaUrl: filePath,
+						mediaAccess: context?.mediaAccess,
+						mediaLocalRoots: context?.mediaLocalRoots,
+						mediaReadFile: context?.mediaReadFile,
+						threadTs: threadTs ?? void 0,
+						...forceDocument ? { forceDocument: true } : {},
+						...filename ? { uploadFileName: filename } : {},
+						...title ? { uploadTitle: title } : {}
+					})
 				});
 			}
 			case "editMessage": {
@@ -529,7 +533,7 @@ async function handleSlackAction(params, cfg, context) {
 				});
 				if (!downloaded) return jsonResult({
 					ok: false,
-					error: "File could not be downloaded (not found, too large, or inaccessible)."
+					error: "File could not be downloaded. Confirm the fileId came from the requested Slack channel or explicit thread and that the file is accessible and within the size limit."
 				});
 				if (!isImageContentType(downloaded.contentType)) return jsonResult({
 					ok: true,
@@ -605,26 +609,23 @@ async function handleSlackAction(params, cfg, context) {
 	}
 	if (action === "emojiList") {
 		if (!isActionEnabled("emojiList")) throw new Error("Slack emoji list is disabled.");
-		const limit = readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." });
+		const limit = Math.min(readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." }) ?? SLACK_REACTION_RESULT_LIMIT, SLACK_REACTION_RESULT_LIMIT);
 		const teamId = resolveTrustedCurrentSlackTeamId({
 			account,
 			context
 		});
 		assertSlackDetachedTargetAllowed(account.accountId, teamId);
 		const result = await slackActionRuntime.listSlackEmojis(buildActionOpts("read", teamId));
-		if (limit != null && limit > 0 && result.emoji != null) {
-			const entries = Object.entries(result.emoji).toSorted(([a], [b]) => a.localeCompare(b));
-			if (entries.length > limit) return jsonResult({
-				ok: true,
-				emojis: {
-					...result,
-					emoji: Object.fromEntries(entries.slice(0, limit))
-				}
-			});
-		}
 		return jsonResult({
 			ok: true,
-			emojis: result
+			emojis: Object.entries(result.emoji ?? {}).toSorted(([left], [right]) => left.localeCompare(right)).slice(0, limit).map(([name, value]) => value.startsWith("alias:") ? {
+				name,
+				identifier: name,
+				aliasOf: value.slice(6)
+			} : {
+				name,
+				identifier: name
+			})
 		});
 	}
 	throw new Error(`Unknown action: ${action}`);

package/dist/action-runtime.runtime-BL3KzX13.js

@@ -0,0 +1,2 @@
+import { t as handleSlackAction } from "./action-runtime-044ldvNL.js";
+export { handleSlackAction };