@openclaw/signal 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/question-reactions-ByjH5qST.js

@@ -0,0 +1,80 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { o as resolveSignalTarget } from "./runtime-JPrGlV7h.js";
+import { l as resolveSignalApprovalConversationKey, u as resolveSignalApprovalTargetAuthorKeys } from "./approval-reactions-BulCzhdB.js";
+import { createQuestionReactionTargetStore, questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+//#region extensions/signal/src/question-reactions.ts
+var question_reactions_exports = /* @__PURE__ */ __exportAll({
+	maybeResolveSignalQuestionReaction: () => maybeResolveSignalQuestionReaction,
+	registerSignalQuestionReactionTargetForDeliveredPayload: () => registerSignalQuestionReactionTargetForDeliveredPayload
+});
+function buildKey(identity) {
+	const values = [
+		identity.accountId,
+		identity.conversationKey,
+		identity.messageId
+	].map((value) => value.trim());
+	return values.every(Boolean) ? values.join(":") : null;
+}
+const questionReactionTargets = createQuestionReactionTargetStore({
+	channel: "signal",
+	channelDisplayName: "Signal",
+	buildKey,
+	identityMatches: (stored, incoming) => Boolean(stored && incoming?.some((authorKey) => stored.includes(authorKey))),
+	registerChannelDelivery: questionGatewayRuntime.registerChannelDelivery,
+	resolveReaction: questionGatewayRuntime.resolveReaction
+});
+function resolveConversationKey(params) {
+	try {
+		return resolveSignalTarget({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			input: params.to
+		})?.to ?? resolveSignalApprovalConversationKey(params.to);
+	} catch {
+		return resolveSignalApprovalConversationKey(params.to);
+	}
+}
+function registerSignalQuestionReactionTargetForDeliveredPayload(params) {
+	const binding = questionGatewayRuntime.readReactionBinding(params.payload);
+	if (params.target.channel !== "signal" || !binding) return false;
+	const conversationKey = resolveConversationKey({
+		cfg: params.cfg,
+		...params.target
+	});
+	const targetAuthorKeys = resolveSignalApprovalTargetAuthorKeys(params);
+	if (!conversationKey || targetAuthorKeys.length === 0) return false;
+	const accountId = normalizeAccountId(params.target.accountId ?? void 0);
+	let registered = false;
+	for (const result of params.results) {
+		const messageId = result.channel === "signal" ? result.messageId.trim() : "";
+		if (!messageId || messageId === "unknown") continue;
+		registered = questionReactionTargets.register(binding, {
+			accountId,
+			conversationKey,
+			messageId
+		}, targetAuthorKeys) || registered;
+	}
+	return registered;
+}
+async function maybeResolveSignalQuestionReaction(params) {
+	if (params.isRemove) return false;
+	const optionIndex = questionGatewayRuntime.resolveReactionIndex(params.reactionKey);
+	if (optionIndex === void 0) return false;
+	const authorKeys = resolveSignalApprovalTargetAuthorKeys(params);
+	return await questionReactionTargets.resolve({
+		identities: [{
+			accountId: params.accountId,
+			conversationKey: params.conversationKey,
+			messageId: params.messageId
+		}],
+		optionIndex,
+		cfg: params.cfg,
+		senderId: params.actorId,
+		gatewayUrl: params.gatewayUrl,
+		metadata: authorKeys,
+		logDebug: params.logDebug
+	});
+}
+//#endregion
+export { question_reactions_exports as n, registerSignalQuestionReactionTargetForDeliveredPayload as r, maybeResolveSignalQuestionReaction as t };

package/dist/{reaction-runtime-api-BjeDyKcz.js → reaction-runtime-api-Cf6QHcE5.js}

@@ -1,5 +1,5 @@
 import { i as resolveSignalAccount } from "./accounts-DrStJjiK.js";
-import { n as signalRpcRequest } from "./client-adapter-mXGeEHQJ.js";
+import { n as signalRpcRequest } from "./client-adapter-D9SNPaNx.js";
 import { t as resolveSignalRpcContext } from "./rpc-context-CZUoE0-A.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
@@ -37,16 +37,17 @@ async function sendReactionSignalCore(params) {
 	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 operation = `Signal reaction${params.remove ? " removal" : ""}`;
+	if (!normalizedRecipient && !groupId) throw new Error(`Recipient or groupId is required for ${operation}`);
+	if (!Number.isFinite(params.targetTimestamp) || params.targetTimestamp <= 0) throw new Error(`Valid targetTimestamp is required for ${operation}`);
 	const normalizedEmoji = params.emoji?.trim();
-	if (!normalizedEmoji) throw new Error(params.errors.missingEmoji);
+	if (!normalizedEmoji) throw new Error(`Emoji is required for ${operation}`);
 	const targetAuthorParams = resolveTargetAuthorParams({
 		targetAuthor: params.opts.targetAuthor,
 		targetAuthorUuid: params.opts.targetAuthorUuid,
 		fallback: normalizedRecipient
 	});
-	if (groupId && !targetAuthorParams.targetAuthor) throw new Error(params.errors.missingTargetAuthor);
+	if (groupId && !targetAuthorParams.targetAuthor) throw new Error(`targetAuthor is required for group reaction${params.remove ? " removal" : "s"}`);
 	const requestParams = {
 		emoji: normalizedEmoji,
 		targetTimestamp: params.targetTimestamp,
@@ -78,13 +79,7 @@ async function sendReactionSignal(recipient, targetTimestamp, emoji, opts) {
 		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"
-		}
+		opts
 	});
 }
 /**
@@ -100,13 +95,7 @@ async function removeReactionSignal(recipient, targetTimestamp, emoji, opts) {
 		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"
-		}
+		opts
 	});
 }
 //#endregion

package/dist/reaction-runtime-api.js

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

package/dist/runtime-api.js

@@ -1,13 +1,13 @@
 import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-DrStJjiK.js";
 import { d as normalizeSignalMessagingTarget, u as looksLikeSignalTargetId } from "./identity-BQ4OzXXk.js";
 import { n as setSignalRuntime } from "./runtime-JPrGlV7h.js";
-import { a as signalMessageActions, o as resolveSignalReactionLevel } from "./transport-detection-Da06-LOL.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BjeDyKcz.js";
-import { n as SignalConfigSchema } from "./config-schema-DLvpQPN5.js";
-import { i as installSignalCli } from "./install-signal-cli-qJF7iC4h.js";
-import { t as monitorSignalProvider } from "./monitor-CHBkf7lk.js";
-import { t as sendMessageSignal } from "./send-B_Ks4MZr.js";
-import { t as probeSignal } from "./probe-Br9abaGp.js";
+import { a as signalMessageActions, o as resolveSignalReactionLevel } from "./transport-detection-BItHawMq.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-Cf6QHcE5.js";
+import { n as SignalConfigSchema } from "./config-schema-CkMIK7zp.js";
+import { i as installSignalCli } from "./install-signal-cli-Cpiyk0k1.js";
+import { t as monitorSignalProvider } from "./monitor-DiN2hKnG.js";
+import { t as sendMessageSignal } from "./send-BvGgByMd.js";
+import { t as probeSignal } from "./probe-C_THuQzn.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";

package/dist/{send-B_Ks4MZr.js → send-BvGgByMd.js}

@@ -1,9 +1,9 @@
 import { i as resolveSignalAccount } from "./accounts-DrStJjiK.js";
 import { d as normalizeSignalMessagingTarget } from "./identity-BQ4OzXXk.js";
-import { c as markdownToSignalText, n as registerSignalReplyContext } from "./transport-detection-Da06-LOL.js";
-import { n as signalRpcRequest } from "./client-adapter-mXGeEHQJ.js";
+import { c as markdownToSignalText, n as registerSignalReplyContext } from "./transport-detection-BItHawMq.js";
+import { n as signalRpcRequest } from "./client-adapter-D9SNPaNx.js";
 import { t as resolveSignalRpcContext } from "./rpc-context-CZUoE0-A.js";
-import { c as registerSignalApprovalReactionTargetForOutboundMessage, n as appendSignalApprovalReactionHintForOutboundMessage } from "./approval-reactions-DtL47gSK.js";
+import { c as registerSignalApprovalReactionTargetForOutboundMessage, n as appendSignalApprovalReactionHintForOutboundMessage } from "./approval-reactions-BulCzhdB.js";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { kindFromMime, resolveOutboundAttachmentFromUrl } from "openclaw/plugin-sdk/media-runtime";
@@ -113,6 +113,15 @@ function resolveSignalQuoteParams(opts) {
 }
 function isSignalQuoteMetadataRejection(error) {
 	const normalized = normalizeLowercaseStringOrEmpty(error instanceof Error ? error.message : String(error));
+	const rpcCode = /^signal rpc (-?\d+):/u.exec(normalized)?.[1];
+	if (rpcCode !== void 0) {
+		if (rpcCode !== "-32602") return false;
+	} else {
+		const restStatusText = /^signal rest (\d{3}):/u.exec(normalized)?.[1];
+		if (!restStatusText) return false;
+		const restStatus = Number(restStatusText);
+		if (restStatus < 400 || restStatus >= 500 || restStatus === 408 || restStatus === 429) return false;
+	}
 	if (!normalized.includes("quote")) return false;
 	return normalized.includes("reject") || normalized.includes("invalid") || normalized.includes("unrecognized") || normalized.includes("unsupported") || normalized.includes("not found") || normalized.includes("no such") || normalized.includes("unknown");
 }

package/dist/{send.runtime-CbuXycZT.js → send.runtime-CtTBBrjL.js}

@@ -1,2 +1,2 @@
-import { r as sendTypingSignal, t as sendMessageSignal } from "./send-B_Ks4MZr.js";
+import { r as sendTypingSignal, t as sendMessageSignal } from "./send-BvGgByMd.js";
 export { sendMessageSignal, sendTypingSignal };

package/dist/{transport-detection-Da06-LOL.js → transport-detection-BItHawMq.js}

@@ -2,7 +2,7 @@ import { u as normalizeSignalTransportUrl } from "./transport-policy-DxvSMHp9.js
 import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-DrStJjiK.js";
 import { d as normalizeSignalMessagingTarget } from "./identity-BQ4OzXXk.js";
 import { i as signalApprovalAuth, r as getSignalApprovalApprovers, t as getOptionalSignalRuntime } from "./runtime-JPrGlV7h.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BjeDyKcz.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-Cf6QHcE5.js";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { kindFromMime } from "openclaw/plugin-sdk/media-runtime";
 import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
@@ -10,9 +10,9 @@ import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { resolveReactionLevel } from "openclaw/plugin-sdk/status-helpers";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { FormatCapabilityProfile, markdownToIR, renderMarkdownIRChunksWithinLimit, renderMarkdownWithAttributedRanges } from "openclaw/plugin-sdk/text-chunking";
-import { createChannelApprovalCapability } from "openclaw/plugin-sdk/approval-delivery-runtime";
+import { createApproverRestrictedNativeApprovalCapabilityFromForwardingRoutes } from "openclaw/plugin-sdk/approval-delivery-runtime";
 import { createLazyChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
-import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, createNativeApprovalChannelRouteGates, createNativeApprovalForwardingFallbackSuppressor, createNativeApprovalMessagingTargetResolvers, shouldSuppressLocalNativeExecApprovalPrompt } from "openclaw/plugin-sdk/approval-native-runtime";
+import { shouldSuppressLocalNativeExecApprovalPrompt } from "openclaw/plugin-sdk/approval-native-runtime";
 import { buildApprovalReactionPendingContentForRequest } from "openclaw/plugin-sdk/approval-reaction-runtime";
 import { formatMediaPlaceholderText } from "openclaw/plugin-sdk/channel-inbound";
 import { createActionGate, jsonResult, readStringParam, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
@@ -20,28 +20,60 @@ import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtim
 import { getExecApprovalReplyMetadata } from "openclaw/plugin-sdk/approval-reply-runtime";
 import { isMessagePresentationInteractiveBlock, normalizeMessagePresentation, renderMessagePresentationFallbackText } from "openclaw/plugin-sdk/interactive-runtime";
 //#region extensions/signal/src/approval-native.ts
-const DEFAULT_APPROVAL_FORWARDING_MODE = "session";
-const { normalizeForwardTarget: normalizeSignalForwardTarget, normalizeTarget: normalizeSignalApprovalTarget, resolveSessionTarget: resolveSessionSignalOriginTarget, resolveTurnSourceTarget: resolveTurnSourceSignalOriginTarget } = createNativeApprovalMessagingTargetResolvers({
-	channel: "signal",
-	normalizeTo: normalizeSignalMessagingTarget
-});
 function isSignalApprovalTransportEnabled(params) {
 	return resolveSignalAccount({
 		cfg: params.cfg,
 		accountId: params.accountId
 	}).enabled;
 }
-const { canApprovalPotentiallyRouteToChannel: canApprovalPotentiallyRouteToSignal, canAnyApprovalPotentiallyRouteToChannel: canAnyApprovalPotentiallyRouteToSignal, isNativeApprovalHandlerConfigured: isSignalNativeApprovalHandlerConfiguredBase, isSessionApprovalEligible: isSignalSessionApprovalEligible, shouldHandleApprovalRequest: shouldHandleSignalApprovalRequest } = createNativeApprovalChannelRouteGates({
+const signalApproval = createApproverRestrictedNativeApprovalCapabilityFromForwardingRoutes({
 	channel: "signal",
-	defaultForwardingMode: DEFAULT_APPROVAL_FORWARDING_MODE,
-	isTransportEnabled: isSignalApprovalTransportEnabled,
-	listAccountIds: listSignalAccountIds,
-	resolveDefaultAccountId: resolveDefaultSignalAccountId,
-	normalizeForwardTarget: normalizeSignalForwardTarget,
-	resolveTurnSourceTarget: resolveTurnSourceSignalOriginTarget
+	channelLabel: "Signal",
+	authorizeActorAction: (params) => signalApprovalAuth.authorizeActorAction(params),
+	routing: {
+		defaultForwardingMode: "session",
+		isTransportEnabled: isSignalApprovalTransportEnabled,
+		listAccountIds: listSignalAccountIds,
+		resolveDefaultAccountId: resolveDefaultSignalAccountId,
+		normalizeTo: normalizeSignalMessagingTarget,
+		resolveApprovers: getSignalApprovalApprovers,
+		suppressExplicitTargetFallback: false,
+		isOriginTargetAllowed: ({ cfg, accountId, target }) => !isSignalGroupTarget(target.to) || getSignalApprovalApprovers({
+			cfg,
+			accountId
+		}).length > 0
+	},
+	describeExecApprovalSetup: ({ accountId }) => {
+		return `Signal supports native exec approvals for this account when \`approvals.exec.enabled\` is true and the route allows Signal. Link Signal and keep the gateway running; configure \`${accountId && accountId !== "default" ? `channels.signal.accounts.${accountId}` : "channels.signal"}.allowFrom\` to restrict approvers.`;
+	},
+	render: {
+		exec: { buildPendingPayload: ({ request, nowMs }) => buildApprovalReactionPendingContentForRequest({
+			request,
+			nowMs
+		}).manualFallbackPayload },
+		plugin: { buildPendingPayload: ({ request, nowMs }) => buildApprovalReactionPendingContentForRequest({
+			request,
+			nowMs
+		}).manualFallbackPayload }
+	},
+	createNativeRuntime: (routing) => createLazyChannelApprovalNativeRuntimeAdapter({
+		eventKinds: ["exec", "plugin"],
+		isConfigured: ({ cfg, accountId, context }) => Boolean(context) && routing.isNativeApprovalHandlerConfigured({
+			cfg,
+			accountId
+		}),
+		shouldHandle: ({ cfg, accountId, context, approvalKind, request }) => Boolean(context) && routing.shouldHandleApprovalRequest({
+			cfg,
+			accountId,
+			approvalKind,
+			request
+		}),
+		load: async () => (await import("./approval-handler.runtime-Bi5yNhnj.js")).signalApprovalNativeRuntime
+	})
 });
+const signalApprovalRouting = signalApproval.routing;
 function isSignalNativeApprovalHandlerConfigured(params) {
-	return isSignalNativeApprovalHandlerConfiguredBase(params);
+	return signalApprovalRouting.isNativeApprovalHandlerConfigured(params);
 }
 function resolveSignalSessionTargetFromSessionKey(sessionKey) {
 	const rest = parseAgentSessionKey(sessionKey)?.rest ?? normalizeOptionalString(sessionKey);
@@ -62,137 +94,10 @@ function shouldSuppressLocalSignalExecApprovalPrompt(params) {
 		}
 	});
 }
-const resolveSignalOriginTargetBase = createChannelNativeOriginTargetResolver({
-	channel: "signal",
-	shouldHandleRequest: shouldHandleSignalApprovalRequest,
-	resolveTurnSourceTarget: resolveTurnSourceSignalOriginTarget,
-	resolveSessionTarget: resolveSessionSignalOriginTarget,
-	normalizeTarget: normalizeSignalApprovalTarget
-});
 function isSignalGroupTarget(to) {
 	return normalizeLowercaseStringOrEmpty(to).startsWith("group:");
 }
-function resolveSignalOriginTarget(params) {
-	const target = resolveSignalOriginTargetBase(params);
-	if (!target) return null;
-	if (isSignalGroupTarget(target.to) && getSignalApprovalApprovers({
-		cfg: params.cfg,
-		accountId: params.accountId
-	}).length === 0) return null;
-	return target;
-}
-const resolveSignalApproverDmTargets = createChannelApproverDmTargetResolver({
-	shouldHandleRequest: shouldHandleSignalApprovalRequest,
-	resolveApprovers: getSignalApprovalApprovers,
-	mapApprover: (approver, params) => {
-		const to = normalizeSignalMessagingTarget(approver);
-		if (!to) return null;
-		return {
-			to,
-			accountId: normalizeOptionalString(params.accountId)
-		};
-	}
-});
-const shouldSuppressSignalForwardingFallback = createNativeApprovalForwardingFallbackSuppressor({
-	channel: "signal",
-	normalizeForwardTarget: normalizeSignalForwardTarget,
-	resolveAccountId: ({ forwardingTarget, request }) => forwardingTarget.accountId ?? normalizeOptionalString(request.request.turnSourceAccountId),
-	resolveForwardingTargetForMatch: ({ forwardingTarget, accountId }) => ({
-		...forwardingTarget,
-		accountId
-	}),
-	isSessionRouteEligible: isSignalSessionApprovalEligible,
-	resolveOriginTarget: resolveSignalOriginTarget,
-	resolveApproverDmTargets: resolveSignalApproverDmTargets
-});
-function buildSignalExecPendingPayload(params) {
-	return buildApprovalReactionPendingContentForRequest(params).manualFallbackPayload;
-}
-function buildSignalPluginPendingPayload(params) {
-	return buildApprovalReactionPendingContentForRequest(params).manualFallbackPayload;
-}
-const signalApprovalCapability = createChannelApprovalCapability({
-	...signalApprovalAuth,
-	getActionAvailabilityState: ({ cfg, accountId, approvalKind }) => (approvalKind ? canApprovalPotentiallyRouteToSignal({
-		cfg,
-		accountId,
-		approvalKind
-	}) : canAnyApprovalPotentiallyRouteToSignal({
-		cfg,
-		accountId
-	})) ? { kind: "enabled" } : { kind: "disabled" },
-	getExecInitiatingSurfaceState: ({ cfg, accountId }) => canApprovalPotentiallyRouteToSignal({
-		cfg,
-		accountId,
-		approvalKind: "exec"
-	}) ? { kind: "enabled" } : { kind: "disabled" },
-	describeExecApprovalSetup: ({ accountId }) => {
-		return `Signal supports native exec approvals for this account when \`approvals.exec.enabled\` is true and the route allows Signal. Link Signal and keep the gateway running; configure \`${accountId && accountId !== "default" ? `channels.signal.accounts.${accountId}` : "channels.signal"}.allowFrom\` to restrict approvers.`;
-	},
-	delivery: {
-		hasConfiguredDmRoute: ({ cfg }) => listSignalAccountIds(cfg).some((accountId) => {
-			if (!canAnyApprovalPotentiallyRouteToSignal({
-				cfg,
-				accountId,
-				nativeSessionOnly: true
-			})) return false;
-			return getSignalApprovalApprovers({
-				cfg,
-				accountId
-			}).length > 0;
-		}),
-		shouldSuppressForwardingFallback: shouldSuppressSignalForwardingFallback
-	},
-	render: {
-		exec: { buildPendingPayload: ({ request, nowMs }) => buildSignalExecPendingPayload({
-			request,
-			nowMs
-		}) },
-		plugin: { buildPendingPayload: ({ request, nowMs }) => buildSignalPluginPendingPayload({
-			request,
-			nowMs
-		}) }
-	},
-	native: {
-		describeDeliveryCapabilities: ({ cfg, accountId, approvalKind, request }) => {
-			const originTarget = resolveSignalOriginTarget({
-				cfg,
-				accountId,
-				approvalKind,
-				request
-			});
-			const approverTargets = resolveSignalApproverDmTargets({
-				cfg,
-				accountId,
-				approvalKind,
-				request
-			});
-			return {
-				enabled: Boolean(originTarget) || approverTargets.length > 0,
-				preferredSurface: originTarget ? "origin" : "approver-dm",
-				supportsOriginSurface: Boolean(originTarget),
-				supportsApproverDmSurface: approverTargets.length > 0,
-				notifyOriginWhenDmOnly: true
-			};
-		},
-		resolveOriginTarget: resolveSignalOriginTarget,
-		resolveApproverDmTargets: resolveSignalApproverDmTargets
-	},
-	nativeRuntime: createLazyChannelApprovalNativeRuntimeAdapter({
-		eventKinds: ["exec", "plugin"],
-		isConfigured: ({ cfg, accountId, context }) => Boolean(context) && isSignalNativeApprovalHandlerConfigured({
-			cfg,
-			accountId
-		}),
-		shouldHandle: ({ cfg, accountId, context, approvalKind, request }) => Boolean(context) && shouldHandleSignalApprovalRequest({
-			cfg,
-			accountId,
-			approvalKind,
-			request
-		}),
-		load: async () => (await import("./approval-handler.runtime-C-XYgcxE.js")).signalApprovalNativeRuntime
-	})
-});
+const signalApprovalCapability = signalApproval.capability;
 //#endregion
 //#region extensions/signal/src/format.ts
 const SIGNAL_STYLE_MAP = {
@@ -633,7 +538,7 @@ const DEFAULT_PROBE_TIMEOUT_MS = 1e4;
 async function detectSignalTransport(params) {
 	const url = normalizeSignalTransportUrl(params.url);
 	const timeoutMs = params.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
-	const probes = params.probeNative && params.probeContainer ? void 0 : await import("./transport-probes.runtime-CV6Qs0Og.js");
+	const probes = params.probeNative && params.probeContainer ? void 0 : await import("./transport-probes.runtime-BsJdp0oI.js");
 	const probeNative = params.probeNative ?? probes?.nativeCheck;
 	const probeContainer = params.probeContainer ?? probes?.containerCheck;
 	if (!probeNative || !probeContainer) throw new Error("Signal transport probes are unavailable");

package/dist/{transport-detection.runtime-D_190UUL.js → transport-detection.runtime-DoiwPcrG.js}

@@ -1,2 +1,2 @@
-import { t as detectSignalTransport } from "./transport-detection-Da06-LOL.js";
+import { t as detectSignalTransport } from "./transport-detection-BItHawMq.js";
 export { detectSignalTransport };

package/dist/{transport-probes.runtime-CV6Qs0Og.js → transport-probes.runtime-BsJdp0oI.js}

@@ -1,2 +1,2 @@
-import { i as containerCheck, t as signalCheck } from "./client-BazXTH7O.js";
+import { i as containerCheck, t as signalCheck } from "./client-CvnR8_XA.js";
 export { containerCheck, signalCheck as nativeCheck };

package/openclaw.plugin.json

@@ -1,5 +1,8 @@
 {
   "id": "signal",
+  "doctorContract": {
+    "configRepair": true
+  },
   "icon": "https://cdn.simpleicons.org/signal",
   "activation": {
     "onStartup": false
@@ -1011,7 +1014,7 @@
         "additionalProperties": false
       },
       "label": "Signal",
-      "description": "signal-cli linked device; more setup (David Reagans: \"Hop on Discord.\").",
+      "description": "signal-cli linked device with additional setup for the local REST bridge.",
       "uiHints": {
         "": {
           "label": "Signal",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/signal",
-  "version": "2026.7.2-beta.5",
+  "version": "2026.8.1-beta.2",
   "description": "OpenClaw Signal channel plugin",
   "type": "module",
   "dependencies": {
@@ -25,7 +25,7 @@
       "detailLabel": "Signal REST",
       "docsPath": "/channels/signal",
       "docsLabel": "signal",
-      "blurb": "signal-cli linked device; more setup (David Reagans: \"Hop on Discord.\").",
+      "blurb": "signal-cli linked device with additional setup for the local REST bridge.",
       "systemImage": "antenna.radiowaves.left.and.right",
       "markdownCapable": true,
       "setup": {
@@ -93,10 +93,10 @@
       "allowInvalidConfigRecovery": true
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.5"
+      "pluginApi": ">=2026.8.1-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.5",
+      "openclawVersion": "2026.8.1-beta.2",
       "bundledDist": false
     },
     "release": {
@@ -118,7 +118,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.5"
+    "openclaw": ">=2026.8.1-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/dist/approval-resolver-B3m0D2R0.js

@@ -1,16 +0,0 @@
-import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
-import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
-//#region extensions/signal/src/approval-resolver.ts
-async function resolveSignalApproval(params) {
-	return await resolveApprovalOverGateway({
-		cfg: params.cfg,
-		approvalId: params.approvalId,
-		approvalKind: params.approvalKind,
-		decision: params.decision,
-		senderId: params.senderId,
-		gatewayUrl: params.gatewayUrl,
-		clientDisplayName: `Signal approval (${params.senderId?.trim() || "unknown"})`
-	});
-}
-//#endregion
-export { isApprovalNotFoundError, resolveSignalApproval };

package/dist/question-reactions-Ds48FtEu.js

@@ -1,109 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { o as resolveSignalTarget } from "./runtime-JPrGlV7h.js";
-import { l as resolveSignalApprovalConversationKey, u as resolveSignalApprovalTargetAuthorKeys } from "./approval-reactions-DtL47gSK.js";
-import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
-import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
-//#region extensions/signal/src/question-reactions.ts
-var question_reactions_exports = /* @__PURE__ */ __exportAll({
-	maybeResolveSignalQuestionReaction: () => maybeResolveSignalQuestionReaction,
-	registerSignalQuestionReactionTargetForDeliveredPayload: () => registerSignalQuestionReactionTargetForDeliveredPayload
-});
-const TARGET_TTL_MS = 1440 * 60 * 1e3;
-const targets = /* @__PURE__ */ new Map();
-function storeTarget(key, binding, targetAuthorKeys) {
-	const existing = targets.get(key);
-	if (existing) clearTimeout(existing.cleanupTimer);
-	const target = {
-		...binding,
-		targetAuthorKeys,
-		terminal: false,
-		expiresAtMs: Date.now() + TARGET_TTL_MS,
-		cleanupTimer: setTimeout(() => {
-			if (targets.get(key) === target) targets.delete(key);
-		}, TARGET_TTL_MS)
-	};
-	target.cleanupTimer.unref?.();
-	targets.set(key, target);
-	questionGatewayRuntime.registerChannelDelivery({
-		questionId: binding.questionId,
-		deliveryId: `signal-reaction:${key}`,
-		finalize: () => {
-			target.terminal = true;
-		}
-	});
-}
-function buildKey(accountId, conversationKey, messageId) {
-	const values = [
-		accountId,
-		conversationKey,
-		messageId
-	].map((value) => value.trim());
-	return values.every(Boolean) ? values.join(":") : null;
-}
-function resolveConversationKey(params) {
-	try {
-		return resolveSignalTarget({
-			cfg: params.cfg,
-			accountId: params.accountId,
-			input: params.to
-		})?.to ?? resolveSignalApprovalConversationKey(params.to);
-	} catch {
-		return resolveSignalApprovalConversationKey(params.to);
-	}
-}
-function registerSignalQuestionReactionTargetForDeliveredPayload(params) {
-	const binding = questionGatewayRuntime.readReactionBinding(params.payload);
-	if (params.target.channel !== "signal" || !binding) return false;
-	const conversationKey = resolveConversationKey({
-		cfg: params.cfg,
-		...params.target
-	});
-	const targetAuthorKeys = resolveSignalApprovalTargetAuthorKeys(params);
-	if (!conversationKey || targetAuthorKeys.length === 0) return false;
-	const accountId = normalizeAccountId(params.target.accountId ?? void 0);
-	let registered = false;
-	for (const result of params.results) {
-		const messageId = result.channel === "signal" ? result.messageId.trim() : "";
-		const key = messageId && messageId !== "unknown" ? buildKey(accountId, conversationKey, messageId) : null;
-		if (!key) continue;
-		storeTarget(key, binding, targetAuthorKeys);
-		registered = true;
-	}
-	return registered;
-}
-async function maybeResolveSignalQuestionReaction(params) {
-	if (params.isRemove) return false;
-	const optionIndex = questionGatewayRuntime.resolveReactionIndex(params.reactionKey);
-	const key = buildKey(params.accountId, params.conversationKey, params.messageId);
-	if (optionIndex === void 0 || !key) return false;
-	const target = targets.get(key);
-	if (!target) return false;
-	if (!resolveSignalApprovalTargetAuthorKeys(params).some((authorKey) => target.targetAuthorKeys.includes(authorKey))) return false;
-	if (target.expiresAtMs <= Date.now() || target.terminal) {
-		target.terminal = true;
-		params.logDebug?.(`signal: stale question reaction ignored id=${target.questionId}`);
-		return true;
-	}
-	const optionValue = target.optionValues[optionIndex];
-	if (!optionValue) {
-		params.logDebug?.(`signal: out-of-range question reaction ignored id=${target.questionId}`);
-		return true;
-	}
-	try {
-		const result = await questionGatewayRuntime.resolveReaction({
-			cfg: params.cfg,
-			questionId: target.questionId,
-			optionValue,
-			senderId: params.actorId,
-			gatewayUrl: params.gatewayUrl,
-			clientDisplayName: `Signal question (${params.actorId})`
-		});
-		target.terminal = result?.status === "answered" || result?.status === "already-terminal";
-		if (result?.status === "already-terminal") params.logDebug?.(`signal: stale question reaction ignored id=${target.questionId}`);
-	} catch (error) {
-		params.logDebug?.(`signal: question reaction failed id=${target.questionId}: ${String(error)}`);
-	}
-	return true;
-}
-//#endregion
-export { question_reactions_exports as n, registerSignalQuestionReactionTargetForDeliveredPayload as r, maybeResolveSignalQuestionReaction as t };