@openclaw/slack 2026.10.10-beta.5 → 2026.11.5-beta.1

package/dist/.setup/question-delivery-D3qAIwuv.mjs

@@ -0,0 +1,38 @@
+import { J as resolveSlackQuestionActionIds, K as isSlackQuestionActionForQuestion, R as SLACK_QUESTION_FINALIZATION_BLOCKS, Tt as escapeSlackMrkdwn, at as buildSlackCompleteBlocksFallbackText } from "./probe-B_Ax1vS1.mjs";
+import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
+// extensions/slack/src/question-delivery.ts
+function registerSlackQuestionDelivery(params) {
+	const blocks = params.result.meta?.[SLACK_QUESTION_FINALIZATION_BLOCKS];
+	if (!blocks || resolveSlackQuestionActionIds(blocks, params.questionId).length === 0) return;
+	const messageId = params.result.meta?.slackQuestionMessageId ?? params.result.messageId;
+	const text = params.text || buildSlackCompleteBlocksFallbackText(blocks);
+	questionGatewayRuntime.registerChannelDelivery({
+		questionId: params.questionId,
+		deliveryId: `slack:${params.accountId ?? "default"}:${params.result.channelId}:${messageId}`,
+		finalize: async (statusLine) => {
+			const escapedStatusLine = escapeSlackMrkdwn(statusLine);
+			const displayBlocks = blocks.flatMap((block) => {
+				if (block.type !== "actions") return [block];
+				const actions = block;
+				const elements = actions.elements.filter((element) => !isSlackQuestionActionForQuestion(element, params.questionId));
+				return elements.length ? [{
+					...actions,
+					elements
+				}] : [];
+			});
+			await params.update({
+				channelId: params.result.channelId,
+				messageTs: messageId,
+				text: `${text}\n\n${escapedStatusLine}`,
+				blocks: [...displayBlocks, {
+					type: "context",
+					elements: [{
+						type: "mrkdwn",
+						text: escapedStatusLine
+					}]
+				}]
+			});
+		}
+	});
+}
+export { registerSlackQuestionDelivery as t };

package/dist/.setup/{relay-source-oY9SbDiX.mjs → relay-source-a8jodKuO.mjs}

