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

package/dist/src/channel.setup.js

@@ -0,0 +1,120 @@
+import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState, } from "openclaw/plugin-sdk/status-helpers";
+import { CHANNEL_ID, listOpenclawClawlingAccountIds, openclawClawlingConfigSchema, resolveOpenclawClawlingAccount, } from "./config.js";
+const configAdapter = createTopLevelChannelConfigAdapter({
+    sectionKey: CHANNEL_ID,
+    resolveAccount: (cfg) => resolveOpenclawClawlingAccount(cfg),
+    listAccountIds: () => listOpenclawClawlingAccountIds(),
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    deleteMode: "clear-fields",
+    clearBaseFields: [
+        "websocketUrl",
+        "baseUrl",
+        "token",
+        "userId",
+        "replyMode",
+        "forwardThinking",
+        "forwardToolCalls",
+        "richInteractions",
+        "enabled",
+    ],
+    resolveAllowFrom: (account) => account.allowFrom,
+    formatAllowFrom: () => [],
+});
+/**
+ * Invite-code setup adapter used by OpenClaw setup surfaces.
+ *
+ * `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 = {
+    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    validateInput: ({ input }) => {
+        const inviteCode = typeof input.code === "string" && input.code.trim()
+            ? input.code.trim()
+            : typeof input.token === "string"
+                ? input.token.trim()
+                : "";
+        if (!inviteCode) {
+            return "ClawChat invite code is required.";
+        }
+        return null;
+    },
+    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()
+            ? input.code.trim()
+            : typeof input.token === "string"
+                ? input.token.trim()
+                : "";
+        if (!code) {
+            runtime.log("[default] openclaw-clawchat setup afterAccountConfigWritten skipped: empty invite code");
+            return;
+        }
+        const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
+        await runOpenclawClawlingLogin({
+            cfg,
+            accountId: null,
+            runtime: { log: (message) => runtime.log(message) },
+            readInviteCode: async () => code,
+            mutateConfigFile: mutateConfigFile,
+        });
+        runtime.log("[default] openclaw-clawchat setup afterAccountConfigWritten completed");
+    },
+};
+export const openclawClawlingSetupPlugin = {
+    id: CHANNEL_ID,
+    meta: {
+        id: CHANNEL_ID,
+        label: "Clawling Chat",
+        selectionLabel: "Clawling Chat",
+        docsPath: "/channels/openclaw-clawchat",
+        docsLabel: "openclaw-clawchat",
+        blurb: "ClawChat Protocol v2 over WebSocket.",
+        order: 110,
+    },
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: true,
+        reactions: false,
+        threads: false,
+        polls: false,
+        blockStreaming: true,
+    },
+    configSchema: {
+        schema: openclawClawlingConfigSchema,
+    },
+    config: {
+        ...configAdapter,
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+        }),
+    },
+    setup: setupAdapter,
+    status: createComputedAccountStatusAdapter({
+        defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, {
+            connected: false,
+            lastInboundAt: null,
+            lastOutboundAt: null,
+        }),
+        resolveAccountSnapshot: ({ account }) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            extra: {
+                websocketUrl: account.websocketUrl || null,
+                baseUrl: account.baseUrl || null,
+                userId: account.userId || null,
+            },
+        }),
+    }),
+};

package/dist/src/client.js

@@ -1,20 +1,17 @@
-import { createWSClient, } from "@newbase-clawchat/sdk";
+import { createClawChatClient } from "./ws-client.js";
 export function createOpenclawClawlingClient(account, overrides = {}) {
-    // Only forward a finite `maxRetries` to the SDK — the SDK's own default
-    // is already unbounded, so omitting the field keeps that behavior. This
-    // avoids forcing the SDK to special-case `Infinity`.
-    const maxRetries = account.reconnect.maxRetries;
-    const reconnect = {
-        enabled: true,
-        initialDelay: account.reconnect.initialDelay,
-        maxDelay: account.reconnect.maxDelay,
-        jitterRatio: account.reconnect.jitterRatio,
-        ...(Number.isFinite(maxRetries) ? { maxRetries } : {}),
-    };
-    const options = {
+    const client = createClawChatClient({
         url: account.websocketUrl,
         token: account.token,
-        reconnect,
+        deviceId: account.userId,
+        ...(overrides.transport ? { transport: overrides.transport } : {}),
+        reconnect: {
+            enabled: true,
+            initialDelay: account.reconnect.initialDelay,
+            maxDelay: account.reconnect.maxDelay,
+            jitterRatio: account.reconnect.jitterRatio,
+            maxRetries: account.reconnect.maxRetries,
+        },
         heartbeat: {
             enabled: true,
             interval: account.heartbeat.interval,
@@ -24,13 +21,17 @@ export function createOpenclawClawlingClient(account, overrides = {}) {
             timeout: account.ack.timeout,
             autoResendOnTimeout: account.ack.autoResendOnTimeout,
         },
-        // Buffer outbound sends during the tiny reconnect window so an inbound
-        // message isn't silently dropped while the socket is flapping.
-        queueWhileReconnecting: true,
-        ...(overrides.transport ? { transport: overrides.transport } : {}),
-        ...(overrides.logger ? { logger: overrides.logger } : {}),
-    };
-    return createWSClient(options);
+    });
+    if (overrides.wsLifecycle?.onConnectFrameSent) {
+        const sendRawEnvelope = client.sendRawEnvelope.bind(client);
+        client.sendRawEnvelope = (env) => {
+            sendRawEnvelope(env);
+            if (env.event === "connect") {
+                overrides.wsLifecycle?.onConnectFrameSent?.(env);
+            }
+        };
+    }
+    return client;
 }
 function normalizeRouting(params) {
     if (params.routing)
@@ -41,24 +42,26 @@ function normalizeRouting(params) {
     throw new Error("openclaw-clawchat streaming emit requires routing");
 }
 /**
- * Emit a raw v2 envelope directly over the transport so we can carry top-level
- * `chat_id` routing without SDK-injected `to` metadata.
+ * Emit a raw v2 envelope through the local client so stream helpers carry
+ * top-level `chat_id` routing without legacy `to` metadata.
  */
