@newbase-clawchat/openclaw-clawchat 2026.4.29 → 2026.4.30

package/src/reply-dispatcher.test.ts

@@ -3,6 +3,82 @@ import { describe, expect, it, vi } from "vitest";
 import { createOpenclawClawlingReplyDispatcher } from "./reply-dispatcher.ts";
 
 describe("openclaw-clawchat reply-dispatcher", () => {
+  it("uses chat_id, not sender_id, as the consolidated streaming reply marker", async () => {
+    let hooks:
+      | {
+          deliver?: (payload: { text?: string }, info?: { kind: "tool" | "block" | "final" }) => Promise<void>;
+          onIdle?: () => Promise<void>;
+        }
+      | undefined;
+    const sent: Array<{ event: string; payload: Record<string, unknown> }> = [];
+    const client = {
+      opts: {
+        transport: {
+          send: (data: string) => {
+            const env = JSON.parse(data) as { event: string; payload: Record<string, unknown> };
+            sent.push({ event: env.event, payload: env.payload });
+          },
+        },
+        traceIdFactory: () => "trace-chat-marker",
+      },
+      typing: vi.fn(),
+    } as unknown as ClawlingChatClient;
+
+    createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: {
+        channel: {
+          reply: {
+            resolveHumanDelayConfig: vi.fn(() => ({ enabled: false })),
+            createReplyDispatcherWithTyping: vi.fn((options) => {
+              hooks = options;
+              return {
+                dispatcher: {},
+                replyOptions: {},
+                markDispatchIdle: vi.fn(),
+              };
+            }),
+          },
+        },
+      } as never,
+      account: {
+        accountId: "default",
+        userId: "agent-1",
+        replyMode: "stream",
+        forwardThinking: true,
+        forwardToolCalls: false,
+        stream: { flushIntervalMs: 250, minChunkChars: 1, maxBufferChars: 2000 },
+      } as never,
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      inboundMessageId: "inbound-1",
+      inboundForFinalReply: {
+        chatId: "chat-1",
+        senderId: "user-1",
+        senderNickName: "User 1",
+        bodyText: "hello",
+      },
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await hooks?.deliver?.({ text: "agent reply" }, { kind: "final" });
+    await hooks?.onIdle?.();
+
+    const finalReply = sent.find((entry) => entry.event === "message.reply");
+    expect(finalReply?.payload).toMatchObject({
+      message: {
+        context: {
+          reply: {
+            reply_preview: {
+              id: "chat-1",
+              nick_name: "User 1",
+            },
+          },
+        },
+      },
+    });
+  });
+
   it("emits message.failed in stream mode even if execution errors before any stream chunk", async () => {
     let hooks:
       | {
@@ -61,7 +137,7 @@ describe("openclaw-clawchat reply-dispatcher", () => {
     expect(sent[0]!.event).toBe("message.failed");
     expect(sent[0]!.payload.reason).toBe("Error: boom");
     expect((client.typing as ReturnType<typeof vi.fn>).mock.calls).toEqual([
-      ["chat-1", false, "direct"],
+      ["chat-1", false],
     ]);
   });
 
@@ -186,10 +262,10 @@ describe("openclaw-clawchat reply-dispatcher", () => {
     expect(client.sendMessage).toHaveBeenCalledWith(
       expect.objectContaining({
         chat_id: "chat-1",
-        chat_type: "direct",
         body: { fragments: [{ kind: "text", text: "Error: boom" }] },
       }),
     );
+    expect((client.sendMessage as ReturnType<typeof vi.fn>).mock.calls[0][0]).not.toHaveProperty("chat_type");
     expect(client.replyMessage).not.toHaveBeenCalled();
   });
 
@@ -246,9 +322,348 @@ describe("openclaw-clawchat reply-dispatcher", () => {
     expect(client.sendMessage).toHaveBeenCalledWith(
       expect.objectContaining({
         chat_id: "chat-1",
-        chat_type: "direct",
         body: { fragments: [{ kind: "text", text: "Error: boom" }] },
       }),
     );
+    expect((client.sendMessage as ReturnType<typeof vi.fn>).mock.calls[0][0]).not.toHaveProperty("chat_type");
+  });
+
+  it("emits approval rich fragments with fallback_text when rich interactions are enabled", async () => {
+    let hooks:
+      | {
+          deliver?: (payload: {
+            text?: string;
+            presentation?: {
+              title?: string;
+              tone?: string;
+              blocks: Array<
+                | { type: "text"; text: string }
+                | { type: "buttons"; buttons: Array<{ label: string; value?: string; style?: string }> }
+              >;
+            };
+          }, info?: { kind: "tool" | "block" | "final" }) => Promise<void>;
+        }
+      | undefined;
+    const client = {
+      sendMessage: vi.fn().mockResolvedValue({
+        payload: { message_id: "server-m1", accepted_at: 1234 },
+        trace_id: "trace-rich",
+      }),
+      replyMessage: vi.fn(),
+      typing: vi.fn(),
+    } as unknown as ClawlingChatClient;
+
+    createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: {
+        channel: {
+          reply: {
+            resolveHumanDelayConfig: vi.fn(() => ({ enabled: false })),
+            createReplyDispatcherWithTyping: vi.fn((options) => {
+              hooks = options;
+              return { dispatcher: {}, replyOptions: {}, markDispatchIdle: vi.fn() };
+            }),
+          },
+        },
+      } as never,
+      account: {
+        accountId: "default",
+        userId: "agent-1",
+        replyMode: "static",
+        forwardThinking: true,
+        forwardToolCalls: false,
+        richInteractions: true,
+        stream: { flushIntervalMs: 250, minChunkChars: 40, maxBufferChars: 2000 },
+      } as never,
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await hooks?.deliver?.(
+      {
+        text: "Approve file deletion?",
+        presentation: {
+          title: "Approval required",
+          tone: "warning",
+          blocks: [
+            { type: "text", text: "Delete /tmp/example.txt?" },
+            {
+              type: "buttons",
+              buttons: [
+                { label: "Approve", value: "approve", style: "primary" },
+                { label: "Deny", value: "deny", style: "danger" },
+              ],
+            },
+          ],
+        },
+      },
+      { kind: "final" },
+    );
+
+    expect(client.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        body: {
+          fragments: [
+            {
+              kind: "approval_request",
+              title: "Approval required",
+              fallback_text: expect.stringContaining("Delete /tmp/example.txt?"),
+              state: "pending",
+              actions: [
+                { id: "approve", label: "Approve", style: "primary", payload: { value: "approve" } },
+                { id: "deny", label: "Deny", style: "danger", payload: { value: "deny" } },
+              ],
+            },
+          ],
+        },
+      }),
+    );
+  });
+
+  it("sends plain fallback text for presentations when rich interactions are disabled", async () => {
+    let hooks:
+      | {
+          deliver?: (payload: {
+            text?: string;
+            presentation?: {
+              title?: string;
+              blocks: Array<{ type: "text"; text: string }>;
+            };
+          }, info?: { kind: "tool" | "block" | "final" }) => Promise<void>;
+        }
+      | undefined;
+    const client = {
+      sendMessage: vi.fn().mockResolvedValue({
+        payload: { message_id: "server-m1", accepted_at: 1234 },
+        trace_id: "trace-fallback",
+      }),
+      replyMessage: vi.fn(),
+      typing: vi.fn(),
+    } as unknown as ClawlingChatClient;
+
+    createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: {
+        channel: {
+          reply: {
+            resolveHumanDelayConfig: vi.fn(() => ({ enabled: false })),
+            createReplyDispatcherWithTyping: vi.fn((options) => {
+              hooks = options;
+              return { dispatcher: {}, replyOptions: {}, markDispatchIdle: vi.fn() };
+            }),
+          },
+        },
+      } as never,
+      account: {
+        accountId: "default",
+        userId: "agent-1",
+        replyMode: "static",
+        forwardThinking: true,
+        forwardToolCalls: false,
+        richInteractions: false,
+        stream: { flushIntervalMs: 250, minChunkChars: 40, maxBufferChars: 2000 },
+      } as never,
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await hooks?.deliver?.(
+      {
+        text: "Approve file deletion?",
+        presentation: {
+          title: "Approval required",
+          blocks: [{ type: "text", text: "Delete /tmp/example.txt?" }],
+        },
+      },
+      { kind: "final" },
+    );
+
+    expect(client.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        body: {
+          fragments: [{ kind: "text", text: expect.stringContaining("Delete /tmp/example.txt?") }],
+        },
+      }),
+    );
+  });
+
+  it("includes rich interaction fragments in the consolidated streaming final reply", async () => {
+    let hooks:
+      | {
+          deliver?: (payload: {
+            text?: string;
+            presentation?: {
+              title?: string;
+              tone?: string;
+              blocks: Array<
+                | { type: "text"; text: string }
+                | { type: "buttons"; buttons: Array<{ label: string; value?: string }> }
+              >;
+            };
+          }, info?: { kind: "tool" | "block" | "final" }) => Promise<void>;
+          onIdle?: () => Promise<void>;
+        }
+      | undefined;
+    const sent: Array<{ event: string; payload: Record<string, unknown> }> = [];
+    const client = {
+      opts: {
+        transport: {
+          send: (data: string) => {
+            const env = JSON.parse(data) as { event: string; payload: Record<string, unknown> };
+            sent.push({ event: env.event, payload: env.payload });
+          },
+        },
+        traceIdFactory: () => "trace-stream-rich",
+      },
+      typing: vi.fn(),
+    } as unknown as ClawlingChatClient;
+
+    createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: {
+        channel: {
+          reply: {
+            resolveHumanDelayConfig: vi.fn(() => ({ enabled: false })),
+            createReplyDispatcherWithTyping: vi.fn((options) => {
+              hooks = options;
+              return { dispatcher: {}, replyOptions: {}, markDispatchIdle: vi.fn() };
+            }),
+          },
+        },
+      } as never,
+      account: {
+        accountId: "default",
+        userId: "agent-1",
+        replyMode: "stream",
+        forwardThinking: true,
+        forwardToolCalls: false,
+        richInteractions: true,
+        stream: { flushIntervalMs: 250, minChunkChars: 1, maxBufferChars: 2000 },
+      } as never,
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      inboundMessageId: "inbound-1",
+      inboundForFinalReply: {
+        chatId: "chat-1",
+        senderId: "user-1",
+        senderNickName: "User 1",
+        bodyText: "hello",
+      },
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await hooks?.deliver?.(
+      {
+        presentation: {
+          title: "Approval required",
+          tone: "warning",
+          blocks: [
+            { type: "text", text: "Run deploy?" },
+            { type: "buttons", buttons: [{ label: "Approve", value: "approve" }] },
+          ],
+        },
+      },
+      { kind: "final" },
+    );
+    await hooks?.onIdle?.();
+
+    const finalReply = sent.find((entry) => entry.event === "message.reply");
+    expect(finalReply?.payload).toMatchObject({
+      message: {
+        body: {
+          fragments: [
+            {
+              kind: "approval_request",
+              title: "Approval required",
+              fallback_text: expect.stringContaining("Run deploy?"),
+              state: "pending",
+            },
+          ],
+        },
+      },
+    });
+  });
+
+  it("forwards non-final rich block payloads in static mode", async () => {
+    let hooks:
+      | {
+          deliver?: (payload: {
+            text?: string;
+            presentation?: {
+              title?: string;
+              blocks: Array<
+                | { type: "text"; text: string }
+                | { type: "buttons"; buttons: Array<{ label: string; value?: string }> }
+              >;
+            };
+          }, info?: { kind: "tool" | "block" | "final" }) => Promise<void>;
+        }
+      | undefined;
+    const client = {
+      sendMessage: vi.fn().mockResolvedValue({
+        payload: { message_id: "server-m1", accepted_at: 1234 },
+        trace_id: "trace-block-rich",
+      }),
+      replyMessage: vi.fn(),
+      typing: vi.fn(),
+    } as unknown as ClawlingChatClient;
+
+    createOpenclawClawlingReplyDispatcher({
+      cfg: {} as never,
+      runtime: {
+        channel: {
+          reply: {
+            resolveHumanDelayConfig: vi.fn(() => ({ enabled: false })),
+            createReplyDispatcherWithTyping: vi.fn((options) => {
+              hooks = options;
+              return { dispatcher: {}, replyOptions: {}, markDispatchIdle: vi.fn() };
+            }),
+          },
+        },
+      } as never,
+      account: {
+        accountId: "default",
+        userId: "agent-1",
+        replyMode: "static",
+        forwardThinking: true,
+        forwardToolCalls: false,
+        richInteractions: true,
+        stream: { flushIntervalMs: 250, minChunkChars: 40, maxBufferChars: 2000 },
+      } as never,
+      client,
+      target: { chatId: "chat-1", chatType: "direct" },
+      log: { info: vi.fn(), error: vi.fn() },
+    });
+
+    await hooks?.deliver?.(
+      {
+        presentation: {
+          title: "Choose next step",
+          blocks: [
+            { type: "text", text: "Pick an action" },
+            { type: "buttons", buttons: [{ label: "Continue", value: "continue" }] },
+          ],
+        },
+      },
+      { kind: "block" },
+    );
+
+    expect(client.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        body: {
+          fragments: [
+            {
+              kind: "action_card",
+              title: "Choose next step",
+              fallback_text: expect.stringContaining("Pick an action"),
+              state: "pending",
+              actions: [{ id: "continue", label: "Continue", payload: { value: "continue" } }],
+            },
+          ],
+        },
+      }),
+    );
   });
 });

