@relaymessenger/openclaw-plugin 0.4.7-staging.4 → 0.4.7-staging.40

package/README.md

@@ -1,7 +1,7 @@
 # Relay for OpenClaw
 
 `@relaymessenger/openclaw-plugin` is the native Relay channel for OpenClaw
-`2026.8.1`.
+`2026.8.1` through `2026.9.6`, the versions its gateway harness runs against.
 
 Source is maintained in
 [`RelayMessenger/Relay-SDK`](https://github.com/RelayMessenger/Relay-SDK/tree/main/packages/openclaw)
@@ -12,12 +12,45 @@ delivers events over its v1 WebSocket, and the plugin sends replies through
 the Relay v1 REST Message API. The plugin imports `@relaymessenger/sdk`; it
 does not contain a copied Relay client or protocol implementation.
 
+## Selection
+
+End the final answer with a `selection` JSON fence holding the question as
+`title` (1 to 60 characters) and the `options`; any words outside the fence go
+as a normal message above the card.
+`BodyForAgent` carries structured response and rich-message JSON; `RawBody` and
+`CommandBody` retain readable text. Stable values are not executable commands.
+
+New human reply text is literal `• ` + each selected source label joined with
+`\n`, followed by `selection_response` metadata in source-option order. Dispatch
+with `selected_values` and the explicit source target, never label parsing.
+Exact legacy comma-joined text remains a server compatibility input. The person
+checks any number of options and submits them once; checking sends nothing, and
+a person answers a given selection once. iOS may draw a checkmark in place of
+each bullet and repeat the prompt's title, as presentation only.
+
+## Payment
+
+The agent ends the final answer with a `payment` JSON fence holding the
+payment request's fields (`description`, `category`, and `amount` with
+`currency`, or `mode: "subscription"` with `price_id`). The plugin creates the
+request with its own Relay token, on the card's own idempotency key; the words
+go first and the payment card follows as its own Message.
+
 ## Install
 
 ```bash
 openclaw plugins install @relaymessenger/openclaw-plugin
 ```
 
