@newbase-clawchat/openclaw-clawchat 2026.5.4 → 2026.5.12-13

package/src/config.ts

@@ -4,6 +4,7 @@ import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 export const CHANNEL_ID = "openclaw-clawchat" as const;
 export const CLAWCHAT_TOKEN_ENV = "CLAWCHAT_TOKEN" as const;
 export const CLAWCHAT_USER_ID_ENV = "CLAWCHAT_USER_ID" as const;
+export const CLAWCHAT_OWNER_USER_ID_ENV = "CLAWCHAT_OWNER_USER_ID" as const;
 export const CLAWCHAT_REFRESH_TOKEN_ENV = "CLAWCHAT_REFRESH_TOKEN" as const;
 export const CLAWCHAT_BASE_URL_ENV = "CLAWCHAT_BASE_URL" as const;
 export const CLAWCHAT_WEBSOCKET_URL_ENV = "CLAWCHAT_WEBSOCKET_URL" as const;
@@ -14,16 +15,16 @@ export const CLAWCHAT_WEBSOCKET_URL_ENV = "CLAWCHAT_WEBSOCKET_URL" as const;
  * setup` call. Operators can still override either one via config.
  *
  */
-export const DEFAULT_BASE_URL = "http://company.newbaselab.com:10086" as const;
-export const DEFAULT_WEBSOCKET_URL = "ws://company.newbaselab.com:10086/ws" as const;
+export const DEFAULT_BASE_URL = "https://app.clawling.com" as const;
+export const DEFAULT_WEBSOCKET_URL = "wss://app.clawling.com/ws" as const;
 
 export type ReplyMode = "static" | "stream";
 
 /**
  * Group-chat trigger policy.
- * - "mention" (default): only trigger a reply when the inbound `context.mentions`
- *   list contains our `userId` (i.e. the sender @-mentioned us).
- * - "all": trigger on every group message regardless of mentions (open listen).
+ * - "all" (default): trigger on every group message regardless of mentions (open listen).
+ * - "mention": only trigger a reply when the inbound `context.mentions`
+ *   list includes our `userId` (i.e. the sender @-mentioned us).
  */
 export type GroupMode = "mention" | "all";
 
@@ -66,6 +67,10 @@ export type OpenclawClawlingStreamConfig = {
   maxBufferChars?: number;
 };
 
+export type OpenclawClawlingGroupConfig = {
+  groupMode: GroupMode;
+};
+
 export type OpenclawClawlingReconnectConfig = {
   initialDelay?: number;
   maxDelay?: number;
@@ -92,8 +97,10 @@ export type OpenclawClawlingConfig = {
   /** Refresh token persisted by ClawChat activation/login (paired with `token`). */
   refreshToken?: string;
   userId?: string;
+  ownerUserId?: string;
   replyMode?: ReplyMode;
   groupMode?: GroupMode;
+  groups?: Record<string, Partial<OpenclawClawlingGroupConfig>>;
   forwardThinking?: boolean;
   forwardToolCalls?: boolean;
   /** Emit approval/action rich fragments instead of plain fallback text. */
@@ -114,8 +121,19 @@ export const openclawClawlingConfigSchema = {
     token: { type: "string" },
     refreshToken: { type: "string" },
     userId: { type: "string" },
+    ownerUserId: { type: "string" },
     replyMode: { type: "string", enum: ["static", "stream"] },
     groupMode: { type: "string", enum: ["mention", "all"] },
+    groups: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          groupMode: { type: "string", enum: ["mention", "all"] },
+        },
+      },
+    },
     forwardThinking: { type: "boolean" },
     forwardToolCalls: { type: "boolean" },
     richInteractions: { type: "boolean" },
@@ -161,17 +179,7 @@ function isOpenclawClawchatToolAllowEntry(entry: unknown): boolean {
   return entry === CHANNEL_ID || entry === "group:plugins";
 }
 
-function hasOpenclawClawchatToolAllow(cfg: OpenClawConfig): boolean {
-  const currentTools = ((cfg as { tools?: Record<string, unknown> }).tools ?? {}) as Record<
-    string,
-    unknown
-  >;
-  const currentAlsoAllow = Array.isArray(currentTools.alsoAllow) ? currentTools.alsoAllow : [];
-  const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow : [];
-  return [...currentAllow, ...currentAlsoAllow].some(isOpenclawClawchatToolAllowEntry);
-}
-
-function mergeToolPolicyEntryAllow(
+function mergeToolPolicyEntryAlsoAllow(
   cfg: OpenClawConfig,
   entry: string,
   isAlreadyCovered: (value: unknown) => boolean,
@@ -184,28 +192,60 @@ function mergeToolPolicyEntryAllow(
     ? currentTools.alsoAllow.slice()
     : [];
   const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow.slice() : [];
-  const alreadyAllowed = [...currentAllow, ...currentAlsoAllow].some(isAlreadyCovered);
-  if (currentAllow.length > 0) {
+  const alreadyCovered = [...currentAllow, ...currentAlsoAllow].some(isAlreadyCovered);
+  if (alreadyCovered) {
     return {
       ...cfg,
       tools: {
         ...currentTools,
-        allow: alreadyAllowed ? currentAllow : [...currentAllow, entry],
+        ...(Array.isArray(currentTools.allow) ? { allow: currentAllow } : {}),
+        ...(Array.isArray(currentTools.alsoAllow) ? { alsoAllow: currentAlsoAllow } : {}),
       },
     } as OpenClawConfig;
   }
-  const alreadyAlsoAllowed = currentAlsoAllow.some(isAlreadyCovered);
   return {
     ...cfg,
     tools: {
       ...currentTools,
-      alsoAllow: alreadyAlsoAllowed ? currentAlsoAllow : [...currentAlsoAllow, entry],
+      alsoAllow: [...currentAlsoAllow, entry],
     },
   } as OpenClawConfig;
 }
 
 export function mergeOpenclawClawchatToolAllow(cfg: OpenClawConfig): OpenClawConfig {
-  return mergeToolPolicyEntryAllow(cfg, CHANNEL_ID, isOpenclawClawchatToolAllowEntry);
+  return mergeToolPolicyEntryAlsoAllow(cfg, CHANNEL_ID, isOpenclawClawchatToolAllowEntry);
+}
+
+function readRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+export function mergeOpenclawClawchatRuntimePluginActivation(
+  cfg: OpenClawConfig,
+): OpenClawConfig {
+  const currentPlugins = readRecord((cfg as { plugins?: unknown }).plugins);
+  const currentEntries = readRecord(currentPlugins.entries);
+  const currentEntry = readRecord(currentEntries[CHANNEL_ID]);
+  const currentAllow = Array.isArray(currentPlugins.allow) ? currentPlugins.allow.slice() : [];
+  const nextPlugins: Record<string, unknown> = {
+    ...currentPlugins,
+    entries: {
+      ...currentEntries,
+      [CHANNEL_ID]: {
+        ...currentEntry,
+        enabled: true,
+      },
+    },
+  };
+  if (!currentAllow.includes(CHANNEL_ID)) {
+    nextPlugins.allow = [...currentAllow, CHANNEL_ID];
+  }
+  return {
+    ...cfg,
+    plugins: nextPlugins,
+  } as OpenClawConfig;
 }
 
 export type ResolvedOpenclawClawlingAccount = {
@@ -217,8 +257,10 @@ export type ResolvedOpenclawClawlingAccount = {
   baseUrl: string;
   token: string;
   userId: string;
+  ownerUserId: string;
   replyMode: ReplyMode;
   groupMode: GroupMode;
+  groups: Record<string, OpenclawClawlingGroupConfig>;
   forwardThinking: boolean;
   forwardToolCalls: boolean;
   richInteractions: boolean;
@@ -248,7 +290,31 @@ function readReplyMode(value: unknown): ReplyMode {
 }
 
 function readGroupMode(value: unknown): GroupMode {
-  return value === "all" ? "all" : "mention";
+  return value === "mention" ? "mention" : "all";
+}
+
+function readGroups(value: unknown): Record<string, OpenclawClawlingGroupConfig> {
+  const rawGroups = value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+  const groups: Record<string, OpenclawClawlingGroupConfig> = {};
+  for (const [chatId, rawGroup] of Object.entries(rawGroups)) {
+    if (!chatId) continue;
+    const group = rawGroup && typeof rawGroup === "object" && !Array.isArray(rawGroup)
+      ? (rawGroup as Record<string, unknown>)
+      : {};
+    groups[chatId] = { groupMode: readGroupMode(group.groupMode) };
+  }
+  return groups;
+}
+
+export function effectiveGroupMode(
+  account: Pick<ResolvedOpenclawClawlingAccount, "groupMode" | "groups">,
+  chatId: string,
+): GroupMode {
+  return account.groups[chatId]?.groupMode
+    ?? account.groups["*"]?.groupMode
+    ?? account.groupMode;
 }
 
 function readStream(raw: unknown): Required<OpenclawClawlingStreamConfig> {
@@ -312,9 +378,12 @@ export function resolveOpenclawClawlingAccount(
     DEFAULT_BASE_URL;
   const token = readOptionalString(channel.token) || readEnvString(env, CLAWCHAT_TOKEN_ENV);
   const userId = readOptionalString(channel.userId) || readEnvString(env, CLAWCHAT_USER_ID_ENV);
+  const ownerUserId =
+    readOptionalString(channel.ownerUserId) || readEnvString(env, CLAWCHAT_OWNER_USER_ID_ENV);
   const enabled = typeof channel.enabled === "boolean" ? channel.enabled : true;
   const replyMode = readReplyMode(channel.replyMode);
   const groupMode = readGroupMode(channel.groupMode);
+  const groups = readGroups(channel.groups);
   const forwardThinking =
     typeof channel.forwardThinking === "boolean" ? channel.forwardThinking : true;
   const forwardToolCalls =
@@ -326,13 +395,15 @@ export function resolveOpenclawClawlingAccount(
     accountId: DEFAULT_ACCOUNT_ID,
     name: CHANNEL_ID,
     enabled,
-    configured: Boolean(websocketUrl && token && userId),
+    configured: Boolean(websocketUrl && token && userId && ownerUserId),
     websocketUrl,
     baseUrl,
     token,
     userId,
+    ownerUserId,
     replyMode,
     groupMode,
+    groups,
     forwardThinking,
     forwardToolCalls,
     richInteractions,

package/src/inbound.test.ts

@@ -1,8 +1,8 @@
-import type { Envelope, DownlinkMessageSendPayload } from "@newbase-clawchat/sdk";
+import type { Envelope, MessagePayload } from "./protocol-types.ts";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import type { ResolvedOpenclawClawlingAccount } from "./config.ts";
-import { dispatchOpenclawClawlingInbound, _resetDedupForTest } from "./inbound.ts";
+import { dispatchOpenclawClawlingInbound } from "./inbound.ts";
 
 function baseAccount(
   overrides: Partial<ResolvedOpenclawClawlingAccount> = {},
@@ -16,7 +16,11 @@ function baseAccount(
     baseUrl: "",
     token: "tk",
     userId: "agent-1",
+    ownerUserId: "owner-1",
     replyMode: "static",
+    groupMode: "all",
+    groups: {},
+    richInteractions: false,
     forwardThinking: true,
     forwardToolCalls: false,
     allowFrom: [],
@@ -37,24 +41,28 @@ function buildSendEnvelope(
   overrides: Partial<{
     event: "message.send" | "message.reply";
     text: string;
-    senderType: "direct" | "group";
-    mentions: string[];
+    chatType: "direct" | "group";
+    mentions: unknown[];
     reply: unknown;
     messageId: string;
     chatId: string;
+    omitChatId: boolean;
   }> = {},
-): Envelope<DownlinkMessageSendPayload> {
+): Envelope<MessagePayload> {
+  const chatId = overrides.chatId ?? "chat-1";
+  const chatType = overrides.chatType ?? "direct";
   return {
     version: "2",
     event: overrides.event ?? "message.send",
     trace_id: "trace-1",
     emitted_at: 1776162600000,
-    chat_id: overrides.chatId,
-    to: { id: "agent-1", type: overrides.senderType ?? "direct" },
+    ...(overrides.omitChatId ? {} : { chat_id: chatId }),
+    chat_type: chatType,
+    to: { id: chatId, type: chatType },
     sender: {
-      sender_id: "user-1",
-      type: overrides.senderType ?? "direct",
-      display_name: "User One",
+      id: "user-1",
+      type: "direct",
+      nick_name: "User One",
     },
     payload: {
       message_id: overrides.messageId ?? "msg-1",
@@ -74,21 +82,63 @@ function buildSendEnvelope(
           started_at: null,
           completed_at: null,
         },
-        sender: {
-          sender_id: "user-1",
-          type: overrides.senderType ?? "direct",
-          display_name: "User One",
-        },
-      } as DownlinkMessageSendPayload["message"],
+      } as MessagePayload["message"],
     },
-  } as Envelope<DownlinkMessageSendPayload>;
+  } as Envelope<MessagePayload>;
 }
 
-describe("openclaw-clawchat inbound", () => {
-  beforeEach(() => {
-    _resetDedupForTest();
-  });
+function buildStreamEnvelope(
+  overrides: Partial<{
+    event: "message.created" | "message.add" | "message.done" | "message.failed";
+    fragments: Array<Record<string, unknown>>;
+    messageId: string;
+    sequence: number;
+    chatId: string;
+    chatType: "direct" | "group";
+  }> = {},
+): Envelope<unknown> {
+  const event = overrides.event ?? "message.done";
+  const sequence = overrides.sequence ?? 0;
+  const payload: Record<string, unknown> = {
+    message_id: overrides.messageId ?? "stream-1",
+  };
+  if (event === "message.add") {
+    payload.sequence = sequence;
+    payload.mutation = { type: "append", target_fragment_index: null };
+    payload.fragments = overrides.fragments ?? [{ kind: "text", text: "Hel", delta: "Hel" }];
+    payload.streaming = {
+      status: "streaming",
+      sequence,
+      mutation_policy: "append_text_only",
+      started_at: null,
+      completed_at: null,
+    };
+    payload.added_at = 1776162600001;
+  }
+  if (event === "message.done" || event === "message.failed") {
+    payload.fragments = overrides.fragments ?? [{ kind: "text", text: "Hello" }];
+    payload.streaming = {
+      status: event === "message.done" ? "done" : "failed",
+      sequence,
+      mutation_policy: "append_text_only",
+      started_at: null,
+      completed_at: 1776162600002,
+    };
+    payload.completed_at = 1776162600002;
+  }
+  return {
+    version: "2",
+    event,
+    trace_id: `trace-${event}`,
+    emitted_at: 1776162600000,
+    chat_id: overrides.chatId ?? "chat-1",
+    chat_type: overrides.chatType ?? "direct",
+    sender: { id: "user-1", type: "direct", nick_name: "User One" },
+    payload,
+  } as Envelope<unknown>;
+}
 
+describe("openclaw-clawchat inbound", () => {
   it("dispatches a plain text message and flattens the body", async () => {
     const ingest = vi.fn().mockResolvedValue(undefined);
     await dispatchOpenclawClawlingInbound({
@@ -102,14 +152,137 @@ describe("openclaw-clawchat inbound", () => {
     const call = ingest.mock.calls[0]![0];
     expect(call.channel).toBe("openclaw-clawchat");
     expect(call.rawBody).toBe("hello there");
-    expect(call.peer).toEqual({ kind: "direct", id: "user-1" });
+    expect(call.peer).toEqual({ kind: "direct", id: "chat-1" });
     expect(call.messageId).toBe("msg-1");
   });
 
+  it("dispatches materialized message.send and message.reply inbound", async () => {
+    for (const event of ["message.send", "message.reply"] as const) {
+      const ingest = vi.fn().mockResolvedValue(undefined);
+      await dispatchOpenclawClawlingInbound({
+        envelope: buildSendEnvelope({ event, messageId: `msg-${event}` }),
+        cfg: {},
+        runtime: {} as never,
+        account: baseAccount(),
+        ingest,
+      });
+      expect(ingest).toHaveBeenCalledTimes(1);
+    }
+  });
+
+  it("dispatches message.done lifecycle frames as completed inbound messages", async () => {
+    const ingest = vi.fn().mockResolvedValue(undefined);
+    await dispatchOpenclawClawlingInbound({
+      envelope: buildStreamEnvelope({
+        event: "message.done",
+        messageId: "stream-1",
+        fragments: [{ kind: "text", text: "completed stream" }],
+      }) as Envelope<MessagePayload>,
+      cfg: {},
+      runtime: {} as never,
+      account: baseAccount(),
+      ingest,
+    });
+
+    expect(ingest).toHaveBeenCalledTimes(1);
+    const call = ingest.mock.calls[0]![0];
+    expect(call.messageId).toBe("stream-1");
+    expect(call.rawBody).toBe("completed stream");
+    expect(call.peer).toEqual({ kind: "direct", id: "chat-1" });
+  });
+
+  it("tracks stream add frames and dispatches only the done payload", async () => {
+    const ingest = vi.fn().mockResolvedValue(undefined);
+    for (const envelope of [
+      buildStreamEnvelope({ event: "message.created", messageId: "stream-2" }),
+      buildStreamEnvelope({
+        event: "message.add",
+        messageId: "stream-2",
+        fragments: [{ kind: "text", text: "partial", delta: "partial" }],
+      }),
+      buildStreamEnvelope({
+        event: "message.done",
+        messageId: "stream-2",
+        fragments: [{ kind: "text", text: "final text" }],
+      }),
+    ]) {
+      await dispatchOpenclawClawlingInbound({
+        envelope: envelope as Envelope<MessagePayload>,
+        cfg: {},
+        runtime: {} as never,
+        account: baseAccount(),
+        ingest,
+      });
+    }
+
+    expect(ingest).toHaveBeenCalledTimes(1);
+    expect(ingest.mock.calls[0]![0].rawBody).toBe("final text");
+  });
+
+  it("derives mentions from message.done fragments for group mention mode", async () => {
+    const ingest = vi.fn().mockResolvedValue(undefined);
+    await dispatchOpenclawClawlingInbound({
+      envelope: buildStreamEnvelope({
+        event: "message.done",
+        messageId: "stream-group-1",
+        chatId: "group-1",
+        chatType: "group",
+        fragments: [
+          { kind: "mention", user_id: "agent-1", display: "@bot" },
+          { kind: "text", text: " please help" },
+        ],
+      }) as Envelope<MessagePayload>,
+      cfg: {},
+      runtime: {} as never,
+      account: baseAccount({ groupMode: "mention" }),
+      ingest,
+    });
+
+    expect(ingest).toHaveBeenCalledTimes(1);
+    const call = ingest.mock.calls[0]![0];
+    expect(call.peer).toEqual({ kind: "group", id: "group-1" });
+    expect(call.wasMentioned).toBe(true);
+    expect(call.rawBody).toBe("@bot please help");
+  });
+
+  it("skips message.done payloads with a non-done streaming status", async () => {
+    const ingest = vi.fn().mockResolvedValue(undefined);
+    const envelope = buildStreamEnvelope({
+      event: "message.done",
+      messageId: "stream-bad-status",
+      fragments: [{ kind: "text", text: "bad status" }],
+    });
+    (envelope.payload as { streaming: { status: string } }).streaming.status = "failed";
+
+    await dispatchOpenclawClawlingInbound({
+      envelope: envelope as Envelope<MessagePayload>,
+      cfg: {},
+      runtime: {} as never,
+      account: baseAccount(),
+      ingest,
+    });
+
+    expect(ingest).not.toHaveBeenCalled();
+  });
+
+  it("does not dispatch unfinished or failed stream lifecycle frames", async () => {
+    for (const event of ["message.created", "message.add", "message.failed"] as const) {
+      const ingest = vi.fn().mockResolvedValue(undefined);
+      await dispatchOpenclawClawlingInbound({
+        envelope: buildStreamEnvelope({ event, messageId: `msg-${event}` }) as Envelope<MessagePayload>,
+        cfg: {},
+        runtime: {} as never,
+        account: baseAccount(),
+        ingest,
+      });
+      expect(ingest).not.toHaveBeenCalled();
+    }
+  });
+
   it("marks wasMentioned=true when direct chat", async () => {
     const ingest = vi.fn().mockResolvedValue(undefined);
     await dispatchOpenclawClawlingInbound({
-      envelope: buildSendEnvelope({ senderType: "direct" }),
+      envelope: buildSendEnvelope({ chatType: "direct" }),
       cfg: {},
       runtime: {} as never,
       account: baseAccount({ groupMode: "mention" }),
@@ -124,27 +297,44 @@ describe("openclaw-clawchat inbound", () => {
     expect(
       detectMention({
         mentions: ["agent-1"],
-        senderType: "group",
+        chatType: "group",
         userId: "agent-1",
       }),
     ).toBe(true);
   });
 
+  it("detects object-shaped context mentions in group mention mode", async () => {
+    const ingest = vi.fn().mockResolvedValue(undefined);
+    await dispatchOpenclawClawlingInbound({
+      envelope: buildSendEnvelope({
+        chatType: "group",
+        mentions: [{ user_id: "agent-1", display: "@bot" }],
+      }),
+      cfg: {},
+      runtime: {} as never,
+      account: baseAccount({ groupMode: "mention" }),
+      ingest,
+    });
+
+    expect(ingest).toHaveBeenCalledTimes(1);
+    expect(ingest.mock.calls[0]![0].wasMentioned).toBe(true);
+  });
+
   it("detectMention returns false for group chat when userId not mentioned", async () => {
     const { detectMention } = await import("./inbound.ts");
     expect(
       detectMention({
         mentions: ["user-2"],
-        senderType: "group",
+        chatType: "group",
         userId: "agent-1",
       }),
     ).toBe(false);
   });
 
-  it("skips group messages entirely", async () => {
+  it("skips unmentioned group messages in mention mode", async () => {
     const ingest = vi.fn().mockResolvedValue(undefined);
     await dispatchOpenclawClawlingInbound({
-      envelope: buildSendEnvelope({ senderType: "group" }),
+      envelope: buildSendEnvelope({ chatType: "group" }),
       cfg: {},
       runtime: {} as never,
       account: baseAccount({ groupMode: "mention" }),
@@ -153,6 +343,57 @@ describe("openclaw-clawchat inbound", () => {
     expect(ingest).not.toHaveBeenCalled();
   });
 
+  it("uses exact per-group mention mode for matching group chat_id", async () => {
+    const ingest = vi.fn().mockResolvedValue(undefined);
+    await dispatchOpenclawClawlingInbound({
+      envelope: buildSendEnvelope({ chatType: "group", chatId: "group-quiet" }),
+      cfg: {},
+      runtime: {} as never,
+      account: baseAccount({
+        groupMode: "all",
+        groups: { "group-quiet": { groupMode: "mention" } },
+      }),
+      ingest,
+    });
+
+    expect(ingest).not.toHaveBeenCalled();
+  });
+
+  it("uses wildcard per-group mention mode when exact group is absent", async () => {
+    const ingest = vi.fn().mockResolvedValue(undefined);
+    await dispatchOpenclawClawlingInbound({
+      envelope: buildSendEnvelope({ chatType: "group", chatId: "group-any" }),
+      cfg: {},
+      runtime: {} as never,
+      account: baseAccount({
+        groupMode: "all",
+        groups: { "*": { groupMode: "mention" } },
+      }),
+      ingest,
+    });
+
+    expect(ingest).not.toHaveBeenCalled();
+  });
+
+  it("lets exact per-group all mode override wildcard mention mode", async () => {
+    const ingest = vi.fn().mockResolvedValue(undefined);
+    await dispatchOpenclawClawlingInbound({
+      envelope: buildSendEnvelope({ chatType: "group", chatId: "group-open" }),
+      cfg: {},
+      runtime: {} as never,
+      account: baseAccount({
+        groupMode: "mention",
+        groups: {
+          "group-open": { groupMode: "all" },
+          "*": { groupMode: "mention" },
+        },
+      }),
+      ingest,
+    });
+
+    expect(ingest).toHaveBeenCalledTimes(1);
+  });
+
   it("skips messages with empty renderable text", async () => {
     const ingest = vi.fn().mockResolvedValue(undefined);
     await dispatchOpenclawClawlingInbound({
@@ -170,8 +411,8 @@ describe("openclaw-clawchat inbound", () => {
     const replyRef = {
       reply_to_msg_id: "m-orig",
       reply_preview: {
-        sender_id: "user-2",
-        display_name: "User Two",
+        id: "user-2",
+        nick_name: "User Two",
         fragments: [{ kind: "text", text: "original text" }],
       },
     };
@@ -192,7 +433,7 @@ describe("openclaw-clawchat inbound", () => {
     });
   });
 
-  it("deduplicates repeat message_ids", async () => {
+  it("does not own duplicate suppression when the same message_id is parsed twice", async () => {
     const ingest = vi.fn().mockResolvedValue(undefined);
     const env = buildSendEnvelope({ messageId: "dup-1" });
     await dispatchOpenclawClawlingInbound({
@@ -209,13 +450,13 @@ describe("openclaw-clawchat inbound", () => {
       account: baseAccount(),
       ingest,
     });
-    expect(ingest).toHaveBeenCalledTimes(1);
+    expect(ingest).toHaveBeenCalledTimes(2);
   });
 
   it("passes mediaItems extracted from body fragments to ingest", async () => {
     const ingest = vi.fn().mockResolvedValue(undefined);
     const env = buildSendEnvelope({});
-    // Replace the body's fragments with text + image (SDK 0.2.0 typed union accepts these directly)
+    // Replace the body's fragments with text + image; the local fragment union accepts these directly.
     env.payload.message.body.fragments = [
       { kind: "text", text: "hello" },
       { kind: "image", url: "https://cdn/x.png", mime: "image/png" },
@@ -250,11 +491,9 @@ describe("openclaw-clawchat inbound", () => {
     expect(call.mediaItems).toEqual([{ kind: "image", url: "https://cdn/x.png" }]);
   });
 
-  it("dispatches when sender is only on envelope.sender (real wire, no message.sender)", async () => {
+  it("dispatches with canonical envelope.sender shape", async () => {
     const ingest = vi.fn().mockResolvedValue(undefined);
     const env = buildSendEnvelope({ text: "hello" });
-    // Real chat-sdk envelopes carry sender on the envelope, not inside the message.
-    delete (env.payload.message as unknown as { sender?: unknown }).sender;
     await dispatchOpenclawClawlingInbound({
       envelope: env,
       cfg: {} as never,
@@ -266,7 +505,19 @@ describe("openclaw-clawchat inbound", () => {
     const call = ingest.mock.calls[0]![0];
     expect(call.senderId).toBe("user-1");
     expect(call.senderNickName).toBe("User One");
-    expect(call.peer).toEqual({ kind: "direct", id: "user-1" });
+    expect(call.peer).toEqual({ kind: "direct", id: "chat-1" });
+  });
+
+  it("skips business events without required chat_id", async () => {
+    const ingest = vi.fn().mockResolvedValue(undefined);
+    await dispatchOpenclawClawlingInbound({
+      envelope: buildSendEnvelope({ omitChatId: true }),
+      cfg: {} as never,
+      runtime: {} as never,
+      account: baseAccount(),
+      ingest,
+    });
+    expect(ingest).not.toHaveBeenCalled();
   });
 
   it("ingest receives mediaItems = [] when body has only text", async () => {