@openclaw/signal 2026.7.1 → 2026.7.2-beta.1

package/dist/{probe-Cnht8Ihg.js → probe-CbWkI24J.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-C9mB2Jz8.js";
+import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-aEM0kGhC.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-EQ7cc7-Y.js → reaction-runtime-api-DifyinAU.js}

@@ -1,5 +1,5 @@
 import { i as resolveSignalAccount } from "./accounts-Bz4HtP0g.js";
-import { n as signalRpcRequest } from "./client-adapter-C9mB2Jz8.js";
+import { n as signalRpcRequest } from "./client-adapter-aEM0kGhC.js";
 import { t as resolveSignalRpcContext } from "./rpc-context-DsHWh2hc.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";

package/dist/reaction-runtime-api.js

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

package/dist/{message-actions-3OLDgjis.js → reply-authors-osU_SY4J.js}

@@ -1,7 +1,8 @@
 import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-Bz4HtP0g.js";
-import { d as normalizeSignalMessagingTarget } from "./identity-C8-yk4J9.js";
-import { n as signalApprovalAuth, t as getSignalApprovalApprovers } from "./approval-auth-CsHNcAiy.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-EQ7cc7-Y.js";
+import { d as normalizeSignalMessagingTarget } from "./identity-BF8taj7g.js";
+import { i as signalApprovalAuth, r as getSignalApprovalApprovers, t as getOptionalSignalRuntime } from "./runtime-BZ9hnS3a.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-DifyinAU.js";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 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";
@@ -12,6 +13,8 @@ import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetR
 import { buildApprovalReactionPendingContentForRequest } from "openclaw/plugin-sdk/approval-reaction-runtime";
 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";
 //#region extensions/signal/src/approval-native.ts
 const DEFAULT_APPROVAL_FORWARDING_MODE = "session";
 function isSignalApprovalTransportEnabled(params) {
@@ -205,12 +208,13 @@ const signalApprovalCapability = createChannelApprovalCapability({
 			cfg,
 			accountId
 		}),
-		shouldHandle: ({ cfg, accountId, context, request }) => Boolean(context) && shouldHandleSignalApprovalRequest({
+		shouldHandle: ({ cfg, accountId, context, approvalKind, request }) => Boolean(context) && shouldHandleSignalApprovalRequest({
 			cfg,
 			accountId,
+			approvalKind,
 			request
 		}),
-		load: async () => (await import("./approval-handler.runtime-DDQ4ZRyc.js")).signalApprovalNativeRuntime
+		load: async () => (await import("./approval-handler.runtime-I1SMFwwR.js")).signalApprovalNativeRuntime
 	})
 });
 //#endregion
@@ -342,7 +346,7 @@ function renderSignalText(ir) {
 		cursor = link.end;
 	}
 	out += text.slice(cursor);
-	const adjusted = applyInsertionsToStyles(ir.styles.map((span) => {
+	const mappedStyles = ir.styles.map((span) => {
 		const mapped = mapStyle(span.style);
 		if (!mapped) return null;
 		return {
@@ -350,7 +354,13 @@ function renderSignalText(ir) {
 			end: span.end,
 			style: mapped
 		};
-	}).filter((span) => span !== null), insertions);
+	}).filter((span) => span !== null);
+	for (const annotation of ir.annotations ?? []) if (annotation.type === "assistant_transcript_role") mappedStyles.push({
+		start: annotation.start,
+		end: annotation.end,
+		style: "MONOSPACE"
+	});
+	const adjusted = applyInsertionsToStyles(mappedStyles, insertions);
 	const trimmedText = out.trimEnd();
 	const trimmedLength = trimmedText.length;
 	return {
@@ -364,6 +374,7 @@ function renderSignalText(ir) {
 }
 function markdownToSignalText(markdown, options = {}) {
 	return renderSignalText(markdownToIR(markdown ?? "", {
+		assistantTranscriptRoleHeaders: true,
 		linkify: true,
 		enableSpoilers: true,
 		headingStyle: "bold",
@@ -374,6 +385,7 @@ function markdownToSignalText(markdown, options = {}) {
 function markdownToSignalTextChunks(markdown, limit, options = {}) {
 	return renderMarkdownIRChunksWithinLimit({
 		ir: markdownToIR(markdown ?? "", {
+			assistantTranscriptRoleHeaders: true,
 			linkify: true,
 			enableSpoilers: true,
 			headingStyle: "bold",
@@ -381,6 +393,7 @@ function markdownToSignalTextChunks(markdown, limit, options = {}) {
 			tableMode: options.tableMode
 		}),
 		limit,
+		assistantTranscriptRoleMessageBoundaries: true,
 		renderChunk: renderSignalText,
 		measureRendered: (rendered) => rendered.text.length
 	}).map(({ rendered }) => rendered);
@@ -461,7 +474,16 @@ const signalMessageActions = {
 		if (configuredAccounts.some((account) => createActionGate(account.config.actions)("reactions"))) actions.add("react");
 		return { actions: Array.from(actions) };
 	},
-	supportsAction: ({ action }) => action !== "send",
+	supportsAction: ({ action }) => action === "react",
+	prepareSendPayload: ({ ctx, payload, replyToId, replyToIdSource }) => {
+		if (ctx.action !== "send") return null;
+		const normalizedReplyToId = replyToId?.trim();
+		if (!normalizedReplyToId) return payload;
+		return replyToIdSource === "implicit" ? payload : {
+			...payload,
+			replyToId: normalizedReplyToId
+		};
+	},
 	handleAction: async ({ action, params, cfg, accountId, toolContext }) => {
 		if (action === "send") throw new Error("Send should be handled by outbound, not actions handler.");
 		if (action === "react") {
@@ -522,4 +544,185 @@ const signalMessageActions = {
 	}
 };
 //#endregion
-export { isSignalNativeApprovalHandlerConfigured as a, markdownToSignalTextChunks as i, resolveSignalReactionLevel as n, shouldSuppressLocalSignalExecApprovalPrompt as o, markdownToSignalText as r, signalApprovalCapability as s, signalMessageActions as t };
+//#region extensions/signal/src/presentation-fallback.ts
+/** Materialize presentation content once before Signal's text-only delivery funnels. */
+function materializeSignalPresentationFallback(payload, presentationOverride) {
+	const presentation = presentationOverride ?? normalizeMessagePresentation(payload.presentation);
+	if (!presentation) return payload;
+	const currentText = payload.text?.trim() ?? "";
+	const presentationFallback = renderMessagePresentationFallbackText({ presentation: Boolean(getExecApprovalReplyMetadata(payload) && currentText) ? {
+		...presentation,
+		blocks: presentation.blocks.filter((block) => !isMessagePresentationInteractiveBlock(block))
+	} : presentation });
+	const text = currentText.includes(presentationFallback) ? currentText : [currentText, presentationFallback].filter(Boolean).join("\n\n");
+	const { presentation: _presentation, ...withoutPresentation } = payload;
+	return {
+		...withoutPresentation,
+		text
+	};
+}
+//#endregion
+//#region extensions/signal/src/reply-authors.ts
+const PERSISTENT_NAMESPACE = "signal.reply-authors.v1";
+const PERSISTENT_MAX_ENTRIES = 5e3;
+const DEFAULT_REPLY_AUTHOR_TTL_MS = 10080 * 60 * 1e3;
+const memoryReplyContexts = /* @__PURE__ */ new Map();
+let persistentStoreDisabled = false;
+function openSignalReplyAuthorStore() {
+	if (persistentStoreDisabled) return;
+	const runtime = getOptionalSignalRuntime();
+	try {
+		return runtime?.state.openKeyedStore({
+			namespace: PERSISTENT_NAMESPACE,
+			maxEntries: PERSISTENT_MAX_ENTRIES,
+			defaultTtlMs: DEFAULT_REPLY_AUTHOR_TTL_MS
+		});
+	} catch (error) {
+		persistentStoreDisabled = true;
+		runtime?.logging.getChildLogger({
+			plugin: "signal",
+			feature: "reply-author-state"
+		}).warn("Signal persistent reply author state unavailable", { error: String(error) });
+		return;
+	}
+}
+function buildSignalReplyAuthorStoreKey(params) {
+	const conversationKey = normalizeSignalMessagingTarget(params.to);
+	const replyToId = normalizeOptionalString(params.replyToId);
+	if (!conversationKey || !replyToId) return;
+	return `account=${normalizeLowercaseStringOrEmpty(normalizeOptionalString(params.accountId) ?? DEFAULT_ACCOUNT_ID)}|to=${conversationKey}|id=${replyToId}`;
+}
+function pruneMemoryReplyContexts(now = Date.now()) {
+	for (const [key, record] of memoryReplyContexts) if (record.expiresAt <= now) memoryReplyContexts.delete(key);
+	while (memoryReplyContexts.size > PERSISTENT_MAX_ENTRIES) {
+		const oldestKey = memoryReplyContexts.keys().next().value;
+		if (!oldestKey) break;
+		memoryReplyContexts.delete(oldestKey);
+	}
+}
+function resolveReplyContext(record) {
+	if (!record) return;
+	if (record.kind === "ambiguous") return { ambiguous: true };
+	const author = normalizeOptionalString(record.author);
+	if (!author) return;
+	const body = normalizeOptionalString(record.body);
+	return {
+		author,
+		...body ? { body } : {}
+	};
+}
+function resolveSourceTimestamp(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : Date.now();
+}
+function mergeReplyContext(current, next) {
+	if (!current) return next;
+	if (current.kind === "ambiguous") return current;
+	if (current.author !== next.author) {
+		const { author: _author, body: _body, ...identity } = next;
+		return {
+			...identity,
+			kind: "ambiguous"
+		};
+	}
+	return next.sourceTimestamp >= current.sourceTimestamp ? next : current;
+}
+async function registerSignalReplyContext(params) {
+	const store = openSignalReplyAuthorStore();
+	const key = buildSignalReplyAuthorStoreKey(params);
+	const author = normalizeOptionalString(params.author);
+	const body = normalizeOptionalString(params.body);
+	const conversationKey = normalizeSignalMessagingTarget(params.to);
+	const replyToId = normalizeOptionalString(params.replyToId);
+	const accountKey = normalizeLowercaseStringOrEmpty(normalizeOptionalString(params.accountId) ?? DEFAULT_ACCOUNT_ID);
+	const sourceTimestamp = resolveSourceTimestamp(params.sourceTimestamp);
+	if (!key || !author || !conversationKey || !replyToId) return;
+	const registeredAt = Date.now();
+	const record = {
+		kind: "resolved",
+		author,
+		...body ? { body } : {},
+		accountId: accountKey,
+		conversationKey,
+		replyToId,
+		sourceTimestamp,
+		registeredAt
+	};
+	const expiresAt = registeredAt + DEFAULT_REPLY_AUTHOR_TTL_MS;
+	if (!store) {
+		const next = mergeReplyContext(memoryReplyContexts.get(key), record);
+		memoryReplyContexts.set(key, {
+			...next,
+			expiresAt
+		});
+		pruneMemoryReplyContexts(registeredAt);
+		return;
+	}
+	if (!store.update) {
+		const next = mergeReplyContext(memoryReplyContexts.get(key), record);
+		memoryReplyContexts.set(key, {
+			...next,
+			expiresAt
+		});
+		pruneMemoryReplyContexts(registeredAt);
+		persistentStoreDisabled = true;
+		getOptionalSignalRuntime()?.logging.getChildLogger({
+			plugin: "signal",
+			feature: "reply-author-state"
+		}).warn("Signal persistent reply author state lacks atomic updates");
+		return;
+	}
+	let updateEvaluated = false;
+	let nextRecord;
+	try {
+		if (await store.update(key, (current) => {
+			updateEvaluated = true;
+			nextRecord = mergeReplyContext(current, record);
+			return nextRecord;
+		}) && nextRecord) memoryReplyContexts.set(key, {
+			...nextRecord,
+			expiresAt
+		});
+		else memoryReplyContexts.delete(key);
+		pruneMemoryReplyContexts(registeredAt);
+	} catch (error) {
+		if (!updateEvaluated) try {
+			nextRecord = mergeReplyContext(await store.lookup(key), record);
+		} catch {
+			nextRecord = void 0;
+		}
+		const next = nextRecord;
+		if (next) memoryReplyContexts.set(key, {
+			...next,
+			expiresAt
+		});
+		else if (updateEvaluated) memoryReplyContexts.delete(key);
+		pruneMemoryReplyContexts(registeredAt);
+		getOptionalSignalRuntime()?.logging.getChildLogger({
+			plugin: "signal",
+			feature: "reply-author-state"
+		}).warn("Signal persistent reply author state failed", { error: String(error) });
+	}
+}
+async function resolveSignalReplyContextWithPersistence(params) {
+	const store = openSignalReplyAuthorStore();
+	const key = buildSignalReplyAuthorStoreKey(params);
+	if (!key) return;
+	if (!store) {
+		pruneMemoryReplyContexts();
+		return resolveReplyContext(memoryReplyContexts.get(key));
+	}
+	pruneMemoryReplyContexts();
+	const memoryContext = resolveReplyContext(memoryReplyContexts.get(key));
+	if (memoryContext) return memoryContext;
+	try {
+		return resolveReplyContext(await store.lookup(key));
+	} catch (error) {
+		getOptionalSignalRuntime()?.logging.getChildLogger({
+			plugin: "signal",
+			feature: "reply-author-state"
+		}).warn("Signal persistent reply author lookup failed", { error: String(error) });
+		return;
+	}
+}
+//#endregion
+export { resolveSignalReactionLevel as a, isSignalNativeApprovalHandlerConfigured as c, signalMessageActions as i, shouldSuppressLocalSignalExecApprovalPrompt as l, resolveSignalReplyContextWithPersistence as n, markdownToSignalText as o, materializeSignalPresentationFallback as r, markdownToSignalTextChunks as s, registerSignalReplyContext as t, signalApprovalCapability as u };

package/dist/{approval-auth-CsHNcAiy.js → runtime-BZ9hnS3a.js}

@@ -1,8 +1,9 @@
 import { i as resolveSignalAccount } from "./accounts-Bz4HtP0g.js";
-import { d as normalizeSignalMessagingTarget, l as looksLikeUuid, u as looksLikeSignalTargetId } from "./identity-C8-yk4J9.js";
+import { d as normalizeSignalMessagingTarget, l as looksLikeUuid, u as looksLikeSignalTargetId } from "./identity-BF8taj7g.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { createChannelApprovalAuth } from "openclaw/plugin-sdk/approval-auth-runtime";
 import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 //#region extensions/signal/src/aliases.ts
 function normalizeAliasKey(raw) {
 	const trimmed = raw.trim();
@@ -124,28 +125,37 @@ function normalizeSignalApproverId(value) {
 	const e164 = normalizeE164(normalized);
 	return e164.length > 1 ? e164 : void 0;
 }
-function getSignalApprovalApprovers(params) {
-	const account = resolveSignalAccount(params).config;
-	let defaultTo = account.defaultTo;
-	if (typeof account.defaultTo === "string") try {
-		defaultTo = resolveSignalTarget({
-			cfg: params.cfg,
-			accountId: params.accountId,
-			input: account.defaultTo
-		})?.to ?? account.defaultTo;
-	} catch {
-		defaultTo = account.defaultTo;
-	}
-	return resolveApprovalApprovers({
-		allowFrom: account.allowFrom,
-		defaultTo,
-		normalizeApprover: normalizeSignalApproverId
-	});
-}
-const signalApprovalAuth = createResolvedApproverActionAuthAdapter({
+const signalApproval = createChannelApprovalAuth({
 	channelLabel: "Signal",
-	resolveApprovers: getSignalApprovalApprovers,
-	normalizeSenderId: (value) => normalizeSignalApproverId(value)
+	resolveInputs: ({ cfg, accountId }) => {
+		const account = resolveSignalAccount({
+			cfg,
+			accountId
+		}).config;
+		let defaultTo = account.defaultTo;
+		if (typeof account.defaultTo === "string") try {
+			defaultTo = resolveSignalTarget({
+				cfg,
+				accountId,
+				input: account.defaultTo
+			})?.to ?? account.defaultTo;
+		} catch {
+			defaultTo = account.defaultTo;
+		}
+		return {
+			allowFrom: account.allowFrom,
+			defaultTo
+		};
+	},
+	normalizeApprover: normalizeSignalApproverId
+});
+const getSignalApprovalApprovers = signalApproval.resolveApprovers;
+const signalApprovalAuth = signalApproval.approvalAuth;
+//#endregion
+//#region extensions/signal/src/runtime.ts
+const { setRuntime: setSignalRuntime, tryGetRuntime: getOptionalSignalRuntime } = createPluginRuntimeStore({
+	pluginId: "signal",
+	errorMessage: "Signal runtime not initialized"
 });
 //#endregion
-export { resolveSignalTarget as i, signalApprovalAuth as n, listSignalAliasDirectoryEntries as r, getSignalApprovalApprovers as t };
+export { listSignalAliasDirectoryEntries as a, signalApprovalAuth as i, setSignalRuntime as n, resolveSignalTarget as o, getSignalApprovalApprovers as r, getOptionalSignalRuntime as t };

package/dist/runtime-api.js

@@ -1,13 +1,13 @@
 import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-Bz4HtP0g.js";
-import { d as normalizeSignalMessagingTarget, u as looksLikeSignalTargetId } from "./identity-C8-yk4J9.js";
-import { n as resolveSignalReactionLevel, t as signalMessageActions } from "./message-actions-3OLDgjis.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-EQ7cc7-Y.js";
-import { n as buildChannelConfigSchema, t as SignalConfigSchema } from "./config-api-KS-qhQvD.js";
-import { r as installSignalCli } from "./install-signal-cli-ik8VPaGg.js";
-import { f as setSignalRuntime } from "./approval-reactions-UFmUPD0A.js";
-import { t as monitorSignalProvider } from "./monitor-Bee8O5Ay.js";
-import { t as sendMessageSignal } from "./send-CUJy6WPt.js";
-import { t as probeSignal } from "./probe-Cnht8Ihg.js";
+import { d as normalizeSignalMessagingTarget, u as looksLikeSignalTargetId } from "./identity-BF8taj7g.js";
+import { n as setSignalRuntime } from "./runtime-BZ9hnS3a.js";
+import { a as resolveSignalReactionLevel, i as signalMessageActions } from "./reply-authors-osU_SY4J.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-DifyinAU.js";
+import { n as buildChannelConfigSchema, t as SignalConfigSchema } from "./config-api-DIg1lInT.js";
+import { i as installSignalCli } from "./install-signal-cli-CtusY3tN.js";
+import { t as monitorSignalProvider } from "./monitor-BdzH3U64.js";
+import { t as sendMessageSignal } from "./send-BWtA6h3J.js";
+import { t as probeSignal } from "./probe-CbWkI24J.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-CUJy6WPt.js → send-BWtA6h3J.js}

@@ -1,8 +1,9 @@
 import { i as resolveSignalAccount } from "./accounts-Bz4HtP0g.js";
-import { r as markdownToSignalText } from "./message-actions-3OLDgjis.js";
-import { n as signalRpcRequest } from "./client-adapter-C9mB2Jz8.js";
+import { d as normalizeSignalMessagingTarget } from "./identity-BF8taj7g.js";
+import { o as markdownToSignalText, t as registerSignalReplyContext } from "./reply-authors-osU_SY4J.js";
+import { n as signalRpcRequest } from "./client-adapter-aEM0kGhC.js";
 import { t as resolveSignalRpcContext } from "./rpc-context-DsHWh2hc.js";
-import { c as registerSignalApprovalReactionTargetForOutboundMessage, n as appendSignalApprovalReactionHintForOutboundMessage } from "./approval-reactions-UFmUPD0A.js";
+import { c as registerSignalApprovalReactionTargetForOutboundMessage, n as appendSignalApprovalReactionHintForOutboundMessage } from "./approval-reactions-ChcS2rQN.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";
@@ -18,9 +19,8 @@ async function resolveSignalRpcAccountInfo(opts) {
 	});
 }
 function parseTarget(raw) {
-	let value = raw.trim();
+	const value = normalizeSignalMessagingTarget(raw);
 	if (!value) throw new Error("Signal recipient is required");
-	if (normalizeLowercaseStringOrEmpty(value).startsWith("signal:")) value = value.slice(7).trim();
 	const normalized = normalizeLowercaseStringOrEmpty(value);
 	if (normalized.startsWith("group:")) return {
 		type: "group",
@@ -30,10 +30,6 @@ function parseTarget(raw) {
 		type: "username",
 		username: value.slice(9).trim()
 	};
-	if (normalized.startsWith("u:")) return {
-		type: "username",
-		username: value.trim()
-	};
 	return {
 		type: "recipient",
 		recipient: value
@@ -193,6 +189,15 @@ async function sendMessageSignal(to, text, opts) {
 	else result = await signalRpcRequest("send", params, sendOpts);
 	const timestamp = result?.timestamp;
 	const messageId = timestamp ? String(timestamp) : "unknown";
+	const replyAuthor = targetAuthor ?? targetAuthorUuid;
+	if (timestamp && replyAuthor) await registerSignalReplyContext({
+		accountId: accountInfo.accountId,
+		to,
+		replyToId: messageId,
+		author: replyAuthor,
+		body: message,
+		sourceTimestamp: timestamp
+	});
 	registerSignalApprovalReactionTargetForOutboundMessage({
 		cfg,
 		accountId: accountInfo.accountId,

package/dist/{send.runtime-CEi5oyCG.js → send.runtime-D4WBNNgn.js}

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

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/signal",
-  "version": "2026.7.1",
+  "version": "2026.7.2-beta.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/signal",
-      "version": "2026.7.1",
+      "version": "2026.7.2-beta.1",
       "dependencies": {
         "ws": "8.21.0"
       }

package/openclaw.plugin.json

@@ -269,33 +269,45 @@
             "exclusiveMinimum": 0,
             "maximum": 9007199254740991
           },
-          "chunkMode": {
-            "type": "string",
-            "enum": [
-              "length",
-              "newline"
-            ]
-          },
-          "blockStreaming": {
-            "type": "boolean"
-          },
-          "blockStreamingCoalesce": {
+          "streaming": {
             "type": "object",
             "properties": {
-              "minChars": {
-                "type": "integer",
-                "exclusiveMinimum": 0,
-                "maximum": 9007199254740991
-              },
-              "maxChars": {
-                "type": "integer",
-                "exclusiveMinimum": 0,
-                "maximum": 9007199254740991
+              "chunkMode": {
+                "type": "string",
+                "enum": [
+                  "length",
+                  "newline"
+                ]
               },
-              "idleMs": {
-                "type": "integer",
-                "minimum": 0,
-                "maximum": 9007199254740991
+              "block": {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean"
+                  },
+                  "coalesce": {
+                    "type": "object",
+                    "properties": {
+                      "minChars": {
+                        "type": "integer",
+                        "exclusiveMinimum": 0,
+                        "maximum": 9007199254740991
+                      },
+                      "maxChars": {
+                        "type": "integer",
+                        "exclusiveMinimum": 0,
+                        "maximum": 9007199254740991
+                      },
+                      "idleMs": {
+                        "type": "integer",
+                        "minimum": 0,
+                        "maximum": 9007199254740991
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                },
+                "additionalProperties": false
               }
             },
             "additionalProperties": false
@@ -705,33 +717,45 @@
                   "exclusiveMinimum": 0,
                   "maximum": 9007199254740991
                 },
-                "chunkMode": {
-                  "type": "string",
-                  "enum": [
-                    "length",
-                    "newline"
-                  ]
-                },
-                "blockStreaming": {
-                  "type": "boolean"
-                },
-                "blockStreamingCoalesce": {
+                "streaming": {
                   "type": "object",
                   "properties": {
-                    "minChars": {
-                      "type": "integer",
-                      "exclusiveMinimum": 0,
-                      "maximum": 9007199254740991
-                    },
-                    "maxChars": {
-                      "type": "integer",
-                      "exclusiveMinimum": 0,
-                      "maximum": 9007199254740991
+                    "chunkMode": {
+                      "type": "string",
+                      "enum": [
+                        "length",
+                        "newline"
+                      ]
                     },
-                    "idleMs": {
-                      "type": "integer",
-                      "minimum": 0,
-                      "maximum": 9007199254740991
+                    "block": {
+                      "type": "object",
+                      "properties": {
+                        "enabled": {
+                          "type": "boolean"
+                        },
+                        "coalesce": {
+                          "type": "object",
+                          "properties": {
+                            "minChars": {
+                              "type": "integer",
+                              "exclusiveMinimum": 0,
+                              "maximum": 9007199254740991
+                            },
+                            "maxChars": {
+                              "type": "integer",
+                              "exclusiveMinimum": 0,
+                              "maximum": 9007199254740991
+                            },
+                            "idleMs": {
+                              "type": "integer",
+                              "minimum": 0,
+                              "maximum": 9007199254740991
+                            }
+                          },
+                          "additionalProperties": false
+                        }
+                      },
+                      "additionalProperties": false
                     }
                   },
                   "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/signal",
-  "version": "2026.7.1",
+  "version": "2026.7.2-beta.1",
   "description": "OpenClaw Signal channel plugin",
   "type": "module",
   "dependencies": {
@@ -44,10 +44,10 @@
       "allowInvalidConfigRecovery": true
     },
     "compat": {
-      "pluginApi": ">=2026.7.1"
+      "pluginApi": ">=2026.7.2-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.7.1",
+      "openclawVersion": "2026.7.2-beta.1",
       "bundledDist": false
     },
     "release": {
@@ -70,7 +70,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.1"
+    "openclaw": ">=2026.7.2-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/dist/config-api-KS-qhQvD.js

@@ -1,2 +0,0 @@
-import { SignalConfigSchema, buildChannelConfigSchema } from "openclaw/plugin-sdk/bundled-channel-config-schema";
-export { buildChannelConfigSchema as n, SignalConfigSchema as t };