@openclaw/slack 2026.7.1 → 2026.7.2-beta.2

package/dist/replies-DpF38e1y.js

@@ -1,287 +0,0 @@
-import { a as SLACK_TEXT_LIMIT, t as resolveSlackReplyBlocks } from "./reply-blocks-BGQ6zSqM.js";
-import { r as sendMessageSlack } from "./send-DKDXoeoV.js";
-import { t as markdownToSlackMrkdwnChunks } from "./format-YCNoNkM2.js";
-import "./provider-C1-DFSpw.js";
-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";
-import { deliverTextOrMediaReply, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
-import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
-import { buildCanonicalSentMessageHookContext, createInternalHookEvent, fireAndForgetHook, toInternalMessageSentContext, toPluginMessageContext, toPluginMessageSentEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
-//#region extensions/slack/src/message-sent-hook.ts
-/**
-* Slack-side emission of the `message_sent` plugin hook.
-*
-* Mirrors the Telegram pattern in `extensions/telegram/src/bot/delivery.replies.ts`
-* (`buildTelegramSentHookContext`, `emitMessageSentHooks`, `emitTelegramMessageSentHooks`).
-*
-* Without this, plugins observing `message_sent` see Telegram outbound but not
-* Slack outbound — even though `docs/plugins/hooks.md` documents the hook as
-* firing for all successful outbound deliveries.
-*/
-function buildSlackSentHookContext(params) {
-	return buildCanonicalSentMessageHookContext({
-		to: params.to,
-		content: params.content,
-		success: params.success,
-		error: params.error,
-		channelId: "slack",
-		accountId: params.accountId ?? void 0,
-		conversationId: params.to,
-		sessionKey: params.sessionKeyForInternalHooks,
-		messageId: params.messageId,
-		isGroup: params.isGroup,
-		groupId: params.groupId
-	});
-}
-function emitInternalSlackMessageSentHook(params) {
-	if (!params.sessionKeyForInternalHooks) return;
-	const canonical = buildSlackSentHookContext(params);
-	fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "sent", params.sessionKeyForInternalHooks, toInternalMessageSentContext(canonical))), "slack: message:sent internal hook failed");
-}
-function emitMessageSentHooks(params) {
-	if (!params.enabled && !params.sessionKeyForInternalHooks) return;
-	const canonical = buildSlackSentHookContext(params);
-	if (params.enabled) fireAndForgetHook(Promise.resolve(params.hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical))), "slack: message_sent plugin hook failed");
-	emitInternalSlackMessageSentHook(params);
-}
-/**
-* Fire both the plugin `message_sent` hook and (if a session key is supplied)
-* the internal `message:sent` hook for a successful or failed Slack outbound
-* delivery.
-*
-* Safe to call after every `chat.postMessage` — the function self-gates on
-* `hookRunner.hasHooks("message_sent")` so plugins not observing the hook
-* incur no cost.
-*/
-function emitSlackMessageSentHooks(params) {
-	const hookRunner = getGlobalHookRunner();
-	emitMessageSentHooks({
-		...params,
-		hookRunner,
-		enabled: hookRunner?.hasHooks("message_sent") ?? false
-	});
-}
-//#endregion
-//#region extensions/slack/src/monitor/replies.ts
-function readSlackReplyBlocks(payload) {
-	return resolveSlackReplyBlocks(payload);
-}
-function resolveSlackMediaHookSpokenText(payload) {
-	return (getReplyPayloadTtsSupplement(payload)?.spokenText ?? payload.spokenText)?.trim() || void 0;
-}
-function resolveDeliveredSlackReplyThreadTs(params) {
-	return (params.replyToMode === "off" ? void 0 : params.payloadReplyToId) ?? params.replyThreadTs;
-}
-async function deliverReplies(params) {
-	let latestResult;
-	for (const payload of params.replies) {
-		if (payload.isReasoning === true) continue;
-		const threadTs = resolveDeliveredSlackReplyThreadTs({
-			replyToMode: params.replyToMode,
-			payloadReplyToId: payload.replyToId,
-			replyThreadTs: params.replyThreadTs
-		});
-		const reply = resolveSendableOutboundReplyParts(payload);
-		const slackBlocks = readSlackReplyBlocks(payload);
-		if (!reply.hasContent && !slackBlocks?.length) continue;
-		const emitSent = (content, result) => {
-			if (params.deferMessageSentHooks) return;
-			emitSlackMessageSentHooks({
-				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
-				to: params.messageSentHookTarget ?? params.target,
-				accountId: params.accountId,
-				content,
-				success: true,
-				messageId: result?.messageId,
-				isGroup: params.isGroup,
-				groupId: params.groupId
-			});
-		};
-		const emitFailed = (content, error) => {
-			if (params.deferMessageSentHooks) return;
-			emitSlackMessageSentHooks({
-				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
-				to: params.messageSentHookTarget ?? params.target,
-				accountId: params.accountId,
-				content,
-				success: false,
-				error: formatErrorMessage(error),
-				isGroup: params.isGroup,
-				groupId: params.groupId
-			});
-		};
-		if (!reply.hasMedia && slackBlocks?.length) {
-			const trimmed = reply.trimmedText;
-			if (!trimmed && !slackBlocks?.length) continue;
-			if (trimmed && isSilentReplyText(trimmed, SILENT_REPLY_TOKEN)) continue;
-			let result;
-			try {
-				result = await sendMessageSlack(params.target, trimmed, {
-					cfg: params.cfg,
-					token: params.token,
-					threadTs,
-					accountId: params.accountId,
-					...slackBlocks?.length ? { blocks: slackBlocks } : {},
-					...params.identity ? { identity: params.identity } : {},
-					...params.metadata ? { metadata: params.metadata } : {}
-				});
-			} catch (error) {
-				emitFailed(trimmed, error);
-				throw error;
-			}
-			emitSent(trimmed, result);
-			latestResult = result;
-			params.runtime.log?.(`delivered reply to ${params.target}`);
-			continue;
-		}
-		const spokenText = resolveSlackMediaHookSpokenText(payload);
-		const mediaHookContent = reply.hasText ? reply.text : spokenText || reply.text;
-		const hookContent = reply.hasMedia ? mediaHookContent : reply.trimmedText;
-		let lastResult;
-		let delivered;
-		try {
-			delivered = await deliverTextOrMediaReply({
-				payload,
-				text: reply.text,
-				chunkText: !reply.hasMedia ? (value) => {
-					const trimmed = value.trim();
-					if (!trimmed || isSilentReplyText(trimmed, SILENT_REPLY_TOKEN)) return [];
-					return [trimmed];
-				} : void 0,
-				sendText: async (trimmed) => {
-					lastResult = await sendMessageSlack(params.target, trimmed, {
-						cfg: params.cfg,
-						token: params.token,
-						threadTs,
-						accountId: params.accountId,
-						...params.identity ? { identity: params.identity } : {},
-						...params.metadata ? { metadata: params.metadata } : {}
-					});
-				},
-				sendMedia: async ({ mediaUrl, caption }) => {
-					lastResult = await sendMessageSlack(params.target, caption ?? "", {
-						cfg: params.cfg,
-						token: params.token,
-						mediaUrl,
-						threadTs,
-						accountId: params.accountId,
-						...params.identity ? { identity: params.identity } : {},
-						...params.metadata ? { metadata: params.metadata } : {}
-					});
-				}
-			});
-		} catch (error) {
-			emitFailed(hookContent, error);
-			throw error;
-		}
-		if (delivered !== "empty") {
-			emitSent(hookContent, reply.hasMedia ? void 0 : lastResult);
-			latestResult = lastResult;
-			params.runtime.log?.(`delivered reply to ${params.target}`);
-		}
-	}
-	return latestResult;
-}
-/**
-* Compute effective threadTs for a Slack reply based on replyToMode.
-* - "off": stay in thread if already in one, otherwise main channel
-* - "first": first reply goes to thread, subsequent replies to main channel
-* - "all": all replies go to thread
-*/
-function resolveSlackThreadTs(params) {
-	return createSlackReplyReferencePlanner({
-		replyToMode: params.replyToMode,
-		incomingThreadTs: params.incomingThreadTs,
-		messageTs: params.messageTs,
-		hasReplied: params.hasReplied,
-		isThreadReply: params.isThreadReply
-	}).use();
-}
-function createSlackReplyReferencePlanner(params) {
-	return createReplyReferencePlanner({
-		replyToMode: params.isThreadReply ?? Boolean(params.incomingThreadTs && params.incomingThreadTs !== params.messageTs) ? "all" : params.replyToMode,
-		existingId: params.incomingThreadTs,
-		startId: params.messageTs,
-		hasReplied: params.hasReplied
-	});
-}
-function createSlackReplyDeliveryPlan(params) {
-	const replyReference = createSlackReplyReferencePlanner({
-		replyToMode: params.replyToMode,
-		incomingThreadTs: params.incomingThreadTs,
-		messageTs: params.messageTs,
-		hasReplied: params.hasRepliedRef.value,
-		isThreadReply: params.isThreadReply
-	});
-	return {
-		peekThreadTs: () => replyReference.peek(),
-		nextThreadTs: () => replyReference.use(),
-		markSent: () => {
-			replyReference.markSent();
-			params.hasRepliedRef.value = replyReference.hasReplied();
-		}
-	};
-}
-async function deliverSlackSlashReplies(params) {
-	const deliveries = [];
-	const chunkLimit = Math.min(params.textLimit, SLACK_TEXT_LIMIT);
-	for (const payload of params.replies) {
-		if (payload.isReasoning === true) continue;
-		const reply = resolveSendableOutboundReplyParts(payload);
-		const slackBlocks = readSlackReplyBlocks(payload);
-		const text = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
-		if (slackBlocks?.length && !reply.hasMedia) {
-			deliveries.push({
-				hookContent: text ?? "",
-				messages: [{
-					text: text ?? "",
-					blocks: slackBlocks
-				}]
-			});
-			continue;
-		}
-		const combined = [text ?? "", ...reply.mediaUrls].filter(Boolean).join("\n");
-		if (!combined) continue;
-		const chunkMode = params.chunkMode ?? "length";
-		const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(combined, chunkLimit, chunkMode) : [combined]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode: params.tableMode }));
-		if (!chunks.length && combined) chunks.push(combined);
-		deliveries.push({
-			hookContent: text ?? resolveSlackMediaHookSpokenText(payload) ?? combined,
-			messages: chunks.map((chunk) => ({ text: chunk }))
-		});
-	}
-	if (deliveries.length === 0) return;
-	const responseType = params.ephemeral ? "ephemeral" : "in_channel";
-	for (const delivery of deliveries) {
-		try {
-			for (const message of delivery.messages) await params.respond({
-				...message,
-				response_type: responseType
-			});
-		} catch (error) {
-			if (params.messageSentHookTarget) emitSlackMessageSentHooks({
-				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
-				to: params.messageSentHookTarget,
-				accountId: params.accountId,
-				content: delivery.hookContent,
-				success: false,
-				error: formatErrorMessage(error),
-				isGroup: params.isGroup,
-				groupId: params.groupId
-			});
-			throw error;
-		}
-		if (params.messageSentHookTarget) emitSlackMessageSentHooks({
-			sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
-			to: params.messageSentHookTarget,
-			accountId: params.accountId,
-			content: delivery.hookContent,
-			success: true,
-			isGroup: params.isGroup,
-			groupId: params.groupId
-		});
-	}
-}
-//#endregion
-export { resolveDeliveredSlackReplyThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, emitSlackMessageSentHooks as s, createSlackReplyDeliveryPlan as t };