@newbase-clawchat/openclaw-clawchat 2026.4.29 → 2026.5.4

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

package/src/runtime.ts

@@ -262,6 +262,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
             ...(replyCtx ? { replyCtx } : {}),
             inboundMessageId: turn.messageId,
             inboundForFinalReply: {
+              chatId: turn.peer.id,
               senderId: turn.senderId,
               senderNickName: turn.senderNickName || turn.senderId,
               bodyText: turn.rawBody,

package/src/streaming.test.ts

@@ -37,12 +37,12 @@ describe("openclaw-clawchat streaming", () => {
       "message.done",
     ]);
     expect((client.typing as ReturnType<typeof vi.fn>).mock.calls).toEqual([
-      ["u1", true, "direct"],
-      ["u1", false, "direct"],
+      ["u1", true],
+      ["u1", false],
     ]);
   });
 
-  it("message.created payload is minimal (just message_id); adds carry monotonic sequences", async () => {
+  it("message.created payload is minimal (just message_id); adds carry zero-based monotonic sequences", async () => {
     const { client, sent } = mockClient();
     await sendStreamingText({
       client,
@@ -54,10 +54,10 @@ describe("openclaw-clawchat streaming", () => {
 
     // created payload is { message_id } only — no embedded message / streaming.
     expect(sent[0]!.payload).toEqual({ message_id: "m1" });
-    expect(sent[1]!.payload.sequence).toBe(1);
-    expect(sent[2]!.payload.sequence).toBe(2);
-    expect(sent[3]!.payload.sequence).toBe(3);
-    expect((sent[4]!.payload.streaming as { sequence: number }).sequence).toBe(3);
+    expect(sent[1]!.payload.sequence).toBe(0);
+    expect(sent[2]!.payload.sequence).toBe(1);
+    expect(sent[3]!.payload.sequence).toBe(2);
+    expect((sent[4]!.payload.streaming as { sequence: number }).sequence).toBe(2);
   });
 
   it("each message.add carries fragments: [{ text: cumulative, delta: new }]", async () => {
@@ -107,10 +107,13 @@ describe("openclaw-clawchat streaming", () => {
       reason: "boom",
     });
     expect(sent[0]!.event).toBe("message.failed");
-    expect(sent[0]!.payload.sequence).toBe(3);
+    expect(sent[0]!.payload.sequence).toBe(2);
     expect(sent[0]!.payload.reason).toBe("boom");
+    expect(sent[0]!.payload).toHaveProperty("completed_at");
+    expect(sent[0]!.payload).not.toHaveProperty("failed_at");
+    expect(sent[0]!.payload.fragments).toEqual([{ kind: "text", text: "boom" }]);
     expect((client.typing as ReturnType<typeof vi.fn>).mock.calls).toEqual([
-      ["u1", false, "direct"],
+      ["u1", false],
     ]);
   });
 });

package/src/streaming.ts

@@ -45,13 +45,13 @@ export async function sendStreamingText(params: StreamingSendParams): Promise<vo
   const routing = resolveRouting(params);
   const emitTyping = params.emitTyping !== false;
   if (emitTyping) {
-    params.client.typing(routing.chatId, true, routing.chatType);
+    params.client.typing(routing.chatId, true);
   }
   emitStreamCreated(params.client, {
     messageId: params.messageId,
     routing,
   });
-  let sequence = 0;
+  let sequence = -1;
   let fullText = "";
   for (const chunk of params.chunks) {
     sequence += 1;
@@ -67,11 +67,11 @@ export async function sendStreamingText(params: StreamingSendParams): Promise<vo
   emitStreamDone(params.client, {
     messageId: params.messageId,
     routing,
-    finalSequence: sequence,
+    finalSequence: Math.max(sequence, 0),
     finalText: fullText,
   });
   if (emitTyping) {
-    params.client.typing(routing.chatId, false, routing.chatType);
+    params.client.typing(routing.chatId, false);
   }
 }
 
@@ -90,10 +90,10 @@ export async function sendStreamingFailure(params: StreamingFailureParams): Prom
   emitStreamFailed(params.client, {
     messageId: params.messageId,
     routing,
-    sequence: params.currentSequence + 1,
+    sequence: params.currentSequence,
     reason: params.reason,
   });
   if (params.emitTyping !== false) {
-    params.client.typing(routing.chatId, false, routing.chatType);
+    params.client.typing(routing.chatId, false);
   }
 }

package/src/tools.test.ts

@@ -1,4 +1,5 @@
-import { describe, expect, it, vi } from "vitest";
+import fs from "node:fs";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { registerOpenclawClawlingTools } from "./tools.ts";
 
 const loginRuntime = vi.hoisted(() => ({
@@ -12,6 +13,16 @@ interface RegisteredTool {
   execute: (callId: string, params: unknown) => Promise<unknown>;
 }
 
+const ALWAYS_VISIBLE_TOOL_NAMES = [
+  "clawchat_activate",
+  "clawchat_get_account_profile",
+  "clawchat_get_user_profile",
+  "clawchat_list_account_friends",
+  "clawchat_update_account_profile",
+  "clawchat_upload_avatar_image",
+  "clawchat_upload_media_file",
+];
+
 function buildApi(opts: {
   configChannel?: Record<string, unknown> | null;
   configTools?: Record<string, unknown>;
@@ -32,6 +43,11 @@ function buildApi(opts: {
       warn: vi.fn(),
       error: vi.fn(),
     },
+    runtime: {
+      config: {
+        mutateConfigFile: vi.fn(),
+      },
+    },
     registerTool: (tool: RegisteredTool, _options?: { name: string }) => {
       registered.push(tool);
     },
@@ -49,12 +65,22 @@ function configuredChannel(extra: Record<string, unknown> = {}) {
 }
 
 describe("registerOpenclawClawlingTools", () => {
-  it("registers no tools when account.configured is false", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("uses OpenClaw SDK tool result types instead of direct pi-agent-core imports", () => {
+    const source = fs.readFileSync(new URL("./tools.ts", import.meta.url), "utf8");
+    expect(source).not.toMatch(/@mariozechner\/pi-agent-core/);
+    expect(source).toMatch(/openclaw\/plugin-sdk\/agent-harness-runtime/);
+  });
+
+  it("registers all ClawChat tools even when account.configured is false", () => {
     const { api, registered } = buildApi({
       configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
     });
     registerOpenclawClawlingTools(api);
-    expect(registered.map((t) => t.name)).toEqual([]);
+    expect(registered.map((t) => t.name).sort()).toEqual(ALWAYS_VISIBLE_TOOL_NAMES);
   });
 
   it("does not mutate tool policy during registration before account activation", () => {
@@ -65,22 +91,51 @@ describe("registerOpenclawClawlingTools", () => {
 
     registerOpenclawClawlingTools(api);
 
-    expect(registered.map((t) => t.name)).toEqual([]);
+    expect(registered.map((t) => t.name).sort()).toEqual(ALWAYS_VISIBLE_TOOL_NAMES);
     expect(api.config?.tools).toEqual({
       profile: "coding",
       allow: [],
     });
   });
 
-  it("does not register clawchat_activate for invite-code onboarding", async () => {
+  it("registers clawchat_activate for invite-code onboarding", async () => {
+    const { api, registered } = buildApi({
+      configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
+    });
+
+    registerOpenclawClawlingTools(api);
+
+    const tool = registered.find((t) => t.name === "clawchat_activate");
+    expect(tool).toBeDefined();
+    loginRuntime.runOpenclawClawlingLogin.mockResolvedValueOnce(undefined);
+
+    const result = await tool!.execute("call-1", { code: "A1B2C3" });
+
+    expect(loginRuntime.runOpenclawClawlingLogin).toHaveBeenCalledTimes(1);
+    const params = loginRuntime.runOpenclawClawlingLogin.mock.calls[0]?.[0];
+    expect(params.cfg).toBe(api.config);
+    expect(params.mutateConfigFile).toBe(api.runtime.config.mutateConfigFile);
+    await expect(params.readInviteCode()).resolves.toBe("A1B2C3");
+    const text = (result as { content: { text: string }[] }).content[0]!.text;
+    const parsed = JSON.parse(text) as { ok?: boolean; message?: string };
+    expect(parsed.ok).toBe(true);
+    expect(parsed.message).toMatch(/activated successfully/i);
+  });
+
+  it("clawchat_activate rejects empty invite codes", async () => {
     const { api, registered } = buildApi({
       configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
     });
 
     registerOpenclawClawlingTools(api);
+    const tool = registered.find((t) => t.name === "clawchat_activate")!;
+    const result = await tool.execute("call-1", { code: "   " });
 
-    expect(registered.some((t) => t.name === "clawchat_activate")).toBe(false);
     expect(loginRuntime.runOpenclawClawlingLogin).not.toHaveBeenCalled();
+    const text = (result as { content: { text: string }[] }).content[0]!.text;
+    const parsed = JSON.parse(text) as { error?: string; message?: string };
+    expect(parsed.error).toBe("validation");
+    expect(parsed.message).toMatch(/code is required/i);
   });
 
   it("skips registration when api.config is undefined", () => {
@@ -89,20 +144,13 @@ describe("registerOpenclawClawlingTools", () => {
     expect(registered).toHaveLength(0);
   });
 
-  it("registers all six account tools when configured (regardless of baseUrl)", () => {
+  it("registers all seven ClawChat tools when configured (regardless of baseUrl)", () => {
     const { api, registered } = buildApi({
       configChannel: configuredChannel(/* no baseUrl */),
     });
     registerOpenclawClawlingTools(api);
     const names = registered.map((t) => t.name).sort();
-    expect(names).toEqual([
-      "clawchat_get_account_profile",
-      "clawchat_get_user_profile",
-      "clawchat_list_account_friends",
-      "clawchat_update_account_profile",
-      "clawchat_upload_avatar_image",
-      "clawchat_upload_media_file",
-    ]);
+    expect(names).toEqual(ALWAYS_VISIBLE_TOOL_NAMES);
   });
 
   it("logs configured tool registration at debug level only", () => {
@@ -118,16 +166,31 @@ describe("registerOpenclawClawlingTools", () => {
 
     expect(logger.info).not.toHaveBeenCalled();
     expect(logger.debug).toHaveBeenCalledWith(
-      "openclaw-clawchat: registered 6 clawchat_* tools (get_account_profile, get_user_profile, list_account_friends, update_account_profile, upload_avatar_image, upload_media_file)",
+      "openclaw-clawchat: registered 7 clawchat_* tools (activate, get_account_profile, get_user_profile, list_account_friends, update_account_profile, upload_avatar_image, upload_media_file)",
     );
   });
 
-  it("does not register clawchat_activate when configured", () => {
+  it("registers clawchat_activate when configured", () => {
     const { api, registered } = buildApi({
       configChannel: configuredChannel(),
     });
     registerOpenclawClawlingTools(api);
-    expect(registered.some((t) => t.name === "clawchat_activate")).toBe(false);
+    expect(registered.some((t) => t.name === "clawchat_activate")).toBe(true);
+  });
+
+  it("account tools return a config error before activation instead of disappearing", async () => {
+    const { api, registered } = buildApi({
+      configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
+    });
+
+    registerOpenclawClawlingTools(api);
+    const tool = registered.find((t) => t.name === "clawchat_get_account_profile")!;
+    const result = await tool.execute("call-1", {});
+
+    const text = (result as { content: { text: string }[] }).content[0]!.text;
+    const parsed = JSON.parse(text) as { error?: string; message?: string };
+    expect(parsed.error).toBe("config");
+    expect(parsed.message).toMatch(/token is required/i);
   });
 
   it("clawchat_update_account_profile description names account profile triggers (EN + ZH)", () => {