package/src/reply-dispatcher.ts

@@ -1,4 +1,11 @@
 import type { ClawlingChatClient, Fragment } from "@newbase-clawchat/sdk";
+import {
+  interactiveReplyToPresentation,
+  renderMessagePresentationFallbackText,
+  type MessagePresentation,
+  type MessagePresentationBlock,
+  type MessagePresentationButtonStyle,
+} from "openclaw/plugin-sdk/interactive-runtime";
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { ReplyPayload } from "openclaw/plugin-sdk/reply-runtime";
@@ -39,6 +46,7 @@ export interface ReplyDispatcherOptions {
    * the consolidated `message.reply` that closes a streaming run.
    */
   inboundForFinalReply?: {
+    chatId?: string;
     senderId: string;
     senderNickName: string;
     bodyText: string;
@@ -55,6 +63,22 @@ type StreamingReplyHooks = {
   onReasoningStream?: (payload: ReplyPayload) => Promise<void>;
 };
 
+type RichAction = {
+  id: string;
+  label: string;
+  style?: MessagePresentationButtonStyle;
+  disabled?: boolean;
+  payload?: Record<string, unknown>;
+};
+
+type RichInteractionFragment = {
+  kind: "approval_request" | "action_card";
+  title?: string;
+  fallback_text: string;
+  state: "pending";
+  actions: RichAction[];
+};
+
 function normalizeReplyErrorText(error: unknown): string {
   const raw = String(error);
   const retryWrapped = raw.match(/^Error: Retry failed for delivery [^:]+:\s*(.+)$/s);
@@ -64,6 +88,86 @@ function normalizeReplyErrorText(error: unknown): string {
   return raw;
 }
 
+function isMessagePresentation(value: unknown): value is MessagePresentation {
+  return Boolean(
+    value &&
+      typeof value === "object" &&
+      Array.isArray((value as { blocks?: unknown }).blocks),
+  );
+}
+
+function resolvePresentation(payload: ReplyPayload): MessagePresentation | undefined {
+  if (isMessagePresentation(payload.presentation)) return payload.presentation;
+  if (payload.interactive) return interactiveReplyToPresentation(payload.interactive);
+  return undefined;
+}
+
+function normalizeActionId(value: string | undefined, label: string, index: number): string {
+  const raw = value?.trim() || label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return raw.replace(/^-+|-+$/g, "") || `action-${index + 1}`;
+}
+
+function collectPresentationActions(blocks: MessagePresentationBlock[]): RichAction[] {
+  const actions: RichAction[] = [];
+  for (const block of blocks) {
+    if (block.type === "buttons") {
+      for (const button of block.buttons) {
+        const value = button.value?.trim();
+        const url = button.url?.trim();
+        const action: RichAction = {
+          id: normalizeActionId(value ?? url, button.label, actions.length),
+          label: button.label,
+          ...(button.style ? { style: button.style } : {}),
+          ...(value || url ? { payload: { ...(value ? { value } : {}), ...(url ? { url } : {}) } } : {}),
+        };
+        actions.push(action);
+      }
+    }
+    if (block.type === "select") {
+      for (const option of block.options) {
+        actions.push({
+          id: normalizeActionId(option.value, option.label, actions.length),
+          label: option.label,
+          style: "secondary",
+          payload: { value: option.value },
+        });
+      }
+    }
+  }
+  return actions;
+}
+
+function looksLikeApproval(actions: RichAction[], presentation: MessagePresentation): boolean {
+  if (presentation.tone === "warning" || presentation.tone === "danger") return true;
+  const ids = new Set(actions.map((action) => action.id.toLowerCase()));
+  return ids.has("approve") || ids.has("deny") || ids.has("reject");
+}
+
+function buildRichInteractionFragment(payload: ReplyPayload): RichInteractionFragment | null {
+  const presentation = resolvePresentation(payload);
+  if (!presentation) return null;
+  const actions = collectPresentationActions(presentation.blocks);
+  if (actions.length === 0) return null;
+  const fallbackText = renderMessagePresentationFallbackText({
+    presentation,
+    text: payload.text ?? null,
+  }).trim();
+  if (!fallbackText) return null;
+  return {
+    kind: looksLikeApproval(actions, presentation) ? "approval_request" : "action_card",
+    ...(presentation.title?.trim() ? { title: presentation.title.trim() } : {}),
+    fallback_text: fallbackText,
+    state: "pending",
+    actions,
+  };
+}
+
+function resolvePayloadText(payload: ReplyPayload): string {
+  const presentation = resolvePresentation(payload);
+  if (!presentation) return payload.text ?? "";
+  return renderMessagePresentationFallbackText({ presentation, text: payload.text ?? null });
+}
+
 /**
  * Reply dispatcher for openclaw-clawchat.
  *
@@ -134,6 +238,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
   let streamText = "";
   let reasoningText = "";
   const accumulatedMediaUrls: string[] = [];
+  const finalRichFragments: Fragment[] = [];
   let finalEmitted = false;
   let streamingClosed = false;
   let runFailed = false;
@@ -206,10 +311,14 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
 
   // ----- Static send ------------------------------------------------------
 
-  const sendStatic = async (text: string, mediaFragments: ClawlingMediaFragment[] = []) => {
-    if (!text.trim() && mediaFragments.length === 0) return;
+  const sendStatic = async (
+    text: string,
+    mediaFragments: ClawlingMediaFragment[] = [],
+    richFragments: Fragment[] = [],
+  ) => {
+    if (!text.trim() && mediaFragments.length === 0 && richFragments.length === 0) return;
     log?.info?.(
-      `[${account.accountId}] openclaw-clawchat sending static text_len=${text.length} media=${mediaFragments.length} to=${target.chatId}`,
+      `[${account.accountId}] openclaw-clawchat sending static text_len=${text.length} media=${mediaFragments.length} rich=${richFragments.length} to=${target.chatId}`,
     );
     await sendOpenclawClawlingText({
       client,
@@ -217,6 +326,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
       to: target,
       text,
       ...(replyCtx ? { replyCtx } : {}),
+      ...(richFragments.length > 0 ? { richFragments } : {}),
       ...(mediaFragments.length > 0 ? { mediaFragments } : {}),
       log,
     });
@@ -230,7 +340,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     finalEmitted = true;
     const mergedMedia = await uploadMediaUrls(accumulatedMediaUrls.slice());
     const mergedText = streamText.trim();
-    if (!mergedText && mergedMedia.length === 0) {
+    if (!mergedText && finalRichFragments.length === 0 && mergedMedia.length === 0) {
       log?.info?.(
         `[${account.accountId}] openclaw-clawchat no merged final content; skip consolidated reply`,
       );
@@ -241,6 +351,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     );
     const bodyFragments: Fragment[] = [
       ...(mergedText ? textToFragments(mergedText) : []),
+      ...finalRichFragments,
       // mediaFragments is the local wide shape; cast at SDK boundary as
       // we do in outbound.ts.
       ...(mergedMedia as Fragment[]),
@@ -252,7 +363,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
       routing,
       replyTo: {
         msgId: inboundMessageId ?? streamingMessageId,
-        senderId: inboundForFinalReply?.senderId ?? target.chatId,
+        previewId: inboundForFinalReply?.chatId ?? target.chatId,
         nickName:
           inboundForFinalReply?.senderNickName ?? inboundForFinalReply?.senderId ?? target.chatId,
         fragments: inboundForFinalReply?.bodyText
@@ -263,8 +374,10 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     });
   };
 
-  const ingestFinalPayload = (payload: ReplyPayload) => {
-    const text = payload.text ?? "";
+  const ingestFinalPayload = (payload: ReplyPayload, text: string, richFragment: Fragment | null) => {
+    if (richFragment && account.richInteractions) {
+      finalRichFragments.push(richFragment);
+    }
     if (text) streamText = mergeStreamingText(streamText, text);
     const urls = [
       ...(payload.mediaUrl ? [payload.mediaUrl] : []),
@@ -300,13 +413,15 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
         streamText = "";
         reasoningText = "";
         accumulatedMediaUrls.length = 0;
+        finalRichFragments.length = 0;
         finalEmitted = false;
         streamingClosed = false;
         runDone = false;
       }
     },
     deliver: async (payload: ReplyPayload, info?: { kind: "tool" | "block" | "final" }) => {
-      const text = payload.text ?? "";
+      const richFragment = buildRichInteractionFragment(payload);
+      const text = richFragment && account.richInteractions ? "" : resolvePayloadText(payload);
       const urls = [
         ...(payload.mediaUrl ? [payload.mediaUrl] : []),
         ...(payload.mediaUrls ?? []),
@@ -329,12 +444,20 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
       if (info?.kind === "tool" && !account.forwardToolCalls) return;
 
       if (info?.kind === "final") {
-        ingestFinalPayload(payload);
+        ingestFinalPayload(
+          payload,
+          text,
+          richFragment && account.richInteractions ? (richFragment as unknown as Fragment) : null,
+        );
         // For streaming: consolidated final is emitted in onIdle after done.
         // For static: emit immediately.
         if (!streamingEnabled) {
           const mediaFragments = await uploadMediaUrls(urls);
-          await sendStatic(text, mediaFragments);
+          await sendStatic(
+            text,
+            mediaFragments,
+            richFragment && account.richInteractions ? ([richFragment] as unknown as Fragment[]) : [],
+          );
         }
         return;
       }
@@ -360,8 +483,10 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
         }
       } else {
         const mediaFragments = await uploadMediaUrls(urls);
-        if (text.trim() || mediaFragments.length > 0) {
-          await sendStatic(text, mediaFragments);
+        const richFragments =
+          richFragment && account.richInteractions ? ([richFragment] as unknown as Fragment[]) : [];
+        if (text.trim() || mediaFragments.length > 0 || richFragments.length > 0) {
+          await sendStatic(text, mediaFragments, richFragments);
         }
       }
     },