@@ -1,12 +1,12 @@
-import { o as formatSlackError } from "./probe-IiHogLQN.mjs";
-import { d as parseSlackMessageEvent, f as requireSlackMessageEvent, x as SLACK_SOCKET_RECONNECT_POLICY } from "./monitor-BFilOuM_.mjs";
+import { m as formatSlackError } from "./probe-B_Ax1vS1.mjs";
+import { d as parseSlackMessageEvent, f as requireSlackMessageEvent, x as SLACK_SOCKET_RECONNECT_POLICY } from "./monitor-BD86SotB.mjs";
 import { asOptionalRecord, normalizeOptionalString, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
 import { isIP } from "node:net";
 import { rawDataToString } from "openclaw/plugin-sdk/webhook-ingress";
-import { WebSocket } from "openclaw/plugin-sdk/websocket-runtime";
-//#region extensions/slack/src/monitor/relay-source.ts
+import { WebSocket, startWebSocketKeepalive } from "openclaw/plugin-sdk/websocket-runtime";
+// extensions/slack/src/monitor/relay-source.ts
 const SLACK_RELAY_ROUTE_KINDS = /* @__PURE__ */ new Set([
 	"user_group",
 	"thread_affinity",
@@ -15,11 +15,13 @@ const SLACK_RELAY_ROUTE_KINDS = /* @__PURE__ */ new Set([
 const SLACK_RELAY_MAX_PAYLOAD_BYTES = 1048576;
 async function monitorSlackRelaySource(params) {
 	let reconnectAttempts = 0;
+	let disconnectedAt;
 	while (!params.abortSignal?.aborted) {
 		let connection;
 		try {
 			connection = await openRelayWebSocket(params.config, params.abortSignal);
 			reconnectAttempts = 0;
+			disconnectedAt = void 0;
 			params.setStatus?.({
 				connected: true,
 				lastConnectedAt: Date.now(),
@@ -42,7 +44,7 @@ async function monitorSlackRelaySource(params) {
 				connected: false,
 				lifecycle: "recovering",
 				lastDisconnect: {
-					at: Date.now(),
+					at: disconnectedAt ??= Date.now(),
 					error: formatSlackError(err)
 				},
 				lastError: formatSlackError(err)
@@ -93,7 +95,12 @@ function runRelayWebSocket(params) {
 	const ws = params.connection;
 	let pending = Promise.resolve();
 	return new Promise((resolve, reject) => {
+		const stopKeepalive = startWebSocketKeepalive(ws, () => {
+			ws.terminate();
+			settleReject(/* @__PURE__ */ new Error("Slack relay websocket heartbeat timed out"));
+		});
 		const cleanup = () => {
+			stopKeepalive();
 			ws.off("message", onMessage);
 			ws.off("error", onError);
 			ws.off("close", onClose);
@@ -246,5 +253,4 @@ function formatRelayClose(code, reason) {
 	const text = reason.toString("utf8");
 	return text ? `Slack relay websocket closed (${code} ${text})` : `Slack relay websocket closed (${code})`;
 }
-//#endregion
 export { SLACK_RELAY_MAX_PAYLOAD_BYTES, SlackRelayMalformedFrameError, buildRelayWebSocketOptions, buildRelayWebSocketUrl, monitorSlackRelaySource, parseRelayFrame, requireSlackMessageEvent };

package/dist/.setup/{replies-CJwjTqDr.mjs → replies-Bq7n0gfM.mjs}

@@ -1,18 +1,20 @@
-import { C as isSlackNativeResponseUrlRejection, M as SLACK_TEXT_LIMIT, S as isSlackInvalidBlocksResponse, Z as markdownToSlackMrkdwnChunks, b as hasSlackNativeDataBlock } from "./session-status-Dv8wNBEt.mjs";
-import { n as iterateSlackReplyDeliveryMessages, o as resolveSlackReplyBlockResolution, t as hasSlackReplyStructuredContent } from "./reply-blocks-Ca-raz2z.mjs";
-import { n as resolveSlackReplyThreadTs } from "./thread-ts-Cvt7WD6B.mjs";
-import { h as chunkSlackTextAtHardLimit, m as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-C-8wY0lK.mjs";
-import { a as SlackResponseAlreadyReportedError, o as createSlackResponseUrlBudget } from "./monitor-BFilOuM_.mjs";
+import { A as isSlackInvalidBlocksResponse, Ct as markdownToSlackMrkdwnChunks, O as hasSlackNativeDataBlock, j as isSlackNativeResponseUrlRejection, xt as SLACK_TEXT_LIMIT } from "./probe-B_Ax1vS1.mjs";
+import { n as resolveSlackReplyThreadTs } from "./thread-ts-47Au2-Yn.mjs";
+import { a as resolveSlackReplyBlockResolution, n as iterateSlackReplyDeliveryMessages, t as hasSlackReplyStructuredContent } from "./reply-blocks-DyYYRrP_.mjs";
+import { g as chunkSlackTextAtHardLimit, h as buildSlackNativeDataDeliveryPlan, i as updateMessageSlack, t as sendMessageSlack } from "./send-WJZ73VSf.mjs";
+import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./monitor-BD86SotB.mjs";
+import { t as registerSlackQuestionDelivery } from "./question-delivery-D3qAIwuv.mjs";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
 import { deliverTextOrMediaReply, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
-import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";
+import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
 import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
 import { createAcceptedChannelDeliveryResult, createChannelPartialDeliveryError, getGroupThreadDeliverySession } from "openclaw/plugin-sdk/channel-inbound";
 import { buildCanonicalSentMessageHookContext, createInternalHookEvent, fireAndForgetHook, toInternalMessageSentContext, toPluginMessageContext, toPluginMessageSentEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
-//#region extensions/slack/src/message-sent-hook.ts
+// extensions/slack/src/message-sent-hook.ts
 function emitSlackMessageSentHooks(params) {
 	const hookRunner = getGlobalHookRunner();
 	const enabled = hookRunner?.hasHooks("message_sent") ?? false;
@@ -33,8 +35,7 @@ function emitSlackMessageSentHooks(params) {
 	if (enabled) fireAndForgetHook(Promise.resolve(hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical))), "slack: message_sent plugin hook failed");
 	if (params.sessionKeyForInternalHooks) fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "sent", params.sessionKeyForInternalHooks, toInternalMessageSentContext(canonical))), "slack: message:sent internal hook failed");
 }
-//#endregion
-//#region extensions/slack/src/monitor/replies.ts
+// 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) => ({
@@ -103,26 +104,37 @@ async function deliverReplies(params) {
 			replyToCurrent: payload.replyToCurrent
 		});
 		const reply = resolveSendableOutboundReplyParts(payload);
-		const textRaw = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
+		const textRaw = reply.hasText ? reply.trimmedText : void 0;
 		const { authoredTextPlacement, segments } = prepared.resolveDelivery();
+		const questionId = questionGatewayRuntime.readAskUserQuestionId(payload);
 		if (!textRaw && !reply.hasMedia && segments.length === 0) continue;
 		const acceptedResults = [];
 		const sendReply = async (input) => {
-			return await sendMessageSlack(params.target, input.text, {
+			const { text, ...options } = input;
+			return await sendMessageSlack(params.target, text, {
+				...options,
 				cfg: params.cfg,
 				token: params.token,
-				threadTs: input.threadTs,
 				accountId: params.accountId,
+				...mediaLocalRoots ? { mediaLocalRoots } : {},
 				onDeliveryResult: (result) => {
 					acceptedResults.push(result);
+					if (questionId) registerSlackQuestionDelivery({
+						questionId,
+						accountId: params.accountId,
+						result,
+						text,
+						update: async (message) => {
+							await updateMessageSlack({
+								...message,
+								cfg: params.cfg,
+								accountId: params.accountId,
+								token: params.token,
+								eventScope: params.eventScope
+							});
+						}
+					});
 				},
-				...input.mediaUrl ? { mediaUrl: input.mediaUrl } : {},
-				...mediaLocalRoots ? { mediaLocalRoots } : {},
-				...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,
@@ -221,9 +233,8 @@ async function deliverReplies(params) {
 	return latestResult;
 }
 function createSlackReplyDeliveryPlan(params) {
-	const effectiveMode = params.isThreadReply ?? Boolean(params.incomingThreadTs && params.incomingThreadTs !== params.messageTs) ? "all" : params.replyToMode;
 	const replyReference = createReplyReferencePlanner({
-		replyToMode: effectiveMode,
+		replyToMode: params.isThreadReply ? "all" : params.replyToMode,
 		existingId: params.incomingThreadTs,
 		startId: params.messageTs,
 		hasReplied: params.hasRepliedRef.value
@@ -260,9 +271,12 @@ async function deliverSlackSlashReplies(params) {
 	for (const [replyIndex, payload] of params.replies.entries()) {
 		if (payload.isReasoning === true) continue;
 		const reply = resolveSendableOutboundReplyParts(payload);
-		const textRaw = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
+		const textRaw = reply.hasText ? reply.trimmedText : void 0;
 		const materializeAuthoredText = hasSlackReplyStructuredContent(payload);
-		const { authoredTextPlacement, segments } = resolveSlackReplyBlockResolution(payload, { materializeAuthoredText });
+		const { authoredTextPlacement, segments } = resolveSlackReplyBlockResolution(payload, {
+			materializeAuthoredText,
+			tableMode: params.tableMode
+		});
 		if (segments.length > 0) {
 			const messages = [];
 			const hookParts = [];
@@ -421,5 +435,4 @@ async function deliverSlackSlashReplies(params) {
 		});
 	}
 }
-//#endregion
 export { emitSlackMessageSentHooks as a, sanitizeSlackMonitorReplyPayload as i, deliverReplies as n, deliverSlackSlashReplies as r, createSlackReplyDeliveryPlan as t };