@openclaw/signal 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/{probe-Br9abaGp.js → probe-B0E_cXQw.js}

@@ -1,19 +1,26 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { t as detectSignalTransport } from "./transport-detection-Da06-LOL.js";
-import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-mXGeEHQJ.js";
+import { t as detectSignalTransport } from "./transport-detection-D_M79R5f.js";
+import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-D9SNPaNx.js";
 import { runChannelProbe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 //#region extensions/signal/src/probe.ts
-var probe_exports = /* @__PURE__ */ __exportAll({ probeSignal: () => probeSignal });
+var probe_exports = /* @__PURE__ */ __exportAll({
+	probeSignal: () => probeSignal,
+	probeSignalAccount: () => probeSignalAccount
+});
 function parseSignalVersion(value) {
 	if (typeof value === "string" && value.trim()) return value.trim();
 	if (typeof value === "object" && value !== null) {
-		const version = value.version;
+		const { version, versions } = value;
 		if (typeof version === "string" && version.trim()) return version.trim();
+		if (Array.isArray(versions)) {
+			const normalizedVersions = versions.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
+			if (normalizedVersions.length > 0) return normalizedVersions.join(", ");
+		}
 	}
 	return null;
 }
-async function probeSignal(baseUrl, timeoutMs, options = {}) {
+async function probeSignalTransport(baseUrl, timeoutMs, options, account) {
 	return await runChannelProbe(void 0, async () => {
 		const result = {
 			ok: false,
@@ -30,7 +37,10 @@ async function probeSignal(baseUrl, timeoutMs, options = {}) {
 				error: formatErrorMessage(error)
 			};
 		}
-		const check = await signalCheck(baseUrl, timeoutMs, { transportKind });
+		const check = await signalCheck(baseUrl, timeoutMs, {
+			transportKind,
+			...account && transportKind === "container" ? { account } : {}
+		});
 		if (!check.ok) return {
 			...result,
 			status: check.status ?? null,
@@ -47,11 +57,17 @@ async function probeSignal(baseUrl, timeoutMs, options = {}) {
 		}
 		return {
 			...result,
-			ok: true,
+			ok: result.error === null,
 			status: check.status ?? null
 		};
 	});
 }
+async function probeSignal(baseUrl, timeoutMs, options = {}) {
+	return await probeSignalTransport(baseUrl, timeoutMs, options);
+}
+async function probeSignalAccount(params) {
+	return await probeSignalTransport(params.baseUrl, params.timeoutMs, { transportKind: params.transportKind }, params.account);
+}
 async function resolveProbeTransportKind(baseUrl, timeoutMs, options) {
 	if (options.transportKind) return options.transportKind;
 	if (options.apiMode === "container") return "container";

package/dist/question-reactions-BaatFqJ7.js

@@ -0,0 +1,80 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { i as resolveSignalTarget } from "./approval-auth-BY6uuApE.js";
+import { c as resolveSignalApprovalTargetAuthorKeys, s as resolveSignalApprovalConversationKey } from "./approval-reactions-cs3Ox9Ow.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-YGD6hhDh.js}

@@ -1,6 +1,6 @@
-import { i as resolveSignalAccount } from "./accounts-DrStJjiK.js";
-import { n as signalRpcRequest } from "./client-adapter-mXGeEHQJ.js";
-import { t as resolveSignalRpcContext } from "./rpc-context-CZUoE0-A.js";
+import { i as resolveSignalAccount } from "./accounts-DO4HMqaK.js";
+import { n as signalRpcRequest } from "./client-adapter-D9SNPaNx.js";
+import { t as resolveSignalRpcContext } from "./rpc-context-dXSy4NtF.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
@@ -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-YGD6hhDh.js";
 export { removeReactionSignal, sendReactionSignal };

package/dist/rpc-context-dXSy4NtF.js

@@ -0,0 +1,15 @@
+import "./accounts-DO4HMqaK.js";
+//#region extensions/signal/src/rpc-context.ts
+function resolveSignalRpcContext(opts, accountInfo) {
+	const baseUrlOverride = opts.baseUrl?.trim();
+	const accountOverride = opts.account?.trim();
+	if ((!baseUrlOverride || !accountOverride) && !accountInfo) throw new Error("Signal account config is required when baseUrl or account is missing");
+	const baseUrl = baseUrlOverride || accountInfo?.baseUrl;
+	if (!baseUrl) throw new Error("Signal base URL is required");
+	return {
+		baseUrl,
+		account: accountOverride || accountInfo?.config.account?.trim() || void 0
+	};
+}
+//#endregion
+export { resolveSignalRpcContext as t };

package/dist/runtime-api.js

@@ -1,13 +1,12 @@
-import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-DrStJjiK.js";
+import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-DO4HMqaK.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-Y3dFGwdL.js";
-import { i as installSignalCli } from "./install-signal-cli-qJF7iC4h.js";
-import { t as monitorSignalProvider } from "./monitor-BvIzkrYW.js";
-import { t as sendMessageSignal } from "./send-B_Ks4MZr.js";
-import { t as probeSignal } from "./probe-Br9abaGp.js";
+import { a as setSignalRuntime, c as resolveSignalReactionLevel, s as signalMessageActions } from "./transport-detection-D_M79R5f.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-YGD6hhDh.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-BLFIkpH0.js";
+import { t as sendMessageSignal } from "./send-BNl5folj.js";
+import { t as probeSignal } from "./probe-B0E_cXQw.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-BNl5folj.js}

@@ -1,9 +1,8 @@
-import { i as resolveSignalAccount } from "./accounts-DrStJjiK.js";
+import { i as resolveSignalAccount } from "./accounts-DO4HMqaK.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 { t as resolveSignalRpcContext } from "./rpc-context-CZUoE0-A.js";
-import { c as registerSignalApprovalReactionTargetForOutboundMessage, n as appendSignalApprovalReactionHintForOutboundMessage } from "./approval-reactions-DtL47gSK.js";
+import { n as registerSignalReplyContext, u as markdownToSignalText } from "./transport-detection-D_M79R5f.js";
+import { n as signalRpcRequest } from "./client-adapter-D9SNPaNx.js";
+import { t as resolveSignalRpcContext } from "./rpc-context-dXSy4NtF.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 +112,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");
 }
@@ -126,15 +134,7 @@ async function sendMessageSignal(to, text, opts) {
 	const target = parseTarget(to);
 	const targetAuthor = normalizeOptionalString(account);
 	const targetAuthorUuid = normalizeOptionalString(accountInfo.config.accountUuid);
-	const outboundText = appendSignalApprovalReactionHintForOutboundMessage({
-		cfg,
-		accountId: accountInfo.accountId,
-		to,
-		text: text ?? "",
-		targetAuthor,
-		targetAuthorUuid
-	});
-	let message = outboundText;
+	let message = text ?? "";
 	let outboundMedia;
 	let textStyles = [];
 	const textMode = opts.textMode ?? "markdown";
@@ -214,15 +214,6 @@ async function sendMessageSignal(to, text, opts) {
 		media: outboundMedia ? [outboundMedia] : void 0,
 		sourceTimestamp: timestamp
 	});
-	registerSignalApprovalReactionTargetForOutboundMessage({
-		cfg,
-		accountId: accountInfo.accountId,
-		to,
-		messageId,
-		text: outboundText,
-		targetAuthor,
-		targetAuthorUuid
-	});
 	return {
 		messageId,
 		timestamp,

package/dist/{send.runtime-CbuXycZT.js → send.runtime-DnMoKk27.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-BNl5folj.js";
 export { sendMessageSignal, sendTypingSignal };

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

@@ -1,8 +1,8 @@
 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 { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-DO4HMqaK.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 signalApprovalAuth, t as getSignalApprovalApprovers } from "./approval-auth-BY6uuApE.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-YGD6hhDh.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,38 +10,71 @@ 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";
 import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { getExecApprovalReplyMetadata } from "openclaw/plugin-sdk/approval-reply-runtime";
 import { isMessagePresentationInteractiveBlock, normalizeMessagePresentation, renderMessagePresentationFallbackText } from "openclaw/plugin-sdk/interactive-runtime";
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 //#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-Co6EVTqY.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 +95,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 = {
@@ -459,6 +365,12 @@ const signalReplyAuthorState = {
 	persistentStoreDisabled: false
 };
 //#endregion
+//#region extensions/signal/src/runtime.ts
+const { setRuntime: setSignalRuntime, tryGetRuntime: getOptionalSignalRuntime } = createPluginRuntimeStore({
+	pluginId: "signal",
+	errorMessage: "Signal runtime not initialized"
+});
+//#endregion
 //#region extensions/signal/src/reply-authors.ts
 const PERSISTENT_NAMESPACE = "signal.reply-authors.v1";
 const PERSISTENT_MAX_ENTRIES = 5e3;
@@ -633,7 +545,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");
@@ -649,4 +561,4 @@ async function detectSignalTransport(params) {
 	throw new Error(`Signal transport not reachable at ${url}`);
 }
 //#endregion
-export { signalMessageActions as a, markdownToSignalText as c, shouldSuppressLocalSignalExecApprovalPrompt as d, signalApprovalCapability as f, materializeSignalPresentationFallback as i, markdownToSignalTextChunks as l, registerSignalReplyContext as n, resolveSignalReactionLevel as o, resolveSignalReplyContextWithPersistence as r, formatSignalMediaText as s, detectSignalTransport as t, isSignalNativeApprovalHandlerConfigured as u };
+export { setSignalRuntime as a, resolveSignalReactionLevel as c, markdownToSignalTextChunks as d, isSignalNativeApprovalHandlerConfigured as f, getOptionalSignalRuntime as i, formatSignalMediaText as l, signalApprovalCapability as m, registerSignalReplyContext as n, materializeSignalPresentationFallback as o, shouldSuppressLocalSignalExecApprovalPrompt as p, resolveSignalReplyContextWithPersistence as r, signalMessageActions as s, detectSignalTransport as t, markdownToSignalText as u };

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

@@ -1,2 +1,2 @@
-import { t as detectSignalTransport } from "./transport-detection-Da06-LOL.js";
+import { t as detectSignalTransport } from "./transport-detection-D_M79R5f.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.7",
+  "version": "2026.8.1-beta.3",
   "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.7"
+      "pluginApi": ">=2026.8.1-beta.3"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.7",
+      "openclawVersion": "2026.8.1-beta.3",
       "bundledDist": false
     },
     "release": {
@@ -118,7 +118,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.7"
+    "openclaw": ">=2026.8.1-beta.3"
   },
   "peerDependenciesMeta": {
     "openclaw": {