-function emitEnvelope(client, event, payload, routing) {
-    const inner = client;
-    if (!inner.opts?.transport) {
-        inner.emitRaw?.(event, payload, { to: { id: routing.chatId, type: routing.chatType } });
+function emitEnvelope(client, event, payload, routing, options = {}) {
+    if (!options.forceRawTransport) {
+        client.emitRaw(event, payload, { chat_id: routing.chatId });
         return;
     }
+    if (typeof client.nextTraceId !== "function" || typeof client.sendRawEnvelope !== "function") {
+        throw new Error("openclaw-clawchat streaming emit requires local raw transport");
+    }
     const env = {
         version: "2",
         event,
-        trace_id: inner.opts.traceIdFactory(),
+        trace_id: client.nextTraceId(),
         emitted_at: Date.now(),
         chat_id: routing.chatId,
         payload,
     };
-    inner.opts.transport.send(JSON.stringify(env));
+    client.sendRawEnvelope(env);
 }
 /**
  * Emit a minimal `message.created` envelope to open a streaming message.
@@ -126,10 +129,8 @@ export function emitStreamDone(client, params) {
  * the same `payload.message_id` as the preceding `message.created` /
  * `message.add` / `message.done` frames.
  *
- * The SDK's high-level `client.replyMessage()` disallows `payload.message_id`
- * on outbound replies (the server normally assigns one via ack); for the
- * streaming-finalize use case the backend expects the correlated id, so we
- * bypass the SDK validator and write directly to the transport.
+ * Final stream replies include the correlated `payload.message_id`, so they
+ * use the local raw-envelope API instead of any higher-level ackable send.
  */
 export function emitFinalStreamReply(client, params) {
     const routing = normalizeRouting(params);
@@ -150,20 +151,15 @@ export function emitFinalStreamReply(client, params) {
                 },
             },
         },
-    }, routing);
+    }, routing, { forceRawTransport: true });
 }
 export function emitStreamFailed(client, params) {
     const now = Date.now();
     const routing = normalizeRouting(params);
-    const reason = params.reason ?? "unknown";
-    const reasonFragment = params.reason?.trim()
-        ? { fragments: [{ kind: "text", text: params.reason.trim() }] }
-        : {};
+    const reasonText = params.reason?.trim();
     emitEnvelope(client, "message.failed", {
         message_id: params.messageId,
-        sequence: params.sequence,
-        reason,
-        ...reasonFragment,
+        fragments: reasonText ? [{ kind: "text", text: reasonText }] : [],
         streaming: {
             status: "failed",
             sequence: params.sequence,

package/dist/src/config.js

@@ -2,6 +2,7 @@ import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 export const CHANNEL_ID = "openclaw-clawchat";
 export const CLAWCHAT_TOKEN_ENV = "CLAWCHAT_TOKEN";
 export const CLAWCHAT_USER_ID_ENV = "CLAWCHAT_USER_ID";
+export const CLAWCHAT_OWNER_USER_ID_ENV = "CLAWCHAT_OWNER_USER_ID";
 export const CLAWCHAT_REFRESH_TOKEN_ENV = "CLAWCHAT_REFRESH_TOKEN";
 export const CLAWCHAT_BASE_URL_ENV = "CLAWCHAT_BASE_URL";
 export const CLAWCHAT_WEBSOCKET_URL_ENV = "CLAWCHAT_WEBSOCKET_URL";
@@ -11,8 +12,8 @@ export const CLAWCHAT_WEBSOCKET_URL_ENV = "CLAWCHAT_WEBSOCKET_URL";
  * setup` call. Operators can still override either one via config.
  *
  */
-export const DEFAULT_BASE_URL = "http://company.newbaselab.com:10086";
-export const DEFAULT_WEBSOCKET_URL = "ws://company.newbaselab.com:10086/ws";
+export const DEFAULT_BASE_URL = "https://app.clawling.com";
+export const DEFAULT_WEBSOCKET_URL = "wss://app.clawling.com/ws";
 export const DEFAULT_STREAM = {
     flushIntervalMs: 250,
     minChunkChars: 40,
@@ -52,8 +53,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" },
@@ -97,39 +109,61 @@ export const openclawClawlingConfigSchema = {
 function isOpenclawClawchatToolAllowEntry(entry) {
     return entry === CHANNEL_ID || entry === "group:plugins";
 }
-function hasOpenclawClawchatToolAllow(cfg) {
-    const currentTools = (cfg.tools ?? {});
-    const currentAlsoAllow = Array.isArray(currentTools.alsoAllow) ? currentTools.alsoAllow : [];
-    const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow : [];
-    return [...currentAllow, ...currentAlsoAllow].some(isOpenclawClawchatToolAllowEntry);
-}
-function mergeToolPolicyEntryAllow(cfg, entry, isAlreadyCovered) {
+function mergeToolPolicyEntryAlsoAllow(cfg, entry, isAlreadyCovered) {
     const currentTools = (cfg.tools ?? {});
     const currentAlsoAllow = Array.isArray(currentTools.alsoAllow)
         ? 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 } : {}),
             },
         };
     }
-    const alreadyAlsoAllowed = currentAlsoAllow.some(isAlreadyCovered);
     return {
         ...cfg,
         tools: {
             ...currentTools,
-            alsoAllow: alreadyAlsoAllowed ? currentAlsoAllow : [...currentAlsoAllow, entry],
+            alsoAllow: [...currentAlsoAllow, entry],
         },
     };
 }
 export function mergeOpenclawClawchatToolAllow(cfg) {
-    return mergeToolPolicyEntryAllow(cfg, CHANNEL_ID, isOpenclawClawchatToolAllowEntry);
+    return mergeToolPolicyEntryAlsoAllow(cfg, CHANNEL_ID, isOpenclawClawchatToolAllowEntry);
+}
+function readRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function mergeOpenclawClawchatRuntimePluginActivation(cfg) {
+    const currentPlugins = readRecord(cfg.plugins);
+    const currentEntries = readRecord(currentPlugins.entries);
+    const currentEntry = readRecord(currentEntries[CHANNEL_ID]);
+    const currentAllow = Array.isArray(currentPlugins.allow) ? currentPlugins.allow.slice() : [];
+    const nextPlugins = {
+        ...currentPlugins,
+        entries: {
+            ...currentEntries,
+            [CHANNEL_ID]: {
+                ...currentEntry,
+                enabled: true,
+            },
+        },
+    };
+    if (!currentAllow.includes(CHANNEL_ID)) {
+        nextPlugins.allow = [...currentAllow, CHANNEL_ID];
+    }
+    return {
+        ...cfg,
+        plugins: nextPlugins,
+    };
 }
 function readChannelSection(cfg) {
     const channels = (cfg.channels ?? {});
@@ -146,7 +180,27 @@ function readReplyMode(value) {
     return value === "stream" ? "stream" : "static";
 }
 function readGroupMode(value) {
-    return value === "all" ? "all" : "mention";
+    return value === "mention" ? "mention" : "all";
+}
+function readGroups(value) {
+    const rawGroups = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    const groups = {};
+    for (const [chatId, rawGroup] of Object.entries(rawGroups)) {
+        if (!chatId)
+            continue;
+        const group = rawGroup && typeof rawGroup === "object" && !Array.isArray(rawGroup)
+            ? rawGroup
+            : {};
+        groups[chatId] = { groupMode: readGroupMode(group.groupMode) };
+    }
+    return groups;
+}
+export function effectiveGroupMode(account, chatId) {
+    return account.groups[chatId]?.groupMode
+        ?? account.groups["*"]?.groupMode
+        ?? account.groupMode;
 }
 function readStream(raw) {
     const s = raw && typeof raw === "object" ? raw : {};
@@ -194,9 +248,11 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
         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 = typeof channel.forwardToolCalls === "boolean" ? channel.forwardToolCalls : false;
     const richInteractions = typeof channel.richInteractions === "boolean" ? channel.richInteractions : false;
@@ -204,13 +260,15 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
         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/dist/src/inbound.js

@@ -1,72 +1,100 @@
-import { EVENT, } from "@newbase-clawchat/sdk";
+import { EVENT, } from "./protocol-types.js";
+import { effectiveGroupMode } from "./config.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;
     const s = sender;
-    const id = typeof s.id === "string" ? s.id : typeof s.sender_id === "string" ? s.sender_id : "";
+    const id = typeof s.id === "string" ? s.id : "";
     if (!id)
         return null;
-    const type = s.type === "group" || s.type === "direct" ? s.type : undefined;
-    const nickName = typeof s.nick_name === "string"
-        ? s.nick_name
-        : typeof s.display_name === "string"
-            ? s.display_name
-            : id;
-    return { id, nickName, ...(type ? { type } : {}) };
+    const nickName = typeof s.nick_name === "string" ? s.nick_name : id;
+    return { id, nickName };
 }
-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);
+function isStreamDonePayload(payload) {
+    if (!payload || typeof payload !== "object")
+        return false;
+    const p = payload;
+    if (typeof p.message_id !== "string" || p.message_id.length === 0)
+        return false;
+    if (!Array.isArray(p.fragments))
+        return false;
+    if (p.streaming !== undefined && p.streaming !== null) {
+        if (typeof p.streaming !== "object")
+            return false;
+        if (p.streaming.status !== "done")
+            return false;
     }
-    return false;
+    return true;
+}
+function requireChatId(envelope) {
+    const chatId = envelope.chat_id;
+    return typeof chatId === "string" && chatId.trim() ? chatId : null;
+}
+function extractMentionIds(fragments) {
+    return fragments
+        .map((fragment) => fragment.kind === "mention" ? fragment.user_id : undefined)
+        .filter((userId) => typeof userId === "string" && userId.length > 0);
+}
+function normalizeMentionIds(mentions) {
+    return mentions
+        .map((mention) => {
+        if (typeof mention === "string")
+            return mention;
+        if (mention && typeof mention === "object") {
+            const userId = mention.user_id;
+            return typeof userId === "string" ? userId : undefined;
+        }
+        return undefined;
+    })
+        .filter((userId) => typeof userId === "string" && userId.length > 0);
 }
 /**
- * Exported for direct unit testing. Group-sender messages currently never
- * reach this function (filtered in dispatchOpenclawClawlingInbound), but the
- * `mentions` branch is exercised by tests now so the group-enable change is
- * a one-line filter removal later.
+ * Exported for direct unit testing. Direct chats always count as addressed;
+ * group chats require a mention unless config opts into all group messages.
  */
 export function detectMention(params) {
-    if (params.senderType === "direct")
+    if (params.chatType === "direct")
         return true;
-    return params.mentions.includes(params.userId);
+    return normalizeMentionIds(params.mentions).includes(params.userId);
 }
 export async function dispatchOpenclawClawlingInbound(params) {
     const { envelope, account, log } = params;
-    if (!isInboundMessagePayload(envelope.payload)) {
+    const isMaterializedMessage = envelope.event === EVENT.MESSAGE_SEND || envelope.event === EVENT.MESSAGE_REPLY;
+    const isStreamDone = envelope.event === "message.done";
+    if (!isMaterializedMessage && !isStreamDone) {
+        log?.info?.(`[${account.accountId}] openclaw-clawchat skip non-business event=${envelope.event} trace=${envelope.trace_id}`);
+        return;
+    }
+    if (isMaterializedMessage && !isInboundMessagePayload(envelope.payload)) {
         log?.info?.(`[${account.accountId}] openclaw-clawchat skip: invalid payload trace=${envelope.trace_id}`);
         return;
     }
+    if (isStreamDone && !isStreamDonePayload(envelope.payload)) {
+        log?.info?.(`[${account.accountId}] openclaw-clawchat skip: invalid stream payload trace=${envelope.trace_id}`);
+        return;
+    }
+    const chatId = requireChatId(envelope);
+    if (!chatId) {
+        log?.info?.(`[${account.accountId}] openclaw-clawchat skip: missing chat_id trace=${envelope.trace_id}`);
+        return;
+    }
     const payload = envelope.payload;
-    const message = payload.message;
-    // v2 envelopes carry sender on the envelope (RoutingSender); the legacy
-    // message.sender shape is accepted as a fallback for older fixtures.
-    const sender = normalizeSender(envelope.sender ?? message.sender);
+    const message = (isMaterializedMessage
+        ? payload.message
+        : {
+            body: { fragments: payload.fragments ?? [] },
+            context: { mentions: extractMentionIds(payload.fragments ?? []), reply: null },
+        });
+    const sender = normalizeSender(envelope.sender);
     if (!sender) {
         log?.info?.(`[${account.accountId}] openclaw-clawchat skip: missing sender trace=${envelope.trace_id}`);
         return;
     }
-    // `chat_type` is on the envelope in the new protocol. Default to "direct"
-    // if the server didn't include it (defensive; shouldn't happen in practice).
-    const legacyTo = envelope.to;
-    const chatType = envelope.chat_type ?? sender.type ?? legacyTo?.type ?? "direct";
+    const chatType = envelope.chat_type === "group" ? "group" : "direct";
     const isGroup = chatType === "group";
-    if (payload.message_mode !== "normal") {
+    if (isMaterializedMessage && payload.message_mode !== "normal") {
         log?.info?.(`[${account.accountId}] openclaw-clawchat skip non-normal mode=${payload.message_mode}`);
         return;
     }
@@ -74,41 +102,31 @@ 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 mentionIds = normalizeMentionIds(message.context.mentions);
     const rawBody = fragmentsToText(message.body.fragments, {
-        mentionFallbackIds: message.context.mentions,
+        mentionFallbackIds: mentionIds,
     });
     const mediaItems = extractMediaFragments(message.body.fragments);
     const wasMentioned = detectMention({
-        mentions: message.context.mentions,
-        senderType: chatType,
+        mentions: mentionIds,
+        chatType,
         userId: account.userId,
     });
     // Group trigger policy: in "mention" mode we only handle group messages
     // that @-mention us; "all" listens open and processes every group msg.
     // Direct chats are unaffected (detectMention returns true).
-    if (isGroup && account.groupMode === "mention" && !wasMentioned) {
+    const groupMode = isGroup ? effectiveGroupMode(account, chatId) : account.groupMode;
+    if (isGroup && groupMode === "mention" && !wasMentioned) {
         log?.info?.(`[${account.accountId}] openclaw-clawchat skip group (no mention) msg=${payload.message_id}`);
         return;
     }
-    log?.info?.(`[${account.accountId}] openclaw-clawchat inbound event=${envelope.event === EVENT.MESSAGE_REPLY ? "reply" : "send"} msg=${payload.message_id} from=${sender.id} text_len=${rawBody.length} mentioned=${wasMentioned}`);
-    // New protocol: `chat_id` is the routing primary; `to` is deprecated.
-    // Fall back to sender.id if neither is present (defensive).
-    const chatId = envelope.chat_id ??
-        sender.id;
+    log?.info?.(`[${account.accountId}] openclaw-clawchat inbound event=${envelope.event} msg=${payload.message_id} from=${sender.id} text_len=${rawBody.length} mentioned=${wasMentioned}`);
     const replyCtx = message.context.reply
         ? {
             replyToMessageId: message.context.reply.reply_to_msg_id,
             replyPreviewChatId: chatId,
-            replyPreviewSenderId: message.context.reply.reply_preview.id ??
-                message.context.reply.reply_preview.sender_id ??
-                "",
-            replyPreviewNickName: message.context.reply.reply_preview.nick_name ??
-                message.context.reply.reply_preview.display_name ??
-                "",
+            replyPreviewSenderId: message.context.reply.reply_preview.id ?? "",
+            replyPreviewNickName: message.context.reply.reply_preview.nick_name ?? "",
             replyPreviewText: fragmentsToText(message.context.reply.reply_preview.fragments),
         }
         : undefined;