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

package/src/inbound.ts

@@ -1,11 +1,10 @@
 import {
   EVENT,
   type ChatType,
-  type DownlinkMessageSendPayload,
   type Envelope,
-} from "@newbase-clawchat/sdk";
+} from "./protocol-types.ts";
 import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk/core";
-import type { ResolvedOpenclawClawlingAccount } from "./config.ts";
+import { effectiveGroupMode, type ResolvedOpenclawClawlingAccount } from "./config.ts";
 import type { MediaItem } from "./media-runtime.ts";
 import { extractMediaFragments, fragmentsToText } from "./message-mapper.ts";
 import { hasRenderableText, isInboundMessagePayload } from "./protocol.ts";
@@ -37,11 +36,11 @@ export interface IngestTurnParams {
   cfg: OpenClawConfig;
   runtime: PluginRuntime;
   account: ResolvedOpenclawClawlingAccount;
-  envelope: Envelope<DownlinkMessageSendPayload>;
+  envelope: Envelope<unknown>;
 }
 
 export interface DispatchInboundParams {
-  envelope: Envelope<DownlinkMessageSendPayload>;
+  envelope: Envelope<unknown>;
   cfg: OpenClawConfig;
   runtime: PluginRuntime;
   account: ResolvedOpenclawClawlingAccount;
@@ -49,111 +48,140 @@ export interface DispatchInboundParams {
   log?: { info?: (m: string) => void; error?: (m: string) => void };
 }
 
-const DEDUP_MAX = 256;
-const dedupSeen: string[] = [];
-const dedupSet = new Set<string>();
-
 type SenderLike = {
   id?: unknown;
   nick_name?: unknown;
-  sender_id?: unknown;
-  display_name?: unknown;
   type?: unknown;
 };
 
-function normalizeSender(sender: unknown): { id: string; nickName: string; type?: ChatType } | null {
+function normalizeSender(sender: unknown): { id: string; nickName: string } | null {
   if (!sender || typeof sender !== "object") return null;
   const s = sender as SenderLike;
-  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(): void {
-  dedupSeen.length = 0;
-  dedupSet.clear();
+function isStreamDonePayload(payload: unknown): payload is {
+  message_id: string;
+  fragments: Array<Record<string, unknown>>;
+} {
+  if (!payload || typeof payload !== "object") return false;
+  const p = payload as Record<string, unknown>;
+  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 as { status?: unknown }).status !== "done") return false;
+  }
+  return true;
 }
 
-function rememberAndCheck(messageId: string): boolean {
-  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);
-  }
-  return false;
+function requireChatId(envelope: Envelope<unknown>): string | null {
+  const chatId = (envelope as Envelope<unknown> & { chat_id?: unknown }).chat_id;
+  return typeof chatId === "string" && chatId.trim() ? chatId : null;
+}
+
+function extractMentionIds(fragments: Array<Record<string, unknown>>): string[] {
+  return fragments
+    .map((fragment) => fragment.kind === "mention" ? fragment.user_id : undefined)
+    .filter((userId): userId is string => typeof userId === "string" && userId.length > 0);
+}
+
+function normalizeMentionIds(mentions: unknown[]): string[] {
+  return mentions
+    .map((mention) => {
+      if (typeof mention === "string") return mention;
+      if (mention && typeof mention === "object") {
+        const userId = (mention as { user_id?: unknown }).user_id;
+        return typeof userId === "string" ? userId : undefined;
+      }
+      return undefined;
+    })
+    .filter((userId): userId is string => 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: {
-  mentions: string[];
-  senderType: "direct" | "group";
+  mentions: unknown[];
+  chatType: "direct" | "group";
   userId: string;
 }): boolean {
-  if (params.senderType === "direct") return true;
-  return params.mentions.includes(params.userId);
+  if (params.chatType === "direct") return true;
+  return normalizeMentionIds(params.mentions).includes(params.userId);
 }
 
 export async function dispatchOpenclawClawlingInbound(
   params: DispatchInboundParams,
 ): Promise<void> {
   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;
   }
-  const payload = envelope.payload;
-  const message = payload.message as unknown as {
+  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 as {
+    message_id: string;
+    message_mode?: string;
+    message?: unknown;
+    fragments?: Array<Record<string, unknown>>;
+  };
+  const message = (isMaterializedMessage
+    ? payload.message
+    : {
+        body: { fragments: payload.fragments ?? [] },
+        context: { mentions: extractMentionIds(payload.fragments ?? []), reply: null },
+      }) as {
     body: { fragments: Array<Record<string, unknown>> };
     context: {
-      mentions: string[];
+      mentions: unknown[];
       reply: {
         reply_to_msg_id: string;
         reply_preview: {
           id?: string;
           nick_name?: string;
-          sender_id?: string;
-          display_name?: string;
           fragments: Array<Record<string, unknown>>;
         };
       } | null;
     };
-    /** Legacy fallback: older fixtures carried sender inside payload.message. */
-    sender?: SenderLike;
   };
 
-  // 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 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 as Envelope<DownlinkMessageSendPayload> & {
-    to?: { type?: ChatType };
-  }).to;
-  const chatType: ChatType = envelope.chat_type ?? sender.type ?? legacyTo?.type ?? "direct";
+  const chatType: 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}`,
     );
@@ -165,27 +193,22 @@ export async function dispatchOpenclawClawlingInbound(
     );
     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 as never, {
-    mentionFallbackIds: message.context.mentions,
+    mentionFallbackIds: mentionIds,
   });
   const mediaItems = extractMediaFragments(message.body.fragments as never);
   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}`,
     );
@@ -193,26 +216,15 @@ export async function dispatchOpenclawClawlingInbound(
   }
 
   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}`,
+    `[${account.accountId}] openclaw-clawchat inbound event=${envelope.event} 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 as Envelope<DownlinkMessageSendPayload> & { chat_id?: string }).chat_id ??
-    sender.id;
   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 as never),
       }
     : undefined;