@openclaw/signal 2026.6.11 → 2026.7.1-beta.2

package/dist/{monitor-CUhIKHJo.js → monitor-C9SiyrFt.js}

@@ -1,16 +1,18 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { i as resolveSignalAccount } from "./accounts-hOCHbEhX.js";
+import { i as resolveSignalAccount } from "./accounts-B7Rz3_xV.js";
 import { a as normalizeSignalAllowRecipient, c as resolveSignalSender, d as normalizeSignalMessagingTarget, i as isSignalSenderAllowed, l as looksLikeUuid, n as formatSignalSenderDisplay, o as resolveSignalPeerId, r as formatSignalSenderId, s as resolveSignalRecipient, t as formatSignalPairingIdLine } from "./identity-B6O4k8xg.js";
-import { a as isSignalNativeApprovalHandlerConfigured } from "./message-actions-Bue0g2Kc.js";
-import { a as signalRpcRequest, i as signalCheck, o as streamSignalEvents } from "./reaction-runtime-api-C_PQ45D9.js";
-import { a as maybeResolveSignalApprovalReaction, n as sendReadReceiptSignal, r as sendTypingSignal, s as resolveSignalApprovalConversationKey, t as sendMessageSignal } from "./send-CBlFUkY_.js";
+import { a as isSignalNativeApprovalHandlerConfigured, n as resolveSignalReactionLevel } from "./message-actions-Cs9XckSd.js";
+import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-Dm8-wT2n.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BkAxQPGs.js";
+import { i as maybeResolveSignalApprovalReaction, o as registerSignalApprovalReactionTargetForDeliveredPayload, s as resolveSignalApprovalConversationKey, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-5x1kmQEq.js";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-CLzc3RUg.js";
 import { createChannelMessageReplyPipeline } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { detectMime, estimateBase64DecodedBytes, kindFromMime, saveMediaBuffer } from "openclaw/plugin-sdk/media-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
-import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
+import { normalizeE164, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import path from "node:path";
 import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
@@ -18,14 +20,14 @@ import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "opencla
 import { deliverTextOrMediaReply, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { chunkTextWithMode, createReplyDispatcherWithTyping, dispatchInboundMessage, resolveChunkMode, resolveTextChunkLimit, settleReplyDispatcher } from "openclaw/plugin-sdk/reply-runtime";
 import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
-import { computeBackoff, createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { computeBackoff, createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, sleep, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { waitForTransportReady } from "openclaw/plugin-sdk/transport-ready-runtime";
 import { spawn } from "node:child_process";
 import os from "node:os";
 import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
-import { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
-import { buildChannelInboundEventContext, buildMentionRegexes, createChannelInboundDebouncer, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, logInboundDrop, matchesMentionPatterns, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, runChannelInboundEvent, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
+import { DEFAULT_EMOJIS, DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
+import { buildChannelInboundEventContext, buildMentionRegexes, createChannelInboundDebouncer, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, hasVisibleInboundReplyDispatch, logInboundDrop, matchesMentionPatterns, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, runChannelInboundEvent, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-auth-native";
 import { recordInboundSession, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
 import { createInternalHookEvent, fireAndForgetHook, toInternalMessageReceivedContext, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
@@ -363,6 +365,42 @@ function resolveSignalInboundRoute(params) {
 		}
 	});
 }
+function resolveSignalStatusReactionTimestamp(params) {
+	if (typeof params.timestamp === "number") return Number.isFinite(params.timestamp) && params.timestamp > 0 ? params.timestamp : null;
+	const parsed = Number(params.messageId);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+function hasSignalStatusReplyDeliveryFailure(result) {
+	const failedCounts = result.failedCounts;
+	return (failedCounts?.tool ?? 0) > 0 || (failedCounts?.block ?? 0) > 0 || (failedCounts?.final ?? 0) > 0;
+}
+function resolveSignalStatusReactionEmojis(emojis) {
+	if (emojis?.stallHard !== void 0) return emojis;
+	return {
+		...emojis,
+		stallHard: DEFAULT_EMOJIS.stallSoft
+	};
+}
+async function finalizeSignalStatusReaction(params) {
+	if (params.outcome === "done") {
+		await params.controller.setDone();
+		if (params.removeAckAfterReply) {
+			await sleep(params.timing.doneHoldMs);
+			await params.controller.clear();
+		} else await params.controller.restoreInitial();
+		return;
+	}
+	await params.controller.setError();
+	if (params.hasFinalResponse) {
+		if (params.removeAckAfterReply) {
+			await sleep(params.timing.errorHoldMs);
+			await params.controller.clear();
+		} else await params.controller.restoreInitial();
+		return;
+	}
+	if (params.removeAckAfterReply) await sleep(params.timing.errorHoldMs);
+	await params.controller.restoreInitial();
+}
 function createSignalEventHandler(deps) {
 	async function handleSignalInboundMessage(entry) {
 		const fromLabel = formatInboundFromLabel({
@@ -473,9 +511,71 @@ function createSignalEventHandler(deps) {
 			extra: { GroupSubject: entry.isGroup ? entry.groupName ?? void 0 : void 0 }
 		});
 		if (shouldLogVerbose()) {
-			const preview = body.slice(0, 200).replace(/\\n/g, "\\\\n");
+			const preview = truncateUtf16Safe(body, 200).replace(/\\n/g, "\\\\n");
 			logVerbose(`signal inbound: from=${ctxPayload.From} len=${body.length} preview="${preview}"`);
 		}
+		const statusReactionTimestamp = resolveSignalStatusReactionTimestamp(entry);
+		const statusReactionsConfig = deps.cfg.messages?.statusReactions;
+		const signalReactionLevel = resolveSignalReactionLevel({
+			cfg: deps.cfg,
+			accountId: route.accountId
+		});
+		const ackReaction = resolveAckReaction(deps.cfg, route.agentId, {
+			channel: "signal",
+			accountId: route.accountId
+		});
+		const shouldSendStatusReaction = Boolean(ackReaction && shouldAckReaction({
+			scope: deps.cfg.messages?.ackReactionScope,
+			isDirect: !entry.isGroup,
+			isGroup: entry.isGroup,
+			isMentionableGroup: entry.isGroup,
+			requireMention: entry.requireMention === true,
+			canDetectMention: entry.canDetectMention === true,
+			effectiveWasMentioned: entry.wasMentioned === true
+		}));
+		const statusReactionTarget = `${entry.groupId ?? entry.senderRecipient}/${statusReactionTimestamp ?? "unknown"}`;
+		const signalReactionOpts = {
+			cfg: deps.cfg,
+			...deps.baseUrl ? { baseUrl: deps.baseUrl } : {},
+			...deps.account ? { account: deps.account } : {},
+			...deps.accountId ? { accountId: deps.accountId } : {},
+			...entry.isGroup && entry.groupId ? {
+				groupId: entry.groupId,
+				targetAuthor: entry.senderRecipient
+			} : {}
+		};
+		const statusReactionRecipient = entry.isGroup ? "" : entry.senderRecipient;
+		let currentStatusReactionEmoji = ackReaction;
+		const statusReactionController = statusReactionsConfig?.enabled === true && signalReactionLevel.level !== "off" && shouldSendStatusReaction && statusReactionTimestamp ? createStatusReactionController({
+			enabled: true,
+			adapter: {
+				setReaction: async (emoji) => {
+					await sendReactionSignal(statusReactionRecipient, statusReactionTimestamp, emoji, signalReactionOpts);
+					currentStatusReactionEmoji = emoji;
+				},
+				clearReaction: async () => {
+					if (!currentStatusReactionEmoji) return;
+					await removeReactionSignal(statusReactionRecipient, statusReactionTimestamp, currentStatusReactionEmoji, signalReactionOpts);
+					currentStatusReactionEmoji = "";
+				}
+			},
+			initialEmoji: ackReaction,
+			emojis: resolveSignalStatusReactionEmojis(statusReactionsConfig.emojis),
+			timing: statusReactionsConfig.timing,
+			onError: (err) => {
+				logAckFailure({
+					log: logVerbose,
+					channel: "signal",
+					target: statusReactionTarget,
+					error: err
+				});
+			}
+		}) : null;
+		const statusReactionTiming = {
+			...DEFAULT_TIMING,
+			...statusReactionsConfig?.timing
+		};
+		if (statusReactionController) statusReactionController.setQueued();
 		const { onModelSelected, typingCallbacks, ...replyPipeline } = createChannelMessageReplyPipeline({
 			cfg: deps.cfg,
 			agentId: route.agentId,
@@ -583,6 +683,7 @@ function createSignalEventHandler(deps) {
 					}),
 					runDispatch: async () => {
 						try {
+							if (statusReactionController) statusReactionController.setThinking();
 							return await dispatchInboundMessage({
 								ctx: ctxPayload,
 								cfg: deps.cfg,
@@ -590,6 +691,21 @@ function createSignalEventHandler(deps) {
 								replyOptions: {
 									...replyOptions,
 									disableBlockStreaming: typeof deps.blockStreaming === "boolean" ? !deps.blockStreaming : void 0,
+									...statusReactionController ? {
+										allowProgressCallbacksWhenSourceDeliverySuppressed: true,
+										allowToolLifecycleWhenProgressHidden: true,
+										onToolStart: async (payload) => {
+											const toolName = payload.name?.trim();
+											if (toolName) await statusReactionController.setTool(toolName);
+										},
+										onCompactionStart: async () => {
+											await statusReactionController.setCompacting();
+										},
+										onCompactionEnd: async () => {
+											statusReactionController.cancelPending();
+											await statusReactionController.setThinking();
+										}
+									} : {},
 									onModelSelected
 								}
 							});
@@ -597,7 +713,21 @@ function createSignalEventHandler(deps) {
 							markDispatchIdle();
 						}
 					}
-				})
+				}),
+				onFinalize: (result) => {
+					if (!statusReactionController) return;
+					const hasFinalResponse = result.dispatched && hasVisibleInboundReplyDispatch(result.dispatchResult);
+					const hasDeliveryFailure = result.dispatched && hasSignalStatusReplyDeliveryFailure(result.dispatchResult);
+					finalizeSignalStatusReaction({
+						controller: statusReactionController,
+						outcome: hasFinalResponse && !hasDeliveryFailure ? "done" : "error",
+						hasFinalResponse,
+						removeAckAfterReply: deps.cfg.messages?.removeAckAfterReply ?? false,
+						timing: statusReactionTiming
+					}).catch((err) => {
+						logVerbose(`signal: status reaction finalize failed: ${String(err)}`);
+					});
+				}
 			}
 		});
 	}
@@ -930,9 +1060,9 @@ function createSignalEventHandler(deps) {
 		}
 		const bodyText = messageText || placeholder || visibleQuoteText || "";
 		if (!bodyText) return;
-		const receiptTimestamp = typeof envelope.timestamp === "number" ? envelope.timestamp : typeof dataMessage.timestamp === "number" ? dataMessage.timestamp : void 0;
-		if (deps.sendReadReceipts && !deps.readReceiptsViaDaemon && !isGroup && receiptTimestamp) try {
-			await sendReadReceiptSignal(`signal:${senderRecipient}`, receiptTimestamp, {
+		const inboundTimestamp = typeof envelope.timestamp === "number" ? envelope.timestamp : typeof dataMessage.timestamp === "number" ? dataMessage.timestamp : void 0;
+		if (deps.sendReadReceipts && !deps.readReceiptsViaDaemon && !isGroup && inboundTimestamp) try {
+			await sendReadReceiptSignal(`signal:${senderRecipient}`, inboundTimestamp, {
 				cfg: deps.cfg,
 				baseUrl: deps.baseUrl,
 				account: deps.account,
@@ -941,9 +1071,9 @@ function createSignalEventHandler(deps) {
 		} catch (err) {
 			logVerbose(`signal read receipt failed for ${senderDisplay}: ${String(err)}`);
 		}
-		else if (deps.sendReadReceipts && !deps.readReceiptsViaDaemon && !isGroup && !receiptTimestamp) logVerbose(`signal read receipt skipped (missing timestamp) for ${senderDisplay}`);
+		else if (deps.sendReadReceipts && !deps.readReceiptsViaDaemon && !isGroup && !inboundTimestamp) logVerbose(`signal read receipt skipped (missing timestamp) for ${senderDisplay}`);
 		const senderName = envelope.sourceName ?? senderDisplay;
-		const messageId = typeof envelope.timestamp === "number" ? String(envelope.timestamp) : void 0;
+		const messageId = typeof inboundTimestamp === "number" ? String(inboundTimestamp) : void 0;
 		await inboundDebouncer.enqueue({
 			senderName,
 			senderDisplay,
@@ -954,13 +1084,15 @@ function createSignalEventHandler(deps) {
 			isGroup,
 			bodyText,
 			commandBody: messageText,
-			timestamp: envelope.timestamp ?? void 0,
+			timestamp: inboundTimestamp,
 			messageId,
 			mediaPath,
 			mediaType,
 			mediaPaths: mediaPaths.length > 0 ? mediaPaths : void 0,
 			mediaTypes: mediaTypes.length > 0 ? mediaTypes : void 0,
 			commandAuthorized,
+			canDetectMention,
+			requireMention,
 			wasMentioned: effectiveWasMentioned,
 			replyToBody: visibleQuoteText || void 0,
 			replyToSender: visibleQuoteSender,
@@ -1026,7 +1158,10 @@ async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEven
 }
 //#endregion
 //#region extensions/signal/src/monitor.ts
-var monitor_exports = /* @__PURE__ */ __exportAll({ monitorSignalProvider: () => monitorSignalProvider });
+var monitor_exports = /* @__PURE__ */ __exportAll({
+	deliverReplies: () => deliverReplies,
+	monitorSignalProvider: () => monitorSignalProvider
+});
 function resolveRuntime(opts) {
 	return opts.runtime ?? createNonExitingRuntime();
 }
@@ -1220,30 +1355,63 @@ async function fetchAttachment(params) {
 }
 async function deliverReplies(params) {
 	const { replies, target, baseUrl, account, accountId, runtime, maxBytes, textLimit, chunkMode } = params;
-	for (const payload of replies) if (await deliverTextOrMediaReply({
-		payload,
-		text: resolveSendableOutboundReplyParts(payload).text,
-		chunkText: (value) => chunkTextWithMode(value, textLimit, chunkMode),
-		sendText: async (chunk) => {
-			await sendMessageSignal(target, chunk, {
-				cfg: params.cfg,
-				baseUrl,
-				account,
-				maxBytes,
-				accountId
+	for (const payload of replies) {
+		const deliveryResults = [];
+		const deliveredPayload = addSignalApprovalReactionHintToStructuredPayload({
+			cfg: params.cfg,
+			accountId,
+			to: target,
+			payload,
+			targetAuthor: account
+		}) ?? payload;
+		const reply = resolveSendableOutboundReplyParts(deliveredPayload);
+		const recordDeliveryResult = (result, visibleText) => {
+			const messageId = typeof result?.messageId === "string" && result.messageId.trim() ? result.messageId.trim() : null;
+			if (messageId) deliveryResults.push({
+				channel: "signal",
+				messageId,
+				meta: { signalVisibleText: visibleText }
 			});
-		},
-		sendMedia: async ({ mediaUrl, caption }) => {
-			await sendMessageSignal(target, caption ?? "", {
+		};
+		if (await deliverTextOrMediaReply({
+			payload: deliveredPayload,
+			text: reply.text,
+			chunkText: (value) => chunkTextWithMode(value, textLimit, chunkMode),
+			sendText: async (chunk) => {
+				recordDeliveryResult(await sendMessageSignal(target, chunk, {
+					cfg: params.cfg,
+					baseUrl,
+					account,
+					maxBytes,
+					accountId
+				}), chunk);
+			},
+			sendMedia: async ({ mediaUrl, caption }) => {
+				const visibleText = caption ?? "";
+				recordDeliveryResult(await sendMessageSignal(target, visibleText, {
+					cfg: params.cfg,
+					baseUrl,
+					account,
+					mediaUrl,
+					maxBytes,
+					accountId
+				}), visibleText);
+			}
+		}) !== "empty") {
+			registerSignalApprovalReactionTargetForDeliveredPayload({
 				cfg: params.cfg,
-				baseUrl,
-				account,
-				mediaUrl,
-				maxBytes,
-				accountId
+				target: {
+					channel: "signal",
+					to: target,
+					accountId
+				},
+				payload: deliveredPayload,
+				results: deliveryResults,
+				targetAuthor: account
 			});
+			runtime.log?.(`delivered reply to ${target}`);
 		}
-	}) !== "empty") runtime.log?.(`delivered reply to ${target}`);
+	}
 }
 async function monitorSignalProvider(opts = {}) {
 	const runtime = resolveRuntime(opts);

package/dist/{probe-BQ_Izoya.js → probe-BL2BqTbG.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as signalRpcRequest, i as signalCheck } from "./reaction-runtime-api-C_PQ45D9.js";
+import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-Dm8-wT2n.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 //#region extensions/signal/src/probe.ts
 var probe_exports = /* @__PURE__ */ __exportAll({ probeSignal: () => probeSignal });

package/dist/reaction-runtime-api-BkAxQPGs.js

@@ -0,0 +1,115 @@
+import { i as resolveSignalAccount } from "./accounts-B7Rz3_xV.js";
+import { n as signalRpcRequest } from "./client-adapter-Dm8-wT2n.js";
+import { t as resolveSignalRpcContext } from "./rpc-context-DbFMe7am.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+//#region extensions/signal/src/send-reactions.ts
+function normalizeSignalId(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	return trimmed.replace(/^signal:/i, "").trim();
+}
+function normalizeSignalUuid(raw) {
+	const trimmed = normalizeSignalId(raw);
+	if (!trimmed) return "";
+	if (normalizeLowercaseStringOrEmpty(trimmed).startsWith("uuid:")) return trimmed.slice(5).trim();
+	return trimmed;
+}
+function resolveTargetAuthorParams(params) {
+	const candidates = [
+		params.targetAuthor,
+		params.targetAuthorUuid,
+		params.fallback
+	];
+	for (const candidate of candidates) {
+		const raw = candidate?.trim();
+		if (!raw) continue;
+		const normalized = normalizeSignalUuid(raw);
+		if (normalized) return { targetAuthor: normalized };
+	}
+	return {};
+}
+async function sendReactionSignalCore(params) {
+	const cfg = requireRuntimeConfig(params.opts.cfg, "Signal reactions");
+	const apiMode = cfg.channels?.signal?.apiMode;
+	const accountInfo = resolveSignalAccount({
+		cfg,
+		accountId: params.opts.accountId
+	});
+	const { baseUrl, account } = resolveSignalRpcContext(params.opts, accountInfo);
+	const normalizedRecipient = normalizeSignalUuid(params.recipient);
+	const groupId = params.opts.groupId?.trim();
+	if (!normalizedRecipient && !groupId) throw new Error(params.errors.missingRecipient);
+	if (!Number.isFinite(params.targetTimestamp) || params.targetTimestamp <= 0) throw new Error(params.errors.invalidTargetTimestamp);
+	const normalizedEmoji = params.emoji?.trim();
+	if (!normalizedEmoji) throw new Error(params.errors.missingEmoji);
+	const targetAuthorParams = resolveTargetAuthorParams({
+		targetAuthor: params.opts.targetAuthor,
+		targetAuthorUuid: params.opts.targetAuthorUuid,
+		fallback: normalizedRecipient
+	});
+	if (groupId && !targetAuthorParams.targetAuthor) throw new Error(params.errors.missingTargetAuthor);
+	const requestParams = {
+		emoji: normalizedEmoji,
+		targetTimestamp: params.targetTimestamp,
+		...params.remove ? { remove: true } : {},
+		...targetAuthorParams
+	};
+	if (normalizedRecipient) requestParams.recipients = [normalizedRecipient];
+	if (groupId) requestParams.groupIds = [groupId];
+	if (account) requestParams.account = account;
+	return {
+		ok: true,
+		timestamp: (await signalRpcRequest("sendReaction", requestParams, {
+			baseUrl,
+			timeoutMs: params.opts.timeoutMs,
+			apiMode
+		}))?.timestamp
+	};
+}
+/**
+* Send a Signal reaction to a message
+* @param recipient - UUID or E.164 phone number of the message author
+* @param targetTimestamp - Message ID (timestamp) to react to
+* @param emoji - Emoji to react with
+* @param opts - Optional account/connection overrides
+*/
+async function sendReactionSignal(recipient, targetTimestamp, emoji, opts) {
+	return await sendReactionSignalCore({
+		recipient,
+		targetTimestamp,
+		emoji,
+		remove: false,
+		opts,
+		errors: {
+			missingRecipient: "Recipient or groupId is required for Signal reaction",
+			invalidTargetTimestamp: "Valid targetTimestamp is required for Signal reaction",
+			missingEmoji: "Emoji is required for Signal reaction",
+			missingTargetAuthor: "targetAuthor is required for group reactions"
+		}
+	});
+}
+/**
+* Remove a Signal reaction from a message
+* @param recipient - UUID or E.164 phone number of the message author
+* @param targetTimestamp - Message ID (timestamp) to remove reaction from
+* @param emoji - Emoji to remove
+* @param opts - Optional account/connection overrides
+*/
+async function removeReactionSignal(recipient, targetTimestamp, emoji, opts) {
+	return await sendReactionSignalCore({
+		recipient,
+		targetTimestamp,
+		emoji,
+		remove: true,
+		opts,
+		errors: {
+			missingRecipient: "Recipient or groupId is required for Signal reaction removal",
+			invalidTargetTimestamp: "Valid targetTimestamp is required for Signal reaction removal",
+			missingEmoji: "Emoji is required for Signal reaction removal",
+			missingTargetAuthor: "targetAuthor is required for group reaction removal"
+		}
+	});
+}
+//#endregion
+export { sendReactionSignal as n, removeReactionSignal as t };

package/dist/reaction-runtime-api.js

@@ -1,2 +1,2 @@
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-C_PQ45D9.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BkAxQPGs.js";
 export { removeReactionSignal, sendReactionSignal };

package/dist/rpc-context-DbFMe7am.js

@@ -0,0 +1,17 @@
+import "./accounts-B7Rz3_xV.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/signal/src/rpc-context.ts
+function resolveSignalRpcContext(opts, accountInfo) {
+	const hasBaseUrl = Boolean(normalizeOptionalString(opts.baseUrl));
+	const hasAccount = Boolean(normalizeOptionalString(opts.account));
+	if ((!hasBaseUrl || !hasAccount) && !accountInfo) throw new Error("Signal account config is required when baseUrl or account is missing");
+	const resolvedAccount = accountInfo;
+	const baseUrl = normalizeOptionalString(opts.baseUrl) ?? resolvedAccount?.baseUrl;
+	if (!baseUrl) throw new Error("Signal base URL is required");
+	return {
+		baseUrl,
+		account: normalizeOptionalString(opts.account) ?? normalizeOptionalString(resolvedAccount?.config.account)
+	};
+}
+//#endregion
+export { resolveSignalRpcContext as t };

package/dist/runtime-api.js

@@ -1,12 +1,13 @@
-import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-hOCHbEhX.js";
+import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-B7Rz3_xV.js";
 import { d as normalizeSignalMessagingTarget, u as looksLikeSignalTargetId } from "./identity-B6O4k8xg.js";
-import { n as resolveSignalReactionLevel, t as signalMessageActions } from "./message-actions-Bue0g2Kc.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-C_PQ45D9.js";
+import { n as resolveSignalReactionLevel, t as signalMessageActions } from "./message-actions-Cs9XckSd.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BkAxQPGs.js";
 import { n as buildChannelConfigSchema, t as SignalConfigSchema } from "./config-api-KS-qhQvD.js";
-import { r as installSignalCli } from "./install-signal-cli-CXgTF3de.js";
-import { t as monitorSignalProvider } from "./monitor-CUhIKHJo.js";
-import { t as sendMessageSignal, u as setSignalRuntime } from "./send-CBlFUkY_.js";
-import { t as probeSignal } from "./probe-BQ_Izoya.js";
+import { r as installSignalCli } from "./install-signal-cli-TwhJ0DGy.js";
+import { u as setSignalRuntime } from "./approval-reactions-5x1kmQEq.js";
+import { t as monitorSignalProvider } from "./monitor-C9SiyrFt.js";
+import { t as sendMessageSignal } from "./send-CLzc3RUg.js";
+import { t as probeSignal } from "./probe-BL2BqTbG.js";
 import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
 import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
 import { buildBaseAccountStatusSnapshot, buildBaseChannelStatusSummary, collectStatusIssuesFromLastError, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";