@newbase-clawchat/openclaw-clawchat 2026.5.12-7 → 2026.5.12-9

package/README.md

@@ -64,17 +64,18 @@ openclaw channels login --channel openclaw-clawchat
 
 OpenClaw 2026.5.5 can load an npm-installed third-party channel while still
 omitting it from the `channels add` CLI catalog. If `channels add` fails with
-`Unknown channel: openclaw-clawchat`, use `/clawchat-login A1B2C3` after a real
-Gateway restart.
+`Unknown channel: openclaw-clawchat`, use `/clawchat-login A1B2C3` after the
+Gateway has loaded the installed plugin through config reload/hot restart, or
+after a manual restart if automatic reload is unavailable.
 
 After a successful activation on a running Gateway with config reload, OpenClaw
 should load the full runtime plugin and start the channel automatically. If the
-Gateway only has the setup-only entry loaded, the credential write forces a
-Gateway reload/restart instead of a setup-only channel hot restart; after the full
-runtime is attached, later channel config changes can hot reload the channel.
-Restart the Gateway manually only after installing/updating the plugin when the
-automatic restart has not happened, when config reload is disabled, or when the
-channel probe does not become healthy:
+Gateway only has the setup-only entry loaded, the credential write lets
+OpenClaw's config watcher hot-reload or hot-restart into the full runtime instead
+of doing a setup-only channel reload; after the full runtime is attached, later
+channel config changes can hot reload the channel. Restart the Gateway manually
+only when config reload/hot restart is disabled or stalled, or when the channel
+probe does not become healthy:
 
 ```bash
 openclaw gateway restart
@@ -89,10 +90,11 @@ openclaw gateway run
 
 The `--token` value above is the ClawChat invite code for OpenClaw's generic
 `channels add` CLI surface on hosts that expose this plugin in the channel
-catalog; the setup write only creates the enabled channel skeleton. Persisted
-token fields, default `groupMode: "all"`, `plugins.entries.openclaw-clawchat`,
-`plugins.allow`, and `tools.alsoAllow` are written together only after the invite
-code exchange succeeds. The plugin registers the ClawChat account/media/search/moment tools
+catalog; the setup adapter validates the invite code without persisting a
+pre-credential channel skeleton. Persisted token fields, default
+`groupMode: "all"`, `plugins.entries.openclaw-clawchat`, `plugins.allow`, and
+`tools.alsoAllow` are written together only after the invite code exchange
+succeeds. The plugin registers the ClawChat account/media/search/moment tools
 with the OpenClaw agent harness at plugin load time, and activation/login
 preserves existing plugin entry fields, creates `plugins.allow` with
 `openclaw-clawchat` when it is missing, appends the same id when it already
@@ -103,8 +105,7 @@ Operators who prefer quieter groups can set `groupMode: "mention"`; later
 credential refreshes preserve that explicit choice.
 Before activation, account/media tools return a config error instead of
 disappearing; after activation/login, the channel is enabled and the same tools
-read the persisted token/userId after the runtime plugin reloads or the Gateway
-restarts.
+read the persisted token/userId after the runtime plugin reloads or hot-restarts.
 
 After activation/login, the channel section is enabled and has credentials:
 

package/dist/src/channel.setup.js

@@ -26,8 +26,8 @@ const configAdapter = createTopLevelChannelConfigAdapter({
 /**
  * Invite-code setup adapter used by OpenClaw setup surfaces.
  *
- * `channels add --token` passes the invite code as setup input. The first
- * config write only enables the channel; `afterAccountConfigWritten` exchanges
+ * `channels add --token` passes the invite code as setup input. The setup
+ * write leaves channel config unchanged; `afterAccountConfigWritten` exchanges
  * the invite code and persists token/userId through the host runtime mutator.
  */
 const setupAdapter = {
@@ -43,20 +43,7 @@ const setupAdapter = {
         }
         return null;
     },
-    applyAccountConfig: ({ cfg }) => {
-        const channels = (cfg.channels ?? {});
-        const current = (channels[CHANNEL_ID] ?? {});
-        const groupMode = current.groupMode === "mention" || current.groupMode === "all"
-            ? current.groupMode
-            : "all";
-        return {
-            ...cfg,
-            channels: {
-                ...channels,
-                [CHANNEL_ID]: { ...current, enabled: true, groupMode },
-            },
-        };
-    },
+    applyAccountConfig: ({ cfg }) => cfg,
     afterAccountConfigWritten: async ({ cfg, input, runtime }) => {
         runtime.log("[default] openclaw-clawchat setup afterAccountConfigWritten invoked");
         const code = typeof input.code === "string" && input.code.trim()

package/dist/src/inbound.js

@@ -1,9 +1,6 @@
 import { EVENT, } from "./protocol-types.js";
 import { extractMediaFragments, fragmentsToText } from "./message-mapper.js";
 import { hasRenderableText, isInboundMessagePayload } from "./protocol.js";
-const DEDUP_MAX = 256;
-const dedupSeen = [];
-const dedupSet = new Set();
 function normalizeSender(sender) {
     if (!sender || typeof sender !== "object")
         return null;
@@ -39,22 +36,6 @@ function extractMentionIds(fragments) {
         .map((fragment) => fragment.kind === "mention" ? fragment.user_id : undefined)
         .filter((userId) => typeof userId === "string" && userId.length > 0);
 }
-export function _resetDedupForTest() {
-    dedupSeen.length = 0;
-    dedupSet.clear();
-}
-function rememberAndCheck(messageId) {
-    if (dedupSet.has(messageId))
-        return true;
-    dedupSet.add(messageId);
-    dedupSeen.push(messageId);
-    if (dedupSeen.length > DEDUP_MAX) {
-        const evict = dedupSeen.shift();
-        if (evict)
-            dedupSet.delete(evict);
-    }
-    return false;
-}
 /**
  * Exported for direct unit testing. Direct chats always count as addressed;
  * group chats require a mention unless config opts into all group messages.
@@ -107,10 +88,6 @@ export async function dispatchOpenclawClawlingInbound(params) {
         log?.info?.(`[${account.accountId}] openclaw-clawchat skip empty msg=${payload.message_id}`);
         return;
     }
-    if (rememberAndCheck(payload.message_id)) {
-        log?.info?.(`[${account.accountId}] openclaw-clawchat skip duplicate msg=${payload.message_id}`);
-        return;
-    }
     const rawBody = fragmentsToText(message.body.fragments, {
         mentionFallbackIds: message.context.mentions,
     });

package/dist/src/login.runtime.js

@@ -2,6 +2,7 @@ import { createInterface } from "node:readline/promises";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
 import { ClawlingApiError } from "./api-types.js";
 import { CHANNEL_ID, mergeOpenclawClawchatRuntimePluginActivation, mergeOpenclawClawchatToolAllow, resolveOpenclawClawlingAccount, } from "./config.js";
+import { getClawChatStore } from "./storage.js";
 /**
  * Platform tag sent to `/v1/agents/connect`. Identifies the host of this
  * agent runtime — openclaw's bundled clawchat channel.
@@ -130,6 +131,24 @@ export async function runOpenclawClawlingLogin(params) {
     const tokenPreview = redactToken(result.access_token);
     runtime.log(`Updating config: channels.${CHANNEL_ID}.token=${tokenPreview} userId=${result.agent.user_id}${result.refresh_token ? " refreshToken=***" : ""} plugins.entries.${CHANNEL_ID}.enabled=true plugins.allow+=${CHANNEL_ID} …`);
     await persistLoginConfig(params, result);
+    try {
+        const store = params.store ??
+            getClawChatStore({
+                ...(params.dbPath ? { dbPath: params.dbPath } : {}),
+                log: { error: runtime.log },
+            });
+        store.upsertActivation({
+            platform: "openclaw",
+            accountId: account.accountId,
+            userId: result.agent.user_id,
+            accessToken: result.access_token,
+            refreshToken: result.refresh_token ?? null,
+            loginMethod: "login",
+        });
+    }
+    catch {
+        runtime.log("openclaw-clawchat sqlite activation persistence failed; login continues.");
+    }
     runtime.log(`Config file updated.`);
     runtime.log(`openclaw-clawchat login succeeded (user_id=${result.agent.user_id}, nickname=${result.agent.nickname || "-"}).`);
 }

package/dist/src/outbound.js

@@ -5,6 +5,7 @@ import { CHANNEL_ID, resolveOpenclawClawlingAccount } from "./config.js";
 import { textToFragments } from "./message-mapper.js";
 import { uploadOutboundMedia } from "./media-runtime.js";
 import { getOpenclawClawlingClient, getOpenclawClawlingRuntime, waitForOpenclawClawlingClient, } from "./runtime.js";
+import { clawChatDbPathForStateDir, getClawChatStore, } from "./storage.js";
 import { createAlignedWsQueue } from "./ws-alignment.js";
 import { formatWsLog } from "./ws-log.js";
 const alignedOutboundQueues = new WeakMap();
@@ -183,11 +184,13 @@ export async function sendOpenclawClawlingText(params) {
     // shape lets us build a single uniform array without a per-kind switch.
     const fragments = [...textFragments, ...richFragments, ...mediaFragments];
     const useReply = Boolean(params.replyCtx);
+    const messageId = params.messageId;
     let ack;
     let mode;
     if (useReply && params.replyCtx) {
         mode = "reply";
         const payload = {
+            ...(messageId ? { message_id: messageId } : {}),
             message_mode: "normal",
             message: {
                 body: { fragments },
@@ -216,6 +219,7 @@ export async function sendOpenclawClawlingText(params) {
     else {
         mode = "send";
         const payload = {
+            ...(messageId ? { message_id: messageId } : {}),
             message_mode: "normal",
             message: {
                 body: { fragments },
@@ -231,6 +235,9 @@ export async function sendOpenclawClawlingText(params) {
             ...(params.log ? { log: params.log } : {}),
         });
     }
+    if (messageId && ack.payload.message_id !== messageId) {
+        throw new Error(`ack message_id mismatch: expected ${messageId} got ${ack.payload.message_id}`);
+    }
     params.log?.info?.(`[${params.account.accountId}] openclaw-clawchat outbound mode=${mode} msg=${ack.payload.message_id} text_len=${text.length} media=${mediaFragments.length} trace=${ack.trace_id}`);
     return {
         messageId: ack.payload.message_id,
@@ -257,11 +264,48 @@ export async function sendOpenclawClawlingMedia(params) {
         to: params.to,
         text: params.text ?? "",
         mediaFragments: params.mediaFragments,
+        ...(params.messageId ? { messageId: params.messageId } : {}),
         ...(params.replyCtx ? { replyCtx: params.replyCtx } : {}),
         ...(params.mentions ? { mentions: params.mentions } : {}),
         ...(params.log ? { log: params.log } : {}),
     });
 }
+function mintOutboundMessageId(account) {
+    return `${account.userId}-msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function resolveChannelOutboundStore() {
+    try {
+        const runtime = getOpenclawClawlingRuntime();
+        const stateDir = runtime.state?.resolveStateDir?.();
+        return getClawChatStore({
+            ...(stateDir ? { dbPath: clawChatDbPathForStateDir(stateDir) } : {}),
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function claimChannelOutbound(params) {
+    const store = resolveChannelOutboundStore();
+    if (!store)
+        return null;
+    try {
+        return store.claimMessageOnce({
+            platform: "openclaw",
+            accountId: params.account.accountId,
+            kind: "message",
+            direction: "outbound",
+            eventType: "message.send",
+            chatId: params.target.chatId,
+            messageId: params.messageId,
+            text: params.text,
+            raw: params.raw,
+        });
+    }
+    catch {
+        return null;
+    }
+}
 export const openclawClawlingOutbound = {
     deliveryMode: "direct",
     chunker: (text, limit) => chunkMarkdownText(text, limit),
@@ -273,15 +317,35 @@ export const openclawClawlingOutbound = {
             const account = resolveOpenclawClawlingAccount(cfg);
             const client = getOpenclawClawlingClient(account.accountId) ??
                 (await waitForOpenclawClawlingClient(account.accountId));
+            const target = parseOpenclawRecipient(to);
+            const messageId = mintOutboundMessageId(account);
+            const trimmedText = text.trim();
+            if (!trimmedText) {
+                throw new Error("openclaw-clawchat sendText requires non-empty text");
+            }
+            const claimed = claimChannelOutbound({
+                account,
+                target,
+                messageId,
+                text: trimmedText,
+                raw: { target, mode: "channel-sendText" },
+            });
+            if (claimed === false) {
+                throw new Error("openclaw-clawchat outbound duplicate claim; message not sent");
+            }
+            if (claimed === null) {
+                throw new Error("openclaw-clawchat outbound message claim failed");
+            }
             const result = await sendOpenclawClawlingText({
                 client,
                 account,
-                to: parseOpenclawRecipient(to),
+                to: target,
                 text,
+                messageId,
             });
             return {
                 to,
-                messageId: result?.messageId ?? `${account.userId}-${Date.now()}`,
+                messageId: result?.messageId ?? messageId,
             };
         },
         sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile }) => {
@@ -307,16 +371,33 @@ export const openclawClawlingOutbound = {
             if (mediaFragments.length === 0) {
                 throw new Error(`openclaw-clawchat failed to upload media: ${mediaUrl}`);
             }
+            const target = parseOpenclawRecipient(to);
+            const messageId = mintOutboundMessageId(account);
+            const claimText = (text ?? "").trim();
+            const claimed = claimChannelOutbound({
+                account,
+                target,
+                messageId,
+                text: claimText,
+                raw: { target, mode: "channel-sendMedia", mediaCount: mediaFragments.length },
+            });
+            if (claimed === false) {
+                throw new Error("openclaw-clawchat outbound duplicate claim; message not sent");
+            }
+            if (claimed === null) {
+                throw new Error("openclaw-clawchat outbound message claim failed");
+            }
             const result = await sendOpenclawClawlingMedia({
                 client,
                 account,
-                to: parseOpenclawRecipient(to),
+                to: target,
                 text,
                 mediaFragments,
+                messageId,
             });
             return {
                 to,
-                messageId: result?.messageId ?? `${account.userId}-${Date.now()}`,
+                messageId: result?.messageId ?? messageId,
             };
         },
     }),

package/dist/src/reply-dispatcher.js

@@ -5,7 +5,7 @@ import { openBufferedStreamingSession, mergeStreamingText, } from "./buffered-st
 import { emitFinalStreamReply } from "./client.js";
 import { textToFragments } from "./message-mapper.js";
 import { uploadOutboundMedia } from "./media-runtime.js";
-import { sendOpenclawClawlingText } from "./outbound.js";
+import { sendOpenclawClawlingText, } from "./outbound.js";
 import { sendStreamingFailure } from "./streaming.js";
 const CLIENT_SAFE_REPLY_FAILURE_TEXT = "OpenClaw could not complete this reply.";
 function normalizeReplyErrorText(error) {
@@ -119,7 +119,7 @@ function resolvePayloadText(payload) {
  * `message.reply` per deliver with text + media.
  */
 export function createOpenclawClawlingReplyDispatcher(options) {
-    const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, inboundForFinalReply, log, } = options;
+    const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, inboundForFinalReply, store, log, } = options;
     const routing = { chatId: target.chatId, chatType: target.chatType };
     const humanDelay = runtime.channel.reply.resolveHumanDelayConfig(cfg, account.userId);
     const streamingEnabled = account.replyMode === "stream" && !replyCtx;
@@ -153,16 +153,87 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     let streamingClosed = false;
     let runFailed = false;
     let runDone = false;
+    let streamClaimAttempted = false;
     // `streamCreatedEmitted` is the authoritative guard: once a `message.created`
     // has been emitted for this dispatcher instance, never emit another — even
     // if `onReplyStart` fires again or a pre-onReplyStart `onPartialReply`
     // raced the lazy open path.
     let streamCreatedEmitted = false;
+    const outboundEventType = () => (replyCtx ? "message.reply" : "message.send");
+    const outboundRaw = () => ({ target, replyCtx: replyCtx ?? null });
+    const claimOutbound = (eventType, messageId, text, raw) => {
+        if (!store || !messageId)
+            return null;
+        try {
+            return store.claimMessageOnce({
+                platform: "openclaw",
+                accountId: account.accountId,
+                kind: "message",
+                direction: "outbound",
+                eventType,
+                chatId: target.chatId,
+                messageId,
+                text,
+                raw,
+            });
+        }
+        catch {
+            log?.error?.(`[${account.accountId}] openclaw-clawchat sqlite outbound claim failed`);
+            return null;
+        }
+    };
+    const updateOutbound = (eventType, messageId, text, raw) => {
+        if (!store || !messageId)
+            return;
+        try {
+            store.updateMessageByIdentity({
+                accountId: account.accountId,
+                kind: "message",
+                direction: "outbound",
+                eventType,
+                chatId: target.chatId,
+                messageId,
+                text,
+                raw,
+            });
+        }
+        catch {
+            log?.error?.(`[${account.accountId}] openclaw-clawchat sqlite outbound update failed; continuing`);
+        }
+    };
+    const recordOutbound = (kind, messageId, text) => {
+        if (!store || !messageId)
+            return;
+        try {
+            store.insertMessage({
+                platform: "openclaw",
+                accountId: account.accountId,
+                kind,
+                direction: "outbound",
+                eventType: outboundEventType(),
+                chatId: target.chatId,
+                messageId,
+                text,
+                raw: outboundRaw(),
+            });
+        }
+        catch {
+            log?.error?.(`[${account.accountId}] openclaw-clawchat sqlite outbound insert failed; continuing`);
+        }
+    };
+    const recordThinkingIfLinked = (messageId) => {
+        const thinkingText = reasoningText.trim();
+        if (!thinkingText)
+            return;
+        recordOutbound("thinking", messageId, thinkingText);
+        reasoningText = "";
+    };
     const mintStreamingMessageId = () => `${account.userId}-stream-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const mintStaticMessageId = () => `${account.userId}-msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const openSessionIfNeeded = () => {
-        if (!streamingEnabled || streamingSession || streamCreatedEmitted)
+        if (!streamingEnabled || streamingSession || streamCreatedEmitted || streamClaimAttempted)
             return;
-        streamCreatedEmitted = true;
+        streamClaimAttempted = true;
         // Mint a fresh agent-side message_id at `message.created` time. All
         // subsequent `message.add` / `message.done` / `message.reply` frames for
         // this stream reuse it. Once the stream finalizes (done or reply), this
@@ -171,6 +242,14 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         // `replyTo.msgId`; keeping the two distinct avoids the agent's reply
         // frames shadowing the user turn they answer.
         streamingMessageId = mintStreamingMessageId();
+        const claimed = claimOutbound("message.created", streamingMessageId, "", { target, replyCtx: replyCtx ?? null, mode: "stream" });
+        if (claimed !== true) {
+            streamCreatedEmitted = false;
+            streamingMessageId = "";
+            log?.[claimed === false ? "info" : "error"]?.(`[${account.accountId}] openclaw-clawchat stream outbound skipped reason=${claimed === false ? "duplicate" : "claim_unavailable"}`);
+            return;
+        }
+        streamCreatedEmitted = true;
         streamingSession = openBufferedStreamingSession({
             client,
             routing,
@@ -217,21 +296,36 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         log?.info?.(`[${account.accountId}] openclaw-clawchat streaming closed msg=${streamingMessageId} reason=${reason ?? "done"}`);
     };
     // ----- Static send ------------------------------------------------------
-    const sendStatic = async (text, mediaFragments = [], richFragments = []) => {
+    const sendStatic = async (text, mediaFragments = [], richFragments = [], options = {}) => {
         if (!text.trim() && mediaFragments.length === 0 && richFragments.length === 0)
-            return;
+            return null;
         log?.info?.(`[${account.accountId}] openclaw-clawchat sending static text_len=${text.length} media=${mediaFragments.length} rich=${richFragments.length} to=${target.chatId}`);
-        await sendOpenclawClawlingText({
+        const messageId = mintStaticMessageId();
+        const raw = { target, replyCtx: replyCtx ?? null, mode: "static" };
+        const claimed = options.recordMessage
+            ? claimOutbound(outboundEventType(), messageId, text, raw)
+            : true;
+        if (claimed === false) {
+            log?.info?.(`[${account.accountId}] openclaw-clawchat outbound duplicate skipped msg=${messageId}`);
+            return null;
+        }
+        if (claimed === null) {
+            log?.error?.(`[${account.accountId}] openclaw-clawchat outbound skipped msg=${messageId} reason=claim_unavailable`);
+            return null;
+        }
+        const result = await sendOpenclawClawlingText({
             client,
             account,
             to: target,
             text,
+            messageId,
             ...(replyCtx ? { replyCtx } : {}),
             ...(richFragments.length > 0 ? { richFragments } : {}),
             ...(mediaFragments.length > 0 ? { mediaFragments } : {}),
             log,
         });
         log?.info?.(`[${account.accountId}] openclaw-clawchat send complete to=${target.chatId}`);
+        return result;
     };
     const logDetachedFailure = (action, error) => {
         log?.error?.(`[${account.accountId}] openclaw-clawchat ${action} failed: ${String(error)}`);
@@ -243,6 +337,8 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         if (finalEmitted)
             return;
         finalEmitted = true;
+        if (!streamingMessageId)
+            return;
         const mergedMedia = await uploadMediaUrls(accumulatedMediaUrls.slice());
         const mergedText = streamText.trim();
         if (!mergedText && finalRichFragments.length === 0 && mergedMedia.length === 0) {
@@ -272,6 +368,8 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             },
             body: { fragments: bodyFragments },
         });
+        updateOutbound("message.reply", streamingMessageId, mergedText, { target, replyCtx: replyCtx ?? null, mode: "stream-final" });
+        recordThinkingIfLinked(streamingMessageId);
     };
     const ingestFinalPayload = (payload, text, richFragment) => {
         if (richFragment && account.richInteractions) {
@@ -328,7 +426,10 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     await queueStreamSnapshot();
                 }
                 else {
-                    await sendStatic(text);
+                    reasoningText = mergeStreamingText(reasoningText, text);
+                    const result = await sendStatic(text, [], [], { recordMessage: true });
+                    if (result?.messageId)
+                        recordThinkingIfLinked(result.messageId);
                 }
                 return;
             }
@@ -338,9 +439,19 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 ingestFinalPayload(payload, text, richFragment && account.richInteractions ? richFragment : null);
                 // For streaming: consolidated final is emitted in onIdle after done.
                 // For static: emit immediately.
-                if (!streamingEnabled) {
+                if (streamingEnabled) {
+                    if (text.trim()) {
+                        await queueStreamSnapshot();
+                    }
+                    else if (richFragment || urls.length > 0) {
+                        openSessionIfNeeded();
+                    }
+                }
+                else {
                     const mediaFragments = await uploadMediaUrls(urls);
-                    await sendStatic(text, mediaFragments, richFragment && account.richInteractions ? [richFragment] : []);
+                    const result = await sendStatic(text, mediaFragments, richFragment && account.richInteractions ? [richFragment] : [], { recordMessage: true });
+                    if (result?.messageId)
+                        recordThinkingIfLinked(result.messageId);
                 }
                 return;
             }
@@ -352,14 +463,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     const mediaFragments = await uploadMediaUrls(urls);
                     if (mediaFragments.length > 0) {
                         log?.info?.(`[${account.accountId}] openclaw-clawchat mid-stream media emitted as separate message (count=${mediaFragments.length})`);
-                        await sendOpenclawClawlingText({
-                            client,
-                            account,
-                            to: target,
-                            text: "",
-                            mediaFragments,
-                            log,
-                        });
+                        await sendStatic("", mediaFragments, [], { recordMessage: true });
                     }
                 }
             }
@@ -367,7 +471,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 const mediaFragments = await uploadMediaUrls(urls);
                 const richFragments = richFragment && account.richInteractions ? [richFragment] : [];
                 if (text.trim() || mediaFragments.length > 0 || richFragments.length > 0) {
-                    await sendStatic(text, mediaFragments, richFragments);
+                    await sendStatic(text, mediaFragments, richFragments, { recordMessage: true });
                 }
             }
         },