@newbase-clawchat/openclaw-clawchat 2026.4.29 → 2026.5.4

package/src/outbound.ts

@@ -22,6 +22,7 @@ export interface OutboundTarget {
 
 export interface OutboundReplyCtx {
   replyToMessageId: string;
+  replyPreviewChatId?: string;
   replyPreviewSenderId: string;
   replyPreviewNickName: string;
   replyPreviewText: string;
@@ -38,6 +39,7 @@ export interface SendParams {
   to: OutboundTarget;
   text: string;
   replyCtx?: OutboundReplyCtx;
+  richFragments?: Fragment[];
   mediaFragments?: ClawlingMediaFragment[];
   mentions?: string[];
   log?: LogSink;
@@ -92,8 +94,9 @@ export function parseOpenclawRecipient(to: string): { chatId: string; chatType:
 
 export async function sendOpenclawClawlingText(params: SendParams): Promise<SendResult | null> {
   const text = (params.text ?? "").trim();
+  const richFragments = params.richFragments ?? [];
   const mediaFragments = params.mediaFragments ?? [];
-  if (!text && mediaFragments.length === 0) {
+  if (!text && richFragments.length === 0 && mediaFragments.length === 0) {
     params.log?.info?.(
       `[${params.account.accountId}] openclaw-clawchat outbound suppressed: empty text and no media`,
     );
@@ -106,7 +109,7 @@ export async function sendOpenclawClawlingText(params: SendParams): Promise<Send
   // with one of the SDK's narrow Fragment members (ImageFragment / FileFragment /
   // AudioFragment / VideoFragment) based on its runtime `kind`. The wide local
   // shape lets us build a single uniform array without a per-kind switch.
-  const fragments = [...textFragments, ...mediaFragments] as Fragment[];
+  const fragments = [...textFragments, ...richFragments, ...mediaFragments] as Fragment[];
 
   const useReply = params.replyCtx && mediaFragments.length === 0;
   if (params.replyCtx && mediaFragments.length > 0) {
@@ -121,26 +124,24 @@ export async function sendOpenclawClawlingText(params: SendParams): Promise<Send
     mode = "reply";
     ack = await params.client.replyMessage({
       chat_id: params.to.chatId,
-      chat_type: params.to.chatType,
       mode: "normal",
       replyTo: {
         msgId: params.replyCtx.replyToMessageId,
-        senderId: params.replyCtx.replyPreviewSenderId,
+        senderId: params.replyCtx.replyPreviewChatId ?? params.replyCtx.replyPreviewSenderId,
         nickName: params.replyCtx.replyPreviewNickName,
         fragments: [{ kind: "text", text: params.replyCtx.replyPreviewText }],
       },
       body: { fragments },
       context: { mentions },
-    });
+    } as Parameters<ClawlingChatClient["replyMessage"]>[0]);
   } else {
     mode = "send";
     ack = await params.client.sendMessage({
       chat_id: params.to.chatId,
-      chat_type: params.to.chatType,
       mode: "normal",
       body: { fragments },
       context: { mentions, reply: null },
-    });
+    } as Parameters<ClawlingChatClient["sendMessage"]>[0]);
   }
   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}`,

package/src/plugin-entry.test.ts

@@ -3,9 +3,14 @@ import pluginEntry from "../index.ts";
 
 describe("openclaw-clawchat plugin entry", () => {
   it("registers the channel/tools and native activation command without bootstrap migration", () => {
+    const mutateConfigFile = vi.fn();
     const api = {
       config: {},
-      runtime: {},
+      runtime: {
+        config: {
+          mutateConfigFile,
+        },
+      },
       logger: { debug: vi.fn(), info: vi.fn(), error: vi.fn() },
       registerChannel: vi.fn(),
       registerCommand: vi.fn(),
@@ -23,5 +28,6 @@ describe("openclaw-clawchat plugin entry", () => {
         name: "clawchat-login",
       }),
     );
+    expect(mutateConfigFile).not.toHaveBeenCalled();
   });
 });

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" } }],
+            },
+          ],
+        },
+      }),
+    );
   });
 });