@relaymessenger/openclaw-plugin 0.3.3 → 0.3.4

package/dist/src/channel.js

@@ -24,6 +24,7 @@ import { createRelayClient, isAbortError, isRelayWebhookConflict, RelayApiError,
 import { createRelayCursorStore, openRelayCursorStateStore } from "./cursor-store.js";
 import { createRelayInboundDedupeGuard, createRelayInboundDeduper } from "./inbound-dedupe.js";
 import { buildRelayInboundFacts } from "./inbound.js";
+import { relayInvocationFor, rememberRelayInvocation } from "./invocations.js";
 import { createRelayAccountLifecycleRegistry } from "./lifecycle.js";
 import { deriveRelayIdempotencyKey, RELAY_TEXT_CHUNK_LIMIT, reconcileRelayUnknownSend, sendRelayText, } from "./outbound.js";
 import { runRelayPollLoop } from "./poll-loop.js";
@@ -105,11 +106,16 @@ const relayMessageAdapter = defineChannelMessageAdapter({
             if (text === null) {
                 return null;
             }
+            const invocationId = relayInvocationFor({
+                accountId: account.accountId,
+                conversationId: ctx.to,
+            });
             const verdict = await reconcileRelayUnknownSend({
                 client: relayClientForAccount(account),
                 conversationId: ctx.to,
                 text,
                 replyToId: ctx.effectiveReplyToId ?? ctx.replyToId ?? null,
+                ...(invocationId ? { invocationId } : {}),
                 idempotencyKey: deriveRelayIdempotencyKey({ deliveryQueueId: ctx.queueId }),
             });
             if (verdict.status === "sent") {
@@ -138,11 +144,19 @@ const relayMessageAdapter = defineChannelMessageAdapter({
             if (!account.configured) {
                 throw new Error(`relay: account "${account.accountId}" has no Agent Token configured`);
             }
+            // A group reply must name the invocation it answers. Core's send context
+            // has no field for it, so the turn parks it in the invocation registry
+            // under (accountId, conversationId) and it is read back here.
+            const invocationId = relayInvocationFor({
+                accountId: account.accountId,
+                conversationId: ctx.to,
+            });
             const result = await sendRelayText({
                 client: relayClientForAccount(account),
                 conversationId: ctx.to,
                 text: ctx.text,
                 replyToId: ctx.replyToId ?? null,
+                ...(invocationId ? { invocationId } : {}),
                 // Stable per (queueId, part): internal retries replay the same key,
                 // so the server-side idempotent commit makes duplicates impossible by
                 // contract. On a core with no part index the text names the part.
@@ -242,81 +256,97 @@ async function dispatchRelayInbound(params) {
     const recordDeliveryError = (error) => {
         deliveryError ??= error;
     };
-    // Admission, runtime resolution, route/session lookup, envelope building,
-    // and context finalization above are replay-safe. The durable attempt starts
-    // immediately before OpenClaw can invoke the agent or its tools.
-    await markRespondingBeforeAttempt({
-        client: params.client,
-        conversationId: facts.conversationId,
-        messageId: facts.messageId,
-        label: "OpenClaw",
-        markAttempt: params.markAttempt,
-    });
-    await runtime.channel.inbound.dispatchReply({
-        cfg: params.cfg,
-        channel: RELAY_CHANNEL_ID,
-        accountId: account.accountId,
-        agentId: route.agentId,
-        routeSessionKey: route.sessionKey,
-        storePath,
-        ctxPayload,
-        recordInboundSession: runtime.channel.session.recordInboundSession,
-        dispatchReplyWithBufferedBlockDispatcher: runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
-        delivery: {
-            // Final replies go through the durable message adapter: core renders
-            // and chunks them (chunker + textChunkLimit) and tracks the send as a
-            // durable queue intent. Requiring reconcileUnknownSend forces
-            // `durability: "required"`, so single-payload finals carry a stable
-            // deliveryQueueId into send.text (stable idempotency key + exact
-            // replay), and multi-chunk finals get core's queue-level crash
-            // recovery. Replies land as plain messages, not quotes
-            // (`replyToId: null`).
-            durable: {
-                to: facts.conversationId,
-                replyToId: null,
-                requiredCapabilities: { reconcileUnknownSend: true },
-            },
-            // Fallback for payloads the durable path does not carry (non-final
-            // visible blocks). The event id + block/chunk ordinals identify each
-            // logical send: retries reuse it while identical intentional blocks and
-            // chunks remain distinct.
-            deliver: async (payload) => {
-                const text = payload && typeof payload === "object" && "text" in payload
-                    ? (payload.text ?? "")
-                    : "";
-                if (!text.trim()) {
-                    return;
-                }
-                const logicalBlockId = `${facts.eventId}:block:${fallbackDeliveryIndex}`;
-                fallbackDeliveryIndex += 1;
-                try {
-                    let chunkIndex = 0;
-                    for (const chunk of chunkText(text, RELAY_TEXT_CHUNK_LIMIT)) {
-                        await sendRelayText({
-                            client: params.client,
-                            conversationId: facts.conversationId,
-                            text: chunk,
-                            idempotencyKey: deriveRelayIdempotencyKey({
-                                deliveryQueueId: logicalBlockId,
-                                deliveryPartIndex: chunkIndex,
-                            }),
-                        });
-                        chunkIndex += 1;
+    // Park the group invocation for the life of the turn. Core's durable send
+    // adapter is a separate entry point with no inbound context, so this is how
+    // the reply learns which invocation it answers.
+    const releaseInvocation = facts.invocationId
+        ? rememberRelayInvocation({
+            accountId: account.accountId,
+            conversationId: facts.conversationId,
+            invocationId: facts.invocationId,
+        })
+        : () => { };
+    try {
+        // Admission, runtime resolution, route/session lookup, envelope building,
+        // and context finalization above are replay-safe. The durable attempt starts
+        // immediately before OpenClaw can invoke the agent or its tools.
+        await markRespondingBeforeAttempt({
+            client: params.client,
+            facts,
+            label: "OpenClaw",
+            markAttempt: params.markAttempt,
+            ...(params.warn ? { onReceiptFailure: params.warn } : {}),
+        });
+        await runtime.channel.inbound.dispatchReply({
+            cfg: params.cfg,
+            channel: RELAY_CHANNEL_ID,
+            accountId: account.accountId,
+            agentId: route.agentId,
+            routeSessionKey: route.sessionKey,
+            storePath,
+            ctxPayload,
+            recordInboundSession: runtime.channel.session.recordInboundSession,
+            dispatchReplyWithBufferedBlockDispatcher: runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
+            delivery: {
+                // Final replies go through the durable message adapter: core renders
+                // and chunks them (chunker + textChunkLimit) and tracks the send as a
+                // durable queue intent. Requiring reconcileUnknownSend forces
+                // `durability: "required"`, so single-payload finals carry a stable
+                // deliveryQueueId into send.text (stable idempotency key + exact
+                // replay), and multi-chunk finals get core's queue-level crash
+                // recovery. Replies land as plain messages, not quotes
+                // (`replyToId: null`).
+                durable: {
+                    to: facts.conversationId,
+                    replyToId: null,
+                    requiredCapabilities: { reconcileUnknownSend: true },
+                },
+                // Fallback for payloads the durable path does not carry (non-final
+                // visible blocks). The event id + block/chunk ordinals identify each
+                // logical send: retries reuse it while identical intentional blocks and
+                // chunks remain distinct.
+                deliver: async (payload) => {
+                    const text = payload && typeof payload === "object" && "text" in payload
+                        ? (payload.text ?? "")
+                        : "";
+                    if (!text.trim()) {
+                        return;
                     }
-                }
-                catch (error) {
-                    recordDeliveryError(error);
-                    throw error;
-                }
+                    const logicalBlockId = `${facts.eventId}:block:${fallbackDeliveryIndex}`;
+                    fallbackDeliveryIndex += 1;
+                    try {
+                        let chunkIndex = 0;
+                        for (const chunk of chunkText(text, RELAY_TEXT_CHUNK_LIMIT)) {
+                            await sendRelayText({
+                                client: params.client,
+                                conversationId: facts.conversationId,
+                                text: chunk,
+                                ...(facts.invocationId ? { invocationId: facts.invocationId } : {}),
+                                idempotencyKey: deriveRelayIdempotencyKey({
+                                    deliveryQueueId: logicalBlockId,
+                                    deliveryPartIndex: chunkIndex,
+                                }),
+                            });
+                            chunkIndex += 1;
+                        }
+                    }
+                    catch (error) {
+                        recordDeliveryError(error);
+                        throw error;
+                    }
+                },
+                onError: recordDeliveryError,
             },
-            onError: recordDeliveryError,
-        },
-        replyPipeline: {},
-    });
-    if (deliveryError) {
-        throw deliveryError instanceof Error
-            ? deliveryError
-            : new Error(`relay reply delivery failed: ${String(deliveryError)}`);
+            replyPipeline: {},
+        });
+        if (deliveryError) {
+            throw deliveryError instanceof Error
+                ? deliveryError
+                : new Error(`relay reply delivery failed: ${String(deliveryError)}`);
+        }
+    }
+    finally {
+        releaseInvocation();
     }
 }
 // ---------------------------------------------------------------------------
@@ -440,6 +470,7 @@ async function startRelayAccount(ctx) {
                     client,
                     allowedSenderIds,
                     markAttempt,
+                    warn,
                 });
             },
         });
@@ -448,7 +479,11 @@ async function startRelayAccount(ctx) {
         if (abortSignal.aborted || isAbortError(error)) {
             return;
         }
-        if (error instanceof RelayApiError && error.terminal) {
+        // Named as `kind === "auth"`, not `error.terminal`. The SDK client counts
+        // every non-retryable kind as terminal, which would swallow the 409 cases
+        // below — including `terminated_by_other_consumer`, whose whole point is
+        // to fall through to the supervisor's restart arbitration.
+        if (error instanceof RelayApiError && error.kind === "auth") {
             markTerminalDisconnect(error);
         }
         else if (isRelayWebhookConflict(error)) {

package/dist/src/client.js

@@ -1,229 +1,13 @@
-// Thin Relay REST client boundary for the standalone OpenClaw channel plugin.
-// Owns the abort-aware long poll, idempotent sends, typing, responding, and
-// read watermarks without loading an OpenClaw runtime in unit tests.
-import { isIP } from "node:net";
-export const DEFAULT_RELAY_BASE_URL = "https://api.relayapp.im";
-function isLoopbackHostname(hostname) {
-    const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, "");
-    const ipVersion = isIP(normalized);
-    if (ipVersion === 4) {
-        return normalized.split(".")[0] === "127";
-    }
-    if (ipVersion === 6) {
-        return normalized === "::1";
-    }
-    return (normalized === "localhost" ||
-        normalized.endsWith(".localhost"));
-}
-/**
- * Validate and canonicalize the API origin before a bearer token can be sent
- * to it. Production/custom remote origins must use HTTPS. Plain HTTP remains
- * available only for an explicit loopback development server.
- */
-export function normalizeRelayBaseUrl(raw) {
-    const candidate = raw?.trim() || DEFAULT_RELAY_BASE_URL;
-    let url;
-    try {
-        url = new URL(candidate);
-    }
-    catch {
-        throw new Error(`relay: invalid baseUrl ${JSON.stringify(candidate)}`);
-    }
-    if (url.username || url.password) {
-        throw new Error("relay: baseUrl must not contain credentials");
-    }
-    if (url.search || url.hash) {
-        throw new Error("relay: baseUrl must not contain a query or fragment");
-    }
-    if (!/^\/+$/u.test(url.pathname)) {
-        throw new Error("relay: baseUrl must be an origin without a path");
-    }
-    if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopbackHostname(url.hostname))) {
-        throw new Error("relay: baseUrl must use HTTPS (HTTP is allowed only for loopback development)");
-    }
-    return url.origin;
-}
-/** Classified Relay API failure. `terminal` means operator action (bad token). */
-export class RelayApiError extends Error {
-    status;
-    kind;
-    /** Server error code from the response body (`error.code`), when present. */
-    code;
-    constructor(message, params) {
-        super(message);
-        this.name = "RelayApiError";
-        this.status = params.status;
-        this.kind = params.kind;
-        this.code = params.code;
-    }
-    get terminal() {
-        return this.kind === "auth";
-    }
-    get retryable() {
-        return this.kind === "retryable";
-    }
-}
-/**
- * 409 from the webhook XOR rule: an enabled webhook endpoint makes long
- * polling unavailable until the operator disables it (server code
- * `conflict`, distinct from `terminated_by_other_consumer`).
- */
-export function isRelayWebhookConflict(error) {
-    return (error instanceof RelayApiError &&
-        error.status === 409 &&
-        error.code !== "terminated_by_other_consumer");
-}
-export function classifyRelayHttpStatus(status) {
-    if (status === 401) {
-        return "auth";
-    }
-    if (status === 409) {
-        return "conflict";
-    }
-    if (status === 408 || status === 429 || status >= 500) {
-        return "retryable";
-    }
-    return "rejected";
-}
-export function isAbortError(error) {
-    return error instanceof Error && error.name === "AbortError";
-}
-async function readErrorDetail(response) {
-    try {
-        const body = (await response.json());
-        return {
-            ...(body?.error?.code ? { code: body.error.code } : {}),
-            message: body?.error?.message ?? body?.message ?? "",
-        };
-    }
-    catch {
-        return { message: "" };
-    }
-}
-export function createRelayClient(options) {
-    const baseUrl = normalizeRelayBaseUrl(options.baseUrl);
-    const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
-    const requestTimeoutMs = options.requestTimeoutMs ?? 15_000;
-    const request = async (params) => {
-        const url = new URL(`${baseUrl}${params.path}`);
-        for (const [key, value] of Object.entries(params.query ?? {})) {
-            if (value !== undefined) {
-                url.searchParams.set(key, String(value));
-            }
-        }
-        let response;
-        const timeoutSignal = AbortSignal.timeout(params.timeoutMs ?? requestTimeoutMs);
-        const signal = params.signal
-            ? AbortSignal.any([params.signal, timeoutSignal])
-            : timeoutSignal;
-        try {
-            response = await fetchImpl(url.toString(), {
-                method: params.method,
-                headers: {
-                    authorization: `Bearer ${options.token}`,
-                    ...(params.body === undefined ? {} : { "content-type": "application/json" }),
-                    ...params.headers,
-                },
-                ...(params.body === undefined ? {} : { body: JSON.stringify(params.body) }),
-                signal,
-            });
-        }
-        catch (error) {
-            if (timeoutSignal.aborted && !params.signal?.aborted) {
-                throw new RelayApiError(`relay: ${params.method} ${params.path} timed out after ${params.timeoutMs ?? requestTimeoutMs}ms`, { kind: "retryable" });
-            }
-            if (isAbortError(error)) {
-                throw error;
-            }
-            // Network-level failure (DNS, reset, offline): always retryable.
-            throw new RelayApiError(`relay: network error: ${String(error)}`, { kind: "retryable" });
-        }
-        if (!response.ok) {
-            const detail = await readErrorDetail(response);
-            throw new RelayApiError(`relay: ${params.method} ${params.path} failed with ${response.status}${detail.message ? `: ${detail.message}` : ""}`, {
-                status: response.status,
-                kind: classifyRelayHttpStatus(response.status),
-                ...(detail.code ? { code: detail.code } : {}),
-            });
-        }
-        return response;
-    };
-    return {
-        getMe: async (params) => {
-            const response = await request({
-                method: "GET",
-                path: "/v1/agents/me",
-                signal: params?.signal,
-            });
-            const body = (await response.json());
-            return body.agent;
-        },
-        pollEvents: async (params) => {
-            const timeoutSeconds = Math.min(Math.max(params.timeoutSeconds ?? 30, 1), 30);
-            // Guard against a wedged connection: the server holds <= timeout seconds,
-            // so anything past timeout + slack is a dead socket, not a slow poll.
-            const response = await request({
-                method: "GET",
-                path: "/v1/events",
-                query: {
-                    cursor: params.cursor,
-                    timeout: timeoutSeconds,
-                    ...(params.limit === undefined ? {} : { limit: params.limit }),
-                },
-                signal: params.signal,
-                timeoutMs: (timeoutSeconds + 15) * 1_000,
-            });
-            const body = (await response.json());
-            const events = Array.isArray(body.events) ? body.events : [];
-            const nextCursor = typeof body.next_cursor === "number" && Number.isSafeInteger(body.next_cursor)
-                ? body.next_cursor
-                : params.cursor;
-            return { events, nextCursor };
-        },
-        sendMessage: async (params) => {
-            const response = await request({
-                method: "POST",
-                path: "/v1/messages",
-                headers: { "idempotency-key": params.idempotencyKey },
-                body: {
-                    conversation_id: params.conversationId,
-                    parts: params.parts,
-                    ...(params.replyTo ? { reply_to: params.replyTo } : {}),
-                },
-                signal: params.signal,
-            });
-            const body = (await response.json());
-            return { messages: body.messages };
-        },
-        setTyping: async (params) => {
-            await request({
-                method: "POST",
-                path: `/v1/conversations/${encodeURIComponent(params.conversationId)}/typing`,
-                body: {
-                    started: params.started,
-                    ...(params.label ? { label: params.label } : {}),
-                },
-                signal: params.signal,
-            });
-        },
-        setResponding: async (params) => {
-            await request({
-                method: "POST",
-                path: `/v1/conversations/${encodeURIComponent(params.conversationId)}/responding`,
-                body: {
-                    message_id: params.messageId,
-                    ...(params.label ? { label: params.label } : {}),
-                },
-                signal: params.signal,
-            });
-        },
-        markRead: async (params) => {
-            await request({
-                method: "POST",
-                path: `/v1/conversations/${encodeURIComponent(params.conversationId)}/read`,
-                body: { message_id: params.messageId },
-                signal: params.signal,
-            });
-        },
-    };
-}
+// The Relay API client the plugin uses. There is no implementation here: this
+// is `@relaymessenger/sdk`'s client, vendored under `./vendor/relay-sdk`
+// (see that directory's README for why, and for the one-file swap when the
+// package ships).
+//
+// The plugin used to hand-roll its own client beside the SDK's. They drifted,
+// and the drift was a defect: the hand-rolled one had no `invocationId` on
+// `sendMessage`, `setTyping`, or `setResponding`, so an agent's first group
+// mention wedged its entire event stream (REL-167).
+import { createRelayClient as createVendoredRelayClient } from "./vendor/relay-sdk/client.js";
+export { DEFAULT_RELAY_BASE_URL, normalizeRelayBaseUrl } from "./vendor/relay-sdk/url.js";
+export { classifyRelayHttpStatus, isAbortError, isRelayWebhookConflict, RelayApiError, } from "./vendor/relay-sdk/errors.js";
+export const createRelayClient = createVendoredRelayClient;

package/dist/src/inbound.js

@@ -81,6 +81,10 @@ export function buildRelayInboundFacts(event, params) {
         return null;
     }
     const createdAtMs = Date.parse(message.created_at);
+    const invocationId = typeof event.data.invocation_id === "string"
+        && event.data.invocation_id.trim()
+        ? event.data.invocation_id
+        : undefined;
     return {
         eventId: event.event_id,
         messageId: message.id,
@@ -90,5 +94,6 @@ export function buildRelayInboundFacts(event, params) {
         ...(message.reply_to?.message_id ? { replyToId: message.reply_to.message_id } : {}),
         text,
         ...(Number.isFinite(createdAtMs) ? { timestamp: createdAtMs } : {}),
+        ...(invocationId ? { invocationId } : {}),
     };
 }

package/dist/src/invocations.js

@@ -0,0 +1,47 @@
+/**
+ * Which group invocation an in-flight turn belongs to.
+ *
+ * Relay mints an invocation when a human invokes an agent in a group, and
+ * every call the agent then makes about that message has to carry the id back:
+ * `/typing` and `/responding` refuse without it, and so does the reply itself.
+ *
+ * The reply does not leave through this plugin's own code. It leaves through
+ * core's durable message adapter, whose send context carries `to`, `text`, and
+ * delivery bookkeeping and nothing about the message being answered
+ * (`ChannelMessageSendTextContext`). There is no field to thread the id
+ * through, so the turn parks it here for the adapter to find.
+ *
+ * Keyed by (accountId, conversationId) because `to` and `accountId` are all
+ * the adapter knows. Two agents in one group get separate slots. Two
+ * overlapping turns for ONE agent in ONE group share a slot and the later one
+ * wins — bounded by the server, which spends an invocation exactly once and
+ * refuses the loser rather than misattributing it.
+ */
+const pendingInvocations = new Map();
+function slotKey(accountId, conversationId) {
+    return `${accountId}\0${conversationId}`;
+}
+/**
+ * Hold `invocationId` for the life of one turn. Returns the release function;
+ * call it in a `finally` so a thrown turn cannot strand the slot.
+ *
+ * Releasing only clears the slot if this turn still owns it, so a turn that
+ * finishes after being superseded cannot delete its successor's id.
+ */
+export function rememberRelayInvocation(params) {
+    const key = slotKey(params.accountId, params.conversationId);
+    pendingInvocations.set(key, params.invocationId);
+    return () => {
+        if (pendingInvocations.get(key) === params.invocationId) {
+            pendingInvocations.delete(key);
+        }
+    };
+}
+/** The invocation an outbound send in this conversation belongs to, if any. */
+export function relayInvocationFor(params) {
+    return pendingInvocations.get(slotKey(params.accountId, params.conversationId));
+}
+/** Test seam: drop every slot. */
+export function resetRelayInvocationsForTest() {
+    pendingInvocations.clear();
+}

package/dist/src/outbound.js

@@ -58,6 +58,7 @@ export async function sendRelayText(params) {
                 conversationId: params.conversationId,
                 parts: [{ type: "text", text: params.text }],
                 ...(params.replyToId ? { replyTo: { message_id: params.replyToId } } : {}),
+                ...(params.invocationId ? { invocationId: params.invocationId } : {}),
                 idempotencyKey: params.idempotencyKey,
                 ...(params.signal ? { signal: params.signal } : {}),
             });
@@ -90,6 +91,7 @@ export async function reconcileRelayUnknownSend(params) {
             conversationId: params.conversationId,
             text: params.text,
             replyToId: params.replyToId ?? null,
+            ...(params.invocationId ? { invocationId: params.invocationId } : {}),
             idempotencyKey: params.idempotencyKey,
         });
         return { status: "sent", messageId: result.messageId, messages: result.messages };

package/dist/src/poll-loop.js

@@ -94,6 +94,18 @@ export async function runRelayPollLoop(params) {
                 catch (error) {
                     if (!attempted) {
                         params.deduper.releaseEvent(event.event_id);
+                        // A rejection is the server's final answer: replaying the identical
+                        // request produces the identical refusal. Holding the cursor for it
+                        // is a livelock, and the cursor is ONE watermark for the whole
+                        // channel — so a single permanently-refused event would starve every
+                        // later message, direct ones included (REL-167). Losing one event is
+                        // strictly better than losing the channel, so log it loudly and let
+                        // the page cursor move past it.
+                        if (error instanceof RelayApiError && error.kind === "rejected") {
+                            log(`[relay] event ${event.event_id} was permanently rejected by the server, ` +
+                                `skipping it so later messages are not starved: ${String(error)}`);
+                            continue;
+                        }
                         log(`[relay] event ${event.event_id} safe preflight failed, will replay: ${String(error)}`);
                         batchFailed = true;
                         break;

package/dist/src/responding.js

@@ -1,13 +1,36 @@
+import { RelayApiError } from "./client.js";
 /**
- * The receipt must commit before OpenClaw can run an agent or tool. A rejected
- * receipt leaves the durable attempt marker untouched, so the poll loop can
- * replay the event safely instead of hiding the failure after execution.
+ * Record the read/responding receipt, then commit the durable attempt marker.
+ *
+ * The receipt is a courtesy to the person waiting: it turns their message Read
+ * and shows that something is composing. It is NOT permission to answer, and
+ * it used to be treated as such — a rejected receipt threw here, before
+ * `markAttempt`, which sent the poll loop down its replay branch and froze the
+ * channel's single delivery cursor. One group mention whose receipt the server
+ * refused therefore starved every later message, direct ones included
+ * (REL-167).
+ *
+ * So a failed receipt is reported and the turn continues. The ordering that
+ * mattered is kept: the receipt is still attempted BEFORE the attempt marker,
+ * so a receipt that succeeds still precedes any agent or tool work.
  */
 export async function markRespondingBeforeAttempt(params) {
-    await params.client.setResponding({
-        conversationId: params.conversationId,
-        messageId: params.messageId,
-        label: params.label,
-    });
+    const { facts } = params;
+    try {
+        await params.client.setResponding({
+            conversationId: facts.conversationId,
+            messageId: facts.messageId,
+            label: params.label,
+            ...(facts.invocationId ? { invocationId: facts.invocationId } : {}),
+        });
+    }
+    catch (error) {
+        // An aborted shutdown is not a receipt failure; let it settle the loop.
+        if (error instanceof Error && error.name === "AbortError") {
+            throw error;
+        }
+        const detail = error instanceof RelayApiError ? error.message : String(error);
+        params.onReceiptFailure?.(`responding receipt for message ${facts.messageId} failed, answering anyway: ${detail}`);
+    }
     await params.markAttempt();
 }