+OpenClaw asks two questions for a plugin from npm: whether you trust a source
+outside ClawHub, and whether to accept the capabilities the plugin declares.
+This plugin declares one capability, the `relay` channel. Where no terminal
+can answer, pass both answers:
+
+```bash
+openclaw plugins install @relaymessenger/openclaw-plugin --force --accept-capabilities
+```
+
 Configure the default account:
 
 ```json
@@ -106,6 +139,16 @@ Without `allowFrom`, any user or agent Contact whose Message Relay delivers
 to this agent can start a direct turn, while the group activation rules above
 still apply.
 
+## Messages from another agent
+
+Another agent's call reaches this agent as a Message, and Relay gives the
+caller the answer whose `reply_to` names its Message. So every answer to
+another agent names the Message it answers. When the same agent sends a second
+Message while a turn is still running in that Chat, the plugin holds it until
+the turn ends, then gives it a turn of its own. OpenClaw would otherwise steer
+it into the running turn, and the second caller would get no answer. A
+person's Messages keep OpenClaw's own queue and reply behavior.
+
 ## Durable delivery
 
 For every WebSocket event, the plugin:
@@ -153,10 +196,12 @@ exact SHA selected from the `staging` branch, the matching
 validated tarball and publishes that same digest with npm provenance; its
 publish job is also bound to the `staging` GitHub environment.
 
-`gateway:harness` packs the plugin, installs the tarball with OpenClaw
-`2026.8.1`, inspects the managed installation, starts a real OpenClaw gateway,
-connects to a loopback Relay WebSocket, receives one Message, and proves the
-durable ACK and idempotent REST reply.
+`gateway:harness` packs the plugin, installs the tarball with the OpenClaw
+version in `devDependencies`, inspects the managed installation, starts a real
+OpenClaw gateway, connects to a loopback Relay WebSocket, receives one Message,
+and proves the durable ACK and idempotent REST reply. Its `--overlap` run sends
+two Messages from one agent, the second while the model still answers the
+first, and requires two answers, each naming its own Message.
 
 ## Contract lock
 

package/contracts/relay-v1.lock.json

@@ -1,16 +1,16 @@
 {
   "relayServer": {
     "repository": "RelayMessenger/Relay-Server",
-    "commit": "ef8cedb1015e1e0d0856d61b69057f2b831f7c90",
+    "commit": "65c4473526e4bbd3fedcd747ab09d218d00920ce",
     "openapiPath": "contracts/developer/openapi.yaml",
-    "sha256": "1b687dc9ffc7a6296a04b570d20fe32bed758deb2ed8f38fc48d0d44a10db2ec"
+    "sha256": "44d3202de07206707c8914c37029abc365c144be4245e677574210d2a1cf6f41"
   },
   "relaySdk": {
     "package": "@relaymessenger/sdk",
-    "version": "0.3.6-staging.4",
-    "integrity": "sha512-WkjSggp1VDo8kLTnUWb4OOED3p1fyPPrE996EGEsn6T6YTk0RPD/HlleqkIPSgaSjwJw7EBunhApwzO6a7kDKg==",
-    "operationsSha256": "5c482165296df7d0634a0f57950936887b118e7159baf3bdabc42fce0d4fe6d8",
-    "workspaceOpenapiSha256": "1b687dc9ffc7a6296a04b570d20fe32bed758deb2ed8f38fc48d0d44a10db2ec",
+    "version": "0.3.6-staging.47",
+    "integrity": "sha512-CI67lgtiuYyhSwuttqXF6x07OC9fDwTIpT3eCZPiqHGxWDo6Tx/zNmAAUzEDcw9ExoGOHP2VXnIlcDFMlQrslw==",
+    "operationsSha256": "3e09d345c249709d942d2efb89ed7e84934c19552767d8f4438eb086dd917e1c",
+    "workspaceOpenapiSha256": "44d3202de07206707c8914c37029abc365c144be4245e677574210d2a1cf6f41",
     "usedOperations": [
       {
         "method": "GET",

package/dist/src/channel.js

@@ -249,6 +249,7 @@ export const relayChannelPlugin = createChatChannelPlugin({
                         deliveryQueueId: ctx.deliveryQueueId,
                         deliveryPartIndex: ctx.deliveryPartIndex,
                     }),
+                    onButtonsError: (error) => ctx.log?.warn?.(`relay: component block left as text: ${error}`),
                     ...(ctx.onPlatformSendDispatch
                         ? { onPlatformSendDispatch: ctx.onPlatformSendDispatch }
                         : {}),

package/dist/src/dispatch.js

@@ -1,7 +1,9 @@
+import { BUTTONS_GUIDANCE, BUTTONS_BLOCK_INSTRUCTION, PAYMENT_BLOCK_INSTRUCTION, PAYMENT_GUIDANCE, LINK_LINE_INSTRUCTION, SELECTION_GUIDANCE, SELECTION_BLOCK_INSTRUCTION, selectionReplyContext } from "@relaymessenger/sdk";
 import { buildChannelInboundEventContext, resolveChannelInboundRouteEnvelope, } from "openclaw/plugin-sdk/channel-inbound";
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { bindIngressLifecycleToReplyOptions } from "openclaw/plugin-sdk/channel-outbound";
-import { buildRelayInboundFacts } from "./inbound.js";
+import { buildRelayInboundFacts, renderRelayMessageParts } from "./inbound.js";
+import { waitForIdleChat } from "./turns.js";
 function isReplyToAgentMessage(message, chatId) {
     return message.chat_id === chatId && message.is_from_me === true;
 }
@@ -28,7 +30,8 @@ export async function resolveRelayTurnActivation(params) {
     }
     if (!params.facts.replyToId)
         return null;
-    const replyTarget = await params.relay.messages.retrieve(params.facts.replyToId);
+    const replyTarget = params.replyTarget
+        ?? await params.relay.messages.retrieve(params.facts.replyToId);
     if (!isReplyToAgentMessage(replyTarget, params.facts.chatId))
         return null;
     return {
@@ -37,15 +40,78 @@ export async function resolveRelayTurnActivation(params) {
         implicitMentionKinds: ["reply_to_bot"],
     };
 }
+/**
+ * The Message a swipe-reply answers, read once for the quote and for group
+ * activation. A failed read is logged and the turn runs without the quote;
+ * group activation then reads it itself and fails the delivery as before.
+ */
+async function readReplyTarget(params) {
+    if (!params.facts.replyToId)
+        return undefined;
+    try {
+        return await params.relay.messages.retrieve(params.facts.replyToId);
+    }
+    catch (error) {
+        params.warn?.(`relay: could not read the Message ${params.facts.replyToId} that ${params.facts.messageId} replies to: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
+/**
+ * OpenClaw's own reply context, `supplemental.quote`, which it renders to the
+ * model as "Reply target of current user message" (id, sender, body), as its
+ * Telegram channel fills it from Telegram's `reply_to_message`. A reply names
+ * one bubble: when the target has more than one part, only the swiped part is
+ * quoted, the rule Relay's iOS app uses to draw the quote.
+ */
+export function relayReplyQuote(facts, target) {
+    if (!target || target.chat_id !== facts.chatId)
+        return undefined;
+    const parts = target.parts ?? [];
+    const swiped = parts.length > 1 && facts.replyToPartIndex !== undefined
+        ? parts[facts.replyToPartIndex]
+        : undefined;
+    const body = renderRelayMessageParts(swiped ? [swiped] : parts);
+    const sender = target.from_handle?.display_name?.trim()
+        || target.from_handle?.handle
+        || target.from
+        || undefined;
+    return {
+        id: target.id,
+        ...(body ? { body } : {}),
+        ...(sender ? { sender } : {}),
+        senderAllowed: true,
+    };
+}
+/**
+ * The answer to another agent names the Message it answers: the model's own
+ * reply target when it chose one, else the agent's Message. Where no reply may
+ * point (a Message opening with buttons or a selection), OpenClaw's implicit
+ * current-message reply is removed.
+ */
+export function agentReplyPayload(payload, facts) {
+    if (facts.agentReplyLink) {
+        return { ...payload, replyToId: payload.replyToId ?? facts.agentReplyLink };
+    }
+    if (payload.replyToId !== facts.messageId)
+        return payload;
+    const { replyToId: _unlinked, ...rest } = payload;
+    return rest;
+}
 export async function dispatchRelayEvent(params) {
     const facts = buildRelayInboundFacts(params.event);
     if (!facts) {
         params.warn?.(`relay: durably accepted ${params.event.event_type} event ${params.event.event_id} without an agent turn`);
         return;
     }
+    const repliedTo = await readReplyTarget({
+        facts,
+        relay: params.relay,
+        warn: params.warn,
+    });
     const activation = await resolveRelayTurnActivation({
         facts,
         relay: params.relay,
+        ...(repliedTo ? { replyTarget: repliedTo } : {}),
     });
     if (!activation) {
         params.warn?.(`relay: durably accepted unmentioned group Message ${facts.messageId} without an agent turn`);
@@ -136,12 +202,18 @@ export async function dispatchRelayEvent(params) {
         params.warn?.(`relay: Contact @${facts.handle} did not pass OpenClaw ingress (${access.ingress.decision}:${access.ingress.reasonCode})`);
         return;
     }
+    // An agent's reply target is only its own Message (agentReplyLink); a
+    // person's is the Message they replied from, as before.
+    const replyTarget = facts.fromAgent
+        ? facts.agentReplyLink
+        : facts.replyAnchorId ?? facts.replyToId;
     const body = buildEnvelope({
         channel: "Relay",
         from: `${facts.displayName} (@${facts.handle})`,
         ...(facts.timestamp ? { timestamp: facts.timestamp } : {}),
         body: facts.text,
     });
+    const quote = relayReplyQuote(facts, repliedTo);
     const ctxPayload = buildChannelInboundEventContext({
         channel: "relay",
         accountId: route.accountId ?? params.account.accountId,
@@ -170,17 +242,18 @@ export async function dispatchRelayEvent(params) {
         reply: {
             to: facts.chatId,
             originatingTo: facts.chatId,
-            ...((facts.replyAnchorId ?? facts.replyToId)
-                ? { replyToId: facts.replyAnchorId ?? facts.replyToId }
-                : {}),
+            ...(replyTarget ? { replyToId: replyTarget } : {}),
         },
         message: {
             inboundEventKind: "user_request",
             body,
-            bodyForAgent: facts.text,
+            bodyForAgent: [facts.text, selectionReplyContext(facts.selection, facts.richMessage),
+                `${BUTTONS_BLOCK_INSTRUCTION} ${LINK_LINE_INSTRUCTION} ${BUTTONS_GUIDANCE} ${SELECTION_BLOCK_INSTRUCTION} ${SELECTION_GUIDANCE} ${PAYMENT_BLOCK_INSTRUCTION} ${PAYMENT_GUIDANCE}`,
+            ].filter(Boolean).join("\n\n"),
             rawBody: facts.text,
             commandBody: facts.text,
         },
+        ...(quote ? { supplemental: { quote } } : {}),
         channelIngress: access,
         access: {
             commands: {
@@ -197,6 +270,15 @@ export async function dispatchRelayEvent(params) {
             },
         },
     });
+    // Another agent's Message waits for the turn running in its Chat, so it
+    // gets a turn and an answer of its own (turns.ts).
+    if (facts.fromAgent) {
+        await waitForIdleChat({
+            turns: params.turns,
+            chatId: facts.chatId,
+            lifecycle: params.lifecycle,
+        });
+    }
     await Promise.allSettled([
         params.relay.chats.markAsRead(facts.chatId),
         params.relay.chats.startTyping(facts.chatId),
@@ -209,7 +291,7 @@ export async function dispatchRelayEvent(params) {
     });
     let deliveryError;
     try {
-        await params.runtime.channel.inbound.dispatch({
+        await params.turns.track(facts.chatId, () => params.runtime.channel.inbound.dispatch({
             cfg: params.cfg,
             channel: "relay",
             accountId: params.account.accountId,
@@ -222,9 +304,17 @@ export async function dispatchRelayEvent(params) {
             delivery: {
                 durable: {
                     to: facts.chatId,
-                    replyToId: null,
+                    replyToId: facts.fromAgent ? facts.agentReplyLink ?? null : null,
                     requiredCapabilities: { reconcileUnknownSend: true },
                 },
+                // Every answer to another agent names its Message, whatever
+                // `replyToMode` the operator chose; OpenClaw's own implicit
+                // current-message reply is dropped where no reply may point.
+                ...(facts.fromAgent
+                    ? {
+                        preparePayload: (payload) => agentReplyPayload(payload, facts),
+                    }
+                    : {}),
                 deliver: async (_payload, info) => {
                     if (info.kind === "final") {
                         throw new Error("relay: durable final Message delivery was unavailable");
@@ -247,7 +337,7 @@ export async function dispatchRelayEvent(params) {
                         : new Error(`relay: session record failed: ${String(error)}`);
                 },
             },
-        });
+        }));
         if (deliveryError) {
             throw deliveryError instanceof Error
                 ? deliveryError

package/dist/src/gateway.js

@@ -4,6 +4,7 @@ import { dispatchRelayEvent } from "./dispatch.js";
 import { commitRelayFullSync } from "./full-sync.js";
 import { createRelayIngressMonitor } from "./ingress.js";
 import { createRelaySdkClient } from "./outbound.js";
+import { createRelayChatTurns } from "./turns.js";
 import { getRelayRuntime } from "./runtime.js";
 import { openRelayStateStore, } from "./state.js";
 const runningCredentials = new Map();
@@ -58,6 +59,7 @@ export async function startRelayAccount(ctx) {
         accountId: transportId,
     });
     const relay = createRelaySdkClient(account);
+    const turns = createRelayChatTurns();
     const ingress = createRelayIngressMonitor({
         queue: openIngressQueue({
             transportId,
@@ -80,6 +82,7 @@ export async function startRelayAccount(ctx) {
                 cfg: ctx.cfg,
                 relay,
                 runtime,
+                turns,
                 warn,
             });
         },

package/dist/src/inbound.js

@@ -1,3 +1,4 @@
+import { selectionReply, selectionReplyContext } from "@relaymessenger/sdk";
 function renderPart(part) {
     switch (part.type) {
         case "text":
@@ -8,12 +9,11 @@ function renderPart(part) {
             return `[Attachment: ${part.filename} (${part.mime_type})] ${part.url}`;
         case "system":
             return part.value;
-        // A tap reads as the label the person chose: the same text the server
-        // derives for a button_reply. The agent's own buttons part reads as
-        // nothing, again as the server does; its question is the text beside it.
-        case "button_reply":
-            return part.label;
+        // The agent's own buttons part reads as nothing, as on the server; its
+        // question is the text beside it. A tap arrives as ordinary text.
         case "buttons":
+        case "selection":
+        case "selection_response":
             return undefined;
     }
 }
@@ -44,7 +44,9 @@ export function buildRelayInboundFacts(event) {
         event.data.sender_handle.kind !== "agent")
         return null;
     const text = renderRelayMessageParts(event.data.parts);
-    if (!text.trim())
+    const message = { parts: event.data.parts, ...(event.data.reply_to ? { reply_to: event.data.reply_to } : {}) };
+    const richMessage = selectionReplyContext(undefined, message) ? message : undefined;
+    if (!text.trim() && !richMessage)
         return null;
     const mentionHandles = event.data.parts.flatMap((part) => part.type === "text" &&
         typeof part.mention === "string" &&
@@ -53,7 +55,23 @@ export function buildRelayInboundFacts(event) {
         : []);
     const timestampValue = event.data.sent_at ?? event.created_at;
     const timestamp = Date.parse(timestampValue);
+    const selection = selectionReply(event.data.parts, event.data.reply_to);
+    const fromAgent = event.data.sender_handle.kind === "agent";
+    // Another agent's Message is named by the answer, as Relay's CLI bridges
+    // do (packages/cli/src/bridge-turn.ts, PR 366): Relay's A2A door gives a
+    // calling agent only the answer whose reply_to names its Message
+    // (Relay-Server a2a.ts replyTo). A Message that opens with buttons or a
+    // selection is not named: an agent may not reply to those parts, and a
+    // reply names part 0.
+    const opening = event.data.parts[0]?.type;
+    const agentReplyLink = fromAgent && opening !== "buttons" && opening !== "selection"
+        ? event.data.id
+        : undefined;
     return {
+        ...(selection ? { selection } : {}),
+        ...(richMessage ? { richMessage } : {}),
+        fromAgent,
+        ...(agentReplyLink ? { agentReplyLink } : {}),
         eventId: event.event_id,
         messageId: event.data.id,
         chatId: event.data.chat.id,
@@ -70,9 +88,15 @@ export function buildRelayInboundFacts(event) {
         ...(event.data.reply_to?.message_id
             ? {
                 replyToId: event.data.reply_to.message_id,
-                replyAnchorId: event.data.parts.some((part) => part.type === "button_reply")
-                    ? event.data.id
-                    : event.data.reply_to.message_id,
+                ...(event.data.reply_to.part_index === undefined
+                    ? {}
+                    : { replyToPartIndex: event.data.reply_to.part_index }),
+                // The answer quotes the person's message, the one it answers (a bot's
+                // reply_to in Telegram and Discord names the person's message). A
+                // tap's reply_to names the agent's buttons part, which no reply may
+                // target, so this is also what keeps a tap answerable. An agent's
+                // Message is quoted only through agentReplyLink.
+                ...(fromAgent ? {} : { replyAnchorId: event.data.id }),
             }
             : {}),
         ...(Number.isFinite(timestamp) ? { timestamp } : {}),

package/dist/src/outbound.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { Relay, RelayAPIError, } from "@relaymessenger/sdk";
+import { answerMessages, createPaymentPart, indexedIdempotencyKey, Relay, RelayAPIError, } from "@relaymessenger/sdk";
 export const RELAY_TEXT_CHUNK_LIMIT = 10_000;
 const IDEMPOTENCY_KEY_MAX_LENGTH = 255;
 export function createRelaySdkClient(account) {
@@ -17,17 +17,49 @@ export function deriveRelayIdempotencyKey(params) {
         ? raw
         : `relay-openclaw:sha256:${createHash("sha256").update(raw).digest("hex")}`;
 }
+/**
+ * OpenClaw hands the agent's words as text, so buttons ride in them as the
+ * SDK's fenced block, lifted here into the buttons part, and a link written
+ * alone on a line goes out as its own link Message. A block that cannot be
+ * read stays in the words and is reported through `onButtonsError`. Without
+ * a block or a link line the words go exactly as OpenClaw handed them, in one
+ * Message; the response is the first Message's, the one the reply anchors to.
+ */
 export async function sendRelayText(params) {
     await params.onPlatformSendDispatch?.();
-    return await params.relay.chats.messages.send(params.chatId, {
-        message: {
-            parts: [{ type: "text", value: params.text }],
-            idempotency_key: params.idempotencyKey,
-            ...(params.replyToId
-                ? { reply_to: { message_id: params.replyToId } }
-                : {}),
-        },
-    }, params.signal ? { signal: params.signal } : undefined);
+    const { messages, payment, error } = answerMessages(params.text);
+    if (error)
+        params.onButtonsError?.(error);
+    if (messages.length === 0 && !payment)
+        messages.push([{ type: "text", value: params.text }]);
+    if (payment) {
+        // Created with the card's own key, so a retry of this delivery returns
+        // the same request. A refusal after words went out is reported and the
+        // words stand; with nothing sent yet, it is the delivery's own error.
+        const key = indexedIdempotencyKey(params.idempotencyKey, messages.length);
+        try {
+            messages.push([await createPaymentPart(params.relay, payment, key, params.signal ? { signal: params.signal } : undefined)]);
+        }
+        catch (refusal) {
+            if (!(refusal instanceof RelayAPIError) || refusal.retryable || messages.length === 0)
+                throw refusal;
+            params.onButtonsError?.(`the payment was not sent: ${refusal.message}`);
+        }
+    }
+    let first;
+    for (const [index, parts] of messages.entries()) {
+        const response = await params.relay.chats.messages.send(params.chatId, {
+            message: {
+                parts,
+                idempotency_key: indexedIdempotencyKey(params.idempotencyKey, index),
+                ...(index === 0 && params.replyToId
+                    ? { reply_to: { message_id: params.replyToId } }
+                    : {}),
+            },
+        }, params.signal ? { signal: params.signal } : undefined);
+        first ??= response;
+    }
+    return first;
 }
 export function classifyUnknownRelaySend(error) {
     if (!(error instanceof RelayAPIError)) {

package/dist/src/turns.js

@@ -0,0 +1,69 @@
+export function createRelayChatTurns() {
+    const running = new Map();
+    return {
+        track(chatId, work) {
+            const turns = running.get(chatId) ?? new Set();
+            running.set(chatId, turns);
+            const turn = work();
+            turns.add(turn);
+            const settle = () => {
+                turns.delete(turn);
+                if (turns.size === 0 && running.get(chatId) === turns)
+                    running.delete(chatId);
+            };
+            turn.then(settle, settle);
+            return turn;
+        },
+        busy: (chatId) => Boolean(running.get(chatId)?.size),
+        async idle(chatId, signal) {
+            for (;;) {
+                signal?.throwIfAborted();
+                const turns = running.get(chatId);
+                if (!turns?.size)
+                    return;
+                const settled = Promise.allSettled([...turns]);
+                if (!signal) {
+                    await settled;
+                    continue;
+                }
+                await new Promise((resolve, reject) => {
+                    const abort = () => reject(signal.reason);
+                    signal.addEventListener("abort", abort, { once: true });
+                    void settled.then(() => {
+                        signal.removeEventListener("abort", abort);
+                        resolve();
+                    });
+                });
+            }
+        },
+    };
+}
+/**
+ * Hold a claimed Relay event until its Chat is idle. The claim is handed off
+ * as deferred and kept alive with the drain's own heartbeat
+ * (`ChannelIngressDispatchLifecycle.onDeferred` / `onDeferredHeartbeat`,
+ * docs/plugins/sdk-channel-outbound.md "Deferred claim heartbeats"), so the
+ * adoption watchdog does not retry a Message that is only waiting its turn. On
+ * shutdown the wait rejects before adoption, and the drain keeps the event for
+ * the next start.
+ */
+export async function waitForIdleChat(params) {
+    const { lifecycle } = params;
+    if (!params.turns.busy(params.chatId))
+        return;
+    const signal = lifecycle.abortSignal;
+    lifecycle.onDeferred?.();
+    const interval = lifecycle.deferredHeartbeatIntervalMs;
+    const heartbeat = lifecycle.onDeferredHeartbeat && interval && interval > 0
+        ? setInterval(() => lifecycle.onDeferredHeartbeat?.(), interval)
+        : undefined;
+    heartbeat?.unref?.();
+    try {
+        await params.turns.idle(params.chatId, signal);
+    }
+    finally {
+        if (heartbeat)
+            clearInterval(heartbeat);
+    }
+}
+//# sourceMappingURL=turns.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relaymessenger/openclaw-plugin",
-  "version": "0.4.7-staging.4",
+  "version": "0.4.7-staging.40",
   "description": "Native Relay channel plugin for OpenClaw",
   "license": "MIT",
   "type": "module",
@@ -33,15 +33,15 @@
     "contract:verify": "node scripts/verify-contract-provenance.mjs",
     "contract:test": "node --test test/*.test.mjs",
     "pack:smoke": "node scripts/pack-smoke.mjs",
-    "gateway:harness": "node scripts/gateway-harness.mjs",
+    "gateway:harness": "node scripts/gateway-harness.mjs && node scripts/gateway-harness.mjs --overlap",
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@relaymessenger/sdk": "0.3.6-staging.4"
+    "@relaymessenger/sdk": "0.3.6-staging.47"
   },
   "devDependencies": {
-    "@types/node": "^26.0.0",
-    "openclaw": "2026.8.1",
+    "@types/node": "^26.6.2",
+    "openclaw": "2026.9.5",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },
@@ -164,7 +164,7 @@
       "pluginApi": ">=2026.8.1 <2026.10.0"
     },
     "build": {
-      "openclawVersion": "2026.8.1"
+      "openclawVersion": "2026.9.5"
     }
   }
 }

package/src/channel.ts

@@ -329,6 +329,10 @@ export const relayChannelPlugin: ChannelPlugin<ResolvedRelayAccount> =
               deliveryQueueId: ctx.deliveryQueueId,
               deliveryPartIndex: ctx.deliveryPartIndex,
             }),
+            onButtonsError: (error) =>
+              (ctx as { log?: { warn?: (message: string) => void } }).log?.warn?.(
+                `relay: component block left as text: ${error}`,
+              ),
             ...(ctx.onPlatformSendDispatch
               ? { onPlatformSendDispatch: ctx.onPlatformSendDispatch }
               : {}),

package/src/dispatch.ts

@@ -1,3 +1,4 @@
+import { BUTTONS_GUIDANCE, BUTTONS_BLOCK_INSTRUCTION, PAYMENT_BLOCK_INSTRUCTION, PAYMENT_GUIDANCE, LINK_LINE_INSTRUCTION, SELECTION_GUIDANCE, SELECTION_BLOCK_INSTRUCTION, selectionReplyContext } from "@relaymessenger/sdk";
 import type {
   Message,
   Relay,
@@ -10,9 +11,11 @@ import {
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { bindIngressLifecycleToReplyOptions } from "openclaw/plugin-sdk/channel-outbound";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
-import { buildRelayInboundFacts } from "./inbound.js";
+import type { ReplyPayload } from "openclaw/plugin-sdk/reply-payload";
+import { buildRelayInboundFacts, renderRelayMessageParts } from "./inbound.js";
 import type { RelayIngressLifecycle } from "./ingress.js";
 import type { PluginRuntime } from "./runtime.js";
+import { type RelayChatTurns, waitForIdleChat } from "./turns.js";
 import type {
   RelayCoreConfig,
   RelayInboundFacts,
@@ -52,6 +55,8 @@ function isReplyToAgentMessage(
 export async function resolveRelayTurnActivation(params: {
   facts: RelayInboundFacts;
   relay: RelayReplyLookup;
+  /** The replied-to Message when the caller already read it. */
+  replyTarget?: Message;
 }): Promise<RelayTurnActivation | null> {
   if (params.facts.chatType === "direct") {
     return {
@@ -74,9 +79,8 @@ export async function resolveRelayTurnActivation(params: {
   }
 
   if (!params.facts.replyToId) return null;
-  const replyTarget = await params.relay.messages.retrieve(
-    params.facts.replyToId,
-  );
+  const replyTarget = params.replyTarget
+    ?? await params.relay.messages.retrieve(params.facts.replyToId);
   if (!isReplyToAgentMessage(replyTarget, params.facts.chatId)) return null;
   return {
     kind: "reply",
@@ -85,6 +89,74 @@ export async function resolveRelayTurnActivation(params: {
   };
 }
 
+/**
+ * The Message a swipe-reply answers, read once for the quote and for group
+ * activation. A failed read is logged and the turn runs without the quote;
+ * group activation then reads it itself and fails the delivery as before.
+ */
+async function readReplyTarget(params: {
+  facts: RelayInboundFacts;
+  relay: RelayReplyLookup;
+  warn: ((message: string) => void) | undefined;
+}): Promise<Message | undefined> {
+  if (!params.facts.replyToId) return undefined;
+  try {
+    return await params.relay.messages.retrieve(params.facts.replyToId);
+  } catch (error) {
+    params.warn?.(
+      `relay: could not read the Message ${params.facts.replyToId} that ${params.facts.messageId} replies to: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return undefined;
+  }
+}
+
+/**
+ * OpenClaw's own reply context, `supplemental.quote`, which it renders to the
+ * model as "Reply target of current user message" (id, sender, body), as its
+ * Telegram channel fills it from Telegram's `reply_to_message`. A reply names
+ * one bubble: when the target has more than one part, only the swiped part is
+ * quoted, the rule Relay's iOS app uses to draw the quote.
+ */
+export function relayReplyQuote(
+  facts: Pick<RelayInboundFacts, "chatId" | "replyToPartIndex">,
+  target: Message | undefined,
+) {
+  if (!target || target.chat_id !== facts.chatId) return undefined;
+  const parts = target.parts ?? [];
+  const swiped = parts.length > 1 && facts.replyToPartIndex !== undefined
+    ? parts[facts.replyToPartIndex]
+    : undefined;
+  const body = renderRelayMessageParts(swiped ? [swiped] : parts);
+  const sender = target.from_handle?.display_name?.trim()
+    || target.from_handle?.handle
+    || target.from
+    || undefined;
+  return {
+    id: target.id,
+    ...(body ? { body } : {}),
+    ...(sender ? { sender } : {}),
+    senderAllowed: true,
+  };
+}
+
+/**
+ * The answer to another agent names the Message it answers: the model's own
+ * reply target when it chose one, else the agent's Message. Where no reply may
+ * point (a Message opening with buttons or a selection), OpenClaw's implicit
+ * current-message reply is removed.
+ */
+export function agentReplyPayload(
+  payload: ReplyPayload,
+  facts: Pick<RelayInboundFacts, "messageId" | "agentReplyLink">,
+): ReplyPayload {
+  if (facts.agentReplyLink) {
+    return { ...payload, replyToId: payload.replyToId ?? facts.agentReplyLink };
+  }
+  if (payload.replyToId !== facts.messageId) return payload;
+  const { replyToId: _unlinked, ...rest } = payload;
+  return rest;
+}
+
 export async function dispatchRelayEvent(params: {
   event: RelayWebhookEvent;
   lifecycle: RelayIngressLifecycle;
@@ -92,6 +164,7 @@ export async function dispatchRelayEvent(params: {
   cfg: RelayCoreConfig;
   relay: Pick<Relay, "chats" | "messages">;
   runtime: PluginRuntime;
+  turns: RelayChatTurns;
   warn?: (message: string) => void;
 }): Promise<void> {
   const facts = buildRelayInboundFacts(params.event);
@@ -102,9 +175,15 @@ export async function dispatchRelayEvent(params: {
     return;
   }
 
+  const repliedTo = await readReplyTarget({
+    facts,
+    relay: params.relay,
+    warn: params.warn,
+  });
   const activation = await resolveRelayTurnActivation({
     facts,
     relay: params.relay,
+    ...(repliedTo ? { replyTarget: repliedTo } : {}),
   });
   if (!activation) {
     params.warn?.(
@@ -202,12 +281,18 @@ export async function dispatchRelayEvent(params: {
     return;
   }
 
+  // An agent's reply target is only its own Message (agentReplyLink); a
+  // person's is the Message they replied from, as before.
+  const replyTarget = facts.fromAgent
+    ? facts.agentReplyLink
+    : facts.replyAnchorId ?? facts.replyToId;
   const body = buildEnvelope({
     channel: "Relay",
     from: `${facts.displayName} (@${facts.handle})`,
     ...(facts.timestamp ? { timestamp: facts.timestamp } : {}),
     body: facts.text,
   });
+  const quote = relayReplyQuote(facts, repliedTo);
   const ctxPayload = buildChannelInboundEventContext({
     channel: "relay",
     accountId: route.accountId ?? params.account.accountId,
@@ -236,17 +321,18 @@ export async function dispatchRelayEvent(params: {
     reply: {
       to: facts.chatId,
       originatingTo: facts.chatId,
-      ...((facts.replyAnchorId ?? facts.replyToId)
-        ? { replyToId: facts.replyAnchorId ?? facts.replyToId }
-        : {}),
+      ...(replyTarget ? { replyToId: replyTarget } : {}),
     },
     message: {
       inboundEventKind: "user_request",
       body,
-      bodyForAgent: facts.text,
+      bodyForAgent: [facts.text, selectionReplyContext(facts.selection, facts.richMessage),
+        `${BUTTONS_BLOCK_INSTRUCTION} ${LINK_LINE_INSTRUCTION} ${BUTTONS_GUIDANCE} ${SELECTION_BLOCK_INSTRUCTION} ${SELECTION_GUIDANCE} ${PAYMENT_BLOCK_INSTRUCTION} ${PAYMENT_GUIDANCE}`,
+      ].filter(Boolean).join("\n\n"),
       rawBody: facts.text,
       commandBody: facts.text,
     },
+    ...(quote ? { supplemental: { quote } } : {}),
     channelIngress: access,
     access: {
       commands: {
@@ -264,6 +350,16 @@ export async function dispatchRelayEvent(params: {
     },
   });
 
+  // Another agent's Message waits for the turn running in its Chat, so it
+  // gets a turn and an answer of its own (turns.ts).
+  if (facts.fromAgent) {
+    await waitForIdleChat({
+      turns: params.turns,
+      chatId: facts.chatId,
+      lifecycle: params.lifecycle,
+    });
+  }
+
   await Promise.allSettled([
     params.relay.chats.markAsRead(facts.chatId),
     params.relay.chats.startTyping(facts.chatId),
@@ -277,7 +373,7 @@ export async function dispatchRelayEvent(params: {
 
   let deliveryError: unknown;
   try {
-    await params.runtime.channel.inbound.dispatch({
+    await params.turns.track(facts.chatId, () => params.runtime.channel.inbound.dispatch({
       cfg: params.cfg as OpenClawConfig,
       channel: "relay",
       accountId: params.account.accountId,
@@ -290,9 +386,18 @@ export async function dispatchRelayEvent(params: {
       delivery: {
         durable: {
           to: facts.chatId,
-          replyToId: null,
+          replyToId: facts.fromAgent ? facts.agentReplyLink ?? null : null,
           requiredCapabilities: { reconcileUnknownSend: true },
         },
+        // Every answer to another agent names its Message, whatever
+        // `replyToMode` the operator chose; OpenClaw's own implicit
+        // current-message reply is dropped where no reply may point.
+        ...(facts.fromAgent
+          ? {
+              preparePayload: (payload: ReplyPayload) =>
+                agentReplyPayload(payload, facts),
+            }
+          : {}),
         deliver: async (_payload, info) => {
           if (info.kind === "final") {
             throw new Error(
@@ -317,7 +422,7 @@ export async function dispatchRelayEvent(params: {
             : new Error(`relay: session record failed: ${String(error)}`);
         },
       },
-    });
+    }));
     if (deliveryError) {
       throw deliveryError instanceof Error
         ? deliveryError

package/src/gateway.ts

@@ -10,6 +10,7 @@ import { dispatchRelayEvent } from "./dispatch.js";
 import { commitRelayFullSync } from "./full-sync.js";
 import { createRelayIngressMonitor } from "./ingress.js";
 import { createRelaySdkClient } from "./outbound.js";
+import { createRelayChatTurns } from "./turns.js";
 import { getRelayRuntime } from "./runtime.js";
 import {
   openRelayStateStore,
@@ -96,6 +97,7 @@ export async function startRelayAccount(
     accountId: transportId,
   });
   const relay = createRelaySdkClient(account);
+  const turns = createRelayChatTurns();
   const ingress = createRelayIngressMonitor({
     queue: openIngressQueue({
       transportId,
@@ -119,6 +121,7 @@ export async function startRelayAccount(
         cfg: ctx.cfg as RelayCoreConfig,
         relay,
         runtime,
+        turns,
         warn,
       });
     },

package/src/inbound.ts

@@ -1,3 +1,4 @@
+import { selectionReply, selectionReplyContext } from "@relaymessenger/sdk";
 import type {
   MessagePartResponse,
   RelayWebhookEvent,
@@ -17,12 +18,11 @@ function renderPart(part: MessagePartResponse): string | undefined {
       return `[Attachment: ${part.filename} (${part.mime_type})] ${part.url}`;
     case "system":
       return part.value;
-    // A tap reads as the label the person chose: the same text the server
-    // derives for a button_reply. The agent's own buttons part reads as
-    // nothing, again as the server does; its question is the text beside it.
-    case "button_reply":
-      return part.label;
+    // The agent's own buttons part reads as nothing, as on the server; its
+    // question is the text beside it. A tap arrives as ordinary text.
     case "buttons":
+    case "selection":
+    case "selection_response":
       return undefined;
   }
 }
@@ -64,7 +64,9 @@ export function buildRelayInboundFacts(
   ) return null;
 
   const text = renderRelayMessageParts(event.data.parts);
-  if (!text.trim()) return null;
+  const message = { parts: event.data.parts, ...(event.data.reply_to ? { reply_to: event.data.reply_to } : {}) };
+  const richMessage = selectionReplyContext(undefined, message) ? message : undefined;
+  if (!text.trim() && !richMessage) return null;
 
   const mentionHandles = event.data.parts.flatMap((part) =>
     part.type === "text" &&
@@ -75,7 +77,23 @@ export function buildRelayInboundFacts(
   );
   const timestampValue = event.data.sent_at ?? event.created_at;
   const timestamp = Date.parse(timestampValue);
+  const selection = selectionReply(event.data.parts, event.data.reply_to);
+  const fromAgent = event.data.sender_handle.kind === "agent";
+  // Another agent's Message is named by the answer, as Relay's CLI bridges
+  // do (packages/cli/src/bridge-turn.ts, PR 366): Relay's A2A door gives a
+  // calling agent only the answer whose reply_to names its Message
+  // (Relay-Server a2a.ts replyTo). A Message that opens with buttons or a
+  // selection is not named: an agent may not reply to those parts, and a
+  // reply names part 0.
+  const opening = event.data.parts[0]?.type;
+  const agentReplyLink = fromAgent && opening !== "buttons" && opening !== "selection"
+    ? event.data.id
+    : undefined;
   return {
+    ...(selection ? { selection } : {}),
+    ...(richMessage ? { richMessage } : {}),
+    fromAgent,
+    ...(agentReplyLink ? { agentReplyLink } : {}),
     eventId: event.event_id,
     messageId: event.data.id,
     chatId: event.data.chat.id,
@@ -93,9 +111,15 @@ export function buildRelayInboundFacts(
     ...(event.data.reply_to?.message_id
       ? {
         replyToId: event.data.reply_to.message_id,
-        replyAnchorId: event.data.parts.some((part) => part.type === "button_reply")
-          ? event.data.id
-          : event.data.reply_to.message_id,
+        ...(event.data.reply_to.part_index === undefined
+          ? {}
+          : { replyToPartIndex: event.data.reply_to.part_index }),
+        // The answer quotes the person's message, the one it answers (a bot's
+        // reply_to in Telegram and Discord names the person's message). A
+        // tap's reply_to names the agent's buttons part, which no reply may
+        // target, so this is also what keeps a tap answerable. An agent's
+        // Message is quoted only through agentReplyLink.
+        ...(fromAgent ? {} : { replyAnchorId: event.data.id }),
       }
       : {}),
     ...(Number.isFinite(timestamp) ? { timestamp } : {}),

package/src/outbound.ts

@@ -1,5 +1,8 @@
 import { createHash, randomUUID } from "node:crypto";
 import {
+  answerMessages,
+  createPaymentPart,
+  indexedIdempotencyKey,
   Relay,
   RelayAPIError,
   type MessageSendResponse,
@@ -32,29 +35,58 @@ export function deriveRelayIdempotencyKey(params: {
     : `relay-openclaw:sha256:${createHash("sha256").update(raw).digest("hex")}`;
 }
 
+/**
+ * OpenClaw hands the agent's words as text, so buttons ride in them as the
+ * SDK's fenced block, lifted here into the buttons part, and a link written
+ * alone on a line goes out as its own link Message. A block that cannot be
+ * read stays in the words and is reported through `onButtonsError`. Without
+ * a block or a link line the words go exactly as OpenClaw handed them, in one
+ * Message; the response is the first Message's, the one the reply anchors to.
+ */
 export async function sendRelayText(params: {
-  relay: Pick<Relay, "chats">;
+  relay: Pick<Relay, "chats" | "paymentRequests">;
   chatId: string;
   text: string;
   replyToId?: string | null | undefined;
   idempotencyKey: string;
   signal?: AbortSignal;
   onPlatformSendDispatch?: () => Promise<void>;
+  onButtonsError?: (error: string) => void;
 }): Promise<MessageSendResponse> {
   await params.onPlatformSendDispatch?.();
-  return await params.relay.chats.messages.send(
-    params.chatId,
-    {
-      message: {
-        parts: [{ type: "text", value: params.text }],
-        idempotency_key: params.idempotencyKey,
-        ...(params.replyToId
-          ? { reply_to: { message_id: params.replyToId } }
-          : {}),
+  const { messages, payment, error } = answerMessages(params.text);
+  if (error) params.onButtonsError?.(error);
+  if (messages.length === 0 && !payment) messages.push([{ type: "text", value: params.text }]);
+  if (payment) {
+    // Created with the card's own key, so a retry of this delivery returns
+    // the same request. A refusal after words went out is reported and the
+    // words stand; with nothing sent yet, it is the delivery's own error.
+    const key = indexedIdempotencyKey(params.idempotencyKey, messages.length);
+    try {
+      messages.push([await createPaymentPart(params.relay, payment, key, params.signal ? { signal: params.signal } : undefined)]);
+    } catch (refusal) {
+      if (!(refusal instanceof RelayAPIError) || refusal.retryable || messages.length === 0) throw refusal;
+      params.onButtonsError?.(`the payment was not sent: ${refusal.message}`);
+    }
+  }
+  let first: MessageSendResponse | undefined;
+  for (const [index, parts] of messages.entries()) {
+    const response = await params.relay.chats.messages.send(
+      params.chatId,
+      {
+        message: {
+          parts,
+          idempotency_key: indexedIdempotencyKey(params.idempotencyKey, index),
+          ...(index === 0 && params.replyToId
+            ? { reply_to: { message_id: params.replyToId } }
+            : {}),
+        },
       },
-    },
-    params.signal ? { signal: params.signal } : undefined,
-  );
+      params.signal ? { signal: params.signal } : undefined,
+    );
+    first ??= response;
+  }
+  return first!;
 }
 
 export function classifyUnknownRelaySend(error: unknown): {

package/src/turns.ts

@@ -0,0 +1,94 @@
+import type { RelayIngressLifecycle } from "./ingress.js";
+
+/**
+ * The OpenClaw turns running in each Chat of one Relay account, so another
+ * agent's Message can wait for them instead of steering into them.
+ *
+ * OpenClaw steers a Message that arrives mid-turn into the running turn by
+ * default (`messages.queue.mode` "steer", docs/concepts/queue.md), and that
+ * turn's answer names the first Message. With `followup` the queued turn's
+ * answer names none. Relay's A2A door gives each calling agent only the answer
+ * whose `reply_to` names its Message (Relay-Server `a2a.ts` `replyTo`), so the
+ * second of two overlapping calls got no answer. A channel plugin "may
+ * preserve ordering ... before a message enters the session queue"
+ * (docs/concepts/messages.md, Queueing and followups); this is that ordering,
+ * the same rule Relay's CLI bridges follow (`replacesLiveTurn`, PR 366): an
+ * agent's Message waits its turn, a person's Message is left to OpenClaw.
+ */
+export type RelayChatTurns = {
+  /** Run one dispatch into OpenClaw, recorded as running in its Chat until it settles. */
+  track<T>(chatId: string, work: () => Promise<T>): Promise<T>;
+  /** Whether a turn runs in the Chat now. */
+  busy(chatId: string): boolean;
+  /** Resolve once no turn runs in the Chat; reject with the signal's reason. */
+  idle(chatId: string, signal?: AbortSignal): Promise<void>;
+};
+
+export function createRelayChatTurns(): RelayChatTurns {
+  const running = new Map<string, Set<Promise<unknown>>>();
+  return {
+    track(chatId, work) {
+      const turns = running.get(chatId) ?? new Set<Promise<unknown>>();
+      running.set(chatId, turns);
+      const turn = work();
+      turns.add(turn);
+      const settle = () => {
+        turns.delete(turn);
+        if (turns.size === 0 && running.get(chatId) === turns) running.delete(chatId);
+      };
+      turn.then(settle, settle);
+      return turn;
+    },
+    busy: (chatId) => Boolean(running.get(chatId)?.size),
+    async idle(chatId, signal) {
+      for (;;) {
+        signal?.throwIfAborted();
+        const turns = running.get(chatId);
+        if (!turns?.size) return;
+        const settled = Promise.allSettled([...turns]);
+        if (!signal) {
+          await settled;
+          continue;
+        }
+        await new Promise<void>((resolve, reject) => {
+          const abort = () => reject(signal.reason);
+          signal.addEventListener("abort", abort, { once: true });
+          void settled.then(() => {
+            signal.removeEventListener("abort", abort);
+            resolve();
+          });
+        });
+      }
+    },
+  };
+}
+
+/**
+ * Hold a claimed Relay event until its Chat is idle. The claim is handed off
+ * as deferred and kept alive with the drain's own heartbeat
+ * (`ChannelIngressDispatchLifecycle.onDeferred` / `onDeferredHeartbeat`,
+ * docs/plugins/sdk-channel-outbound.md "Deferred claim heartbeats"), so the
+ * adoption watchdog does not retry a Message that is only waiting its turn. On
+ * shutdown the wait rejects before adoption, and the drain keeps the event for
+ * the next start.
+ */
+export async function waitForIdleChat(params: {
+  turns: RelayChatTurns;
+  chatId: string;
+  lifecycle: Partial<RelayIngressLifecycle>;
+}): Promise<void> {
+  const { lifecycle } = params;
+  if (!params.turns.busy(params.chatId)) return;
+  const signal = lifecycle.abortSignal;
+  lifecycle.onDeferred?.();
+  const interval = lifecycle.deferredHeartbeatIntervalMs;
+  const heartbeat = lifecycle.onDeferredHeartbeat && interval && interval > 0
+    ? setInterval(() => lifecycle.onDeferredHeartbeat?.(), interval)
+    : undefined;
+  heartbeat?.unref?.();
+  try {
+    await params.turns.idle(params.chatId, signal);
+  } finally {
+    if (heartbeat) clearInterval(heartbeat);
+  }
+}

package/src/types.ts

@@ -1,5 +1,8 @@
 import type {
   Chat,
+  SelectionReply,
+  MessagePartResponse,
+  ReplyTo,
   ChatHandle,
   MessageWebhookData,
   Message,
@@ -61,6 +64,8 @@ export type RelayMessageReceivedEvent = RelayWebhookEnvelope<
 >;
 
 export type RelayInboundFacts = {
+  selection?: SelectionReply;
+  richMessage?: { parts: MessagePartResponse[]; reply_to?: ReplyTo | null };
   eventId: string;
   messageId: string;
   chatId: string;
@@ -72,12 +77,20 @@ export type RelayInboundFacts = {
   mentionHandles: string[];
   ownerHandle?: ChatHandle;
   replyToId?: string;
+  /** The part of the replied-to Message the person swiped (`reply_to.part_index`). */
+  replyToPartIndex?: number;
   /**
-   * The Message an outbound reply should quote. A tap's reply_to names the
-   * agent's buttons part, which only a button_reply may target, so the
-   * agent's answer quotes the tap itself; every other Message quotes what
-   * the person quoted.
+   * The Message an outbound reply should quote when the person's Message
+   * was itself a reply: the person's Message. A tap's reply_to names the
+   * agent's buttons part, which no reply may target.
    */
   replyAnchorId?: string;
+  /** Whether another agent sent the Message. */
+  fromAgent: boolean;
+  /**
+   * The Message every answer names when another agent sent it: this one,
+   * unless it opens with buttons or a selection, which no reply may target.
+   */
+  agentReplyLink?: string;
   timestamp?: number;
 };