@openclaw/slack 2026.10.10 → 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-DFBDTA5Z.mjs → relay-source-a8jodKuO.mjs}

@@ -1,11 +1,11 @@
-import { o as formatSlackError } from "./probe-C5VWf3sz.mjs";
-import { d as parseSlackMessageEvent, f as requireSlackMessageEvent, x as SLACK_SOCKET_RECONNECT_POLICY } from "./monitor-DsZUQtTM.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";
+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",
@@ -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);

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

@@ -1,14 +1,16 @@
-import { C as isSlackNativeResponseUrlRejection, M as SLACK_TEXT_LIMIT, S as isSlackInvalidBlocksResponse, Z as markdownToSlackMrkdwnChunks, b as hasSlackNativeDataBlock } from "./session-status-CHkEn3HM.mjs";
-import { n as iterateSlackReplyDeliveryMessages, o as resolveSlackReplyBlockResolution, t as hasSlackReplyStructuredContent } from "./reply-blocks-DOjiDr44.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 { h as chunkSlackTextAtHardLimit, m as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-C5uXkmZV.mjs";
-import { a as SlackResponseAlreadyReportedError, o as createSlackResponseUrlBudget } from "./monitor-DsZUQtTM.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";
@@ -102,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,
@@ -220,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
@@ -259,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 = [];