@newbase-clawchat/openclaw-clawchat 2026.4.24 → 2026.4.29

package/src/channel.test.ts

@@ -17,20 +17,20 @@ describe("openclaw-clawchat plugin", () => {
     expect(openclawClawlingPlugin.capabilities.media).toBe(true);
   });
 
-  it("setup.validateInput requires --code", () => {
+  it("setup.validateInput requires an invite code", () => {
     const validate = openclawClawlingPlugin.setup?.validateInput as
       | ((args: { cfg: unknown; accountId: string; input: Record<string, unknown> }) => string | null)
       | undefined;
     expect(validate).toBeDefined();
     expect(validate!({ cfg: {}, accountId: "default", input: {} })).toMatch(
-      /--code \(invite code/,
+      /invite code is required/i,
     );
     expect(
       validate!({ cfg: {}, accountId: "default", input: { code: "  " } }),
-    ).toMatch(/--code \(invite code/);
+    ).toMatch(/invite code is required/i);
   });
 
-  it("setup.validateInput passes when --code is present", () => {
+  it("setup.validateInput passes when code is present", () => {
     const validate = openclawClawlingPlugin.setup?.validateInput as (args: {
       cfg: unknown;
       accountId: string;
@@ -62,17 +62,52 @@ describe("openclaw-clawchat plugin", () => {
     expect(section.baseUrl).toBeUndefined();
   });
 
+  it("setup.applyAccountConfig allows openclaw-clawchat plugin tools without replacing policy", () => {
+    const apply = openclawClawlingPlugin.setup?.applyAccountConfig as (args: {
+      cfg: unknown;
+      accountId: string;
+      input: Record<string, unknown>;
+    }) => Record<string, unknown>;
+    const next = apply({
+      cfg: {
+        tools: {
+          profile: "coding",
+          allow: [],
+          deny: ["exec"],
+          alsoAllow: ["browser"],
+        },
+      },
+      accountId: "default",
+      input: { code: "INV-XXXX" },
+    }) as { tools: Record<string, unknown> };
+
+    expect(next.tools.profile).toBe("coding");
+    expect(next.tools.allow).toEqual([]);
+    expect(next.tools.deny).toEqual(["exec"]);
+    expect(next.tools.alsoAllow).toEqual(["browser", "openclaw-clawchat"]);
+  });
+
   it("publishes clawchat-specific agentPrompt hints", () => {
     const hints = openclawClawlingPlugin.agentPrompt?.messageToolHints?.({
       cfg: {} as never,
       accountId: "default",
     });
-    expect(Array.isArray(hints) && hints.length).toBeGreaterThan(0);
-    expect(hints!.some((h) => /ClawChat/.test(h))).toBe(true);
-    expect(hints!.some((h) => /update.*profile|profile.*bio/i.test(h))).toBe(true);
-    expect(hints!.some((h) => /update.*avatar|profile picture|clawchat_upload_avatar/i.test(h))).toBe(
-      true,
-    );
+    expect(hints).toEqual([
+      "To send an image or file to the current chat, use the message tool with action='send' and set 'media' to a local file path or a remote URL.",
+      "When the user asks you to find an image from the web, find a suitable HTTPS image URL and send it using the message tool with 'media' set to that URL — do NOT download the image first.",
+      "For configured ClawChat account profile, user profile, friends, avatar, or standalone media upload/share-link workflows, use `clawchat-account-tools` for tool-selection details.",
+      "For ClawChat account avatar changes using a local image, call `clawchat_upload_avatar_image` first, then `clawchat_update_account_profile` with `avatar_url`.",
+      "- Targeting: omit `target` to reply here; for a different chat use `target=\"cc:{chat_id}\"` for direct or `target=\"cc:group:{chat_id}\"` for group.",
+      "- ClawChat supports image / file / audio / video media alongside text.",
+    ]);
+    const joined = hints!.join("\n");
+    expect(joined).not.toMatch(/clawchat_get_account_profile/);
+    expect(joined).not.toMatch(/clawchat_get_user_profile/);
+    expect(joined).not.toMatch(/clawchat_list_account_friends/);
+    expect(joined).not.toMatch(/clawchat_upload_media_file/);
+    expect(joined).not.toMatch(/stream mode/i);
+    expect(joined).not.toMatch(/clawchat:/);
+    expect(joined).not.toMatch(/specify 'to'/);
   });
 
   it("normalizes openclaw-clawchat targets for host resolution", () => {

package/src/channel.ts

@@ -14,6 +14,7 @@ import {
 import {
   CHANNEL_ID,
   listOpenclawClawlingAccountIds,
+  mergeOpenclawClawchatToolAllow,
   openclawClawlingConfigSchema,
   resolveOpenclawClawlingAccount,
   type ResolvedOpenclawClawlingAccount,
@@ -42,13 +43,14 @@ const configAdapter = createTopLevelChannelConfigAdapter<ResolvedOpenclawClawlin
 });
 
 /**
- * `openclaw channels setup --channel openclaw-clawchat` adapter.
+ * Invite-code setup adapter used by OpenClaw setup surfaces that already have
+ * a concrete plugin instance. This plugin does not advertise catalog-driven
+ * one-shot setup metadata because current hosts do not discover channels from
+ * `plugins.load.paths`.
  *
  * Setup takes exactly ONE input: `code` (an invite code). URL + token +
  * userId come from the login flow which is triggered automatically in
- * `afterAccountConfigWritten`:
- *
- *   openclaw channels setup --channel openclaw-clawchat --code INV-XXXX
+ * `afterAccountConfigWritten`.
  *
  * `applyAccountConfig` itself only marks the section `enabled: true`;
  * credentials are written by `runOpenclawClawlingLogin` which calls `writeConfigFile`
@@ -58,7 +60,7 @@ const setupAdapter = {
   resolveAccountId: () => DEFAULT_ACCOUNT_ID,
   validateInput: ({ input }: { cfg: unknown; accountId: string; input: ChannelSetupInput }) => {
     if (!input.code?.trim()) {
-      return "Clawling Chat setup requires --code (invite code from your admin).";
+      return "ClawChat invite code is required.";
     }
     return null;
   },
@@ -73,13 +75,13 @@ const setupAdapter = {
     // `afterAccountConfigWritten` → `runOpenclawClawlingLogin`.
     const channels = (cfg.channels ?? {}) as Record<string, unknown>;
     const current = (channels[CHANNEL_ID] ?? {}) as Record<string, unknown>;
-    return {
+    return mergeOpenclawClawchatToolAllow({
       ...cfg,
       channels: {
         ...channels,
         [CHANNEL_ID]: { ...current, enabled: true },
       },
-    };
+    });
   },
   afterAccountConfigWritten: async ({
     cfg,
@@ -196,13 +198,12 @@ export const openclawClawlingPlugin: ChannelPlugin<ResolvedOpenclawClawlingAccou
       },
       agentPrompt: {
         messageToolHints: () => [
-          "To send an image or file to the current user, use the message tool with action='send' and set 'media' to a local file path or a remote URL. You do not need to specify 'to' — the current conversation recipient is used automatically.",
-          "When the user asks you to find an image from the web, use a web search or browser tool to find a suitable image URL, then send it using the message tool with 'media' set to that HTTPS image URL — do NOT download the image first.",
-          "When the user asks you to update your profile, nickname, bio, self-introduction, or personal introduction, use `clawchat_update_my_profile` with the relevant fields (`nickname`, `bio`, and/or `avatar_url`).",
-          "When the user asks you to change or update your avatar/profile picture using a local image, first use `clawchat_upload_avatar` to get the avatar URL, then call `clawchat_update_my_profile` with `avatar_url`.",
-          "- ClawChat targeting: omit `target` to reply to the current chat (auto-inferred). To send to a specific chat, use `cc:{chat_id}` (direct, default) or `cc:group:{chat_id}` (group). `clawchat:` is accepted as a synonym of `cc:`.",
-          "- ClawChat supports media fragments (image / file / audio / video) alongside text in the same message.",
-          "- ClawChat stream mode emits `message.created` → progressive `message.add` deltas → `message.done`, followed by a consolidated `message.reply` with the merged text.",
+          "To send an image or file to the current chat, use the message tool with action='send' and set 'media' to a local file path or a remote URL.",
+          "When the user asks you to find an image from the web, find a suitable HTTPS image URL and send it using the message tool with 'media' set to that URL — do NOT download the image first.",
+          "For configured ClawChat account profile, user profile, friends, avatar, or standalone media upload/share-link workflows, use `clawchat-account-tools` for tool-selection details.",
+          "For ClawChat account avatar changes using a local image, call `clawchat_upload_avatar_image` first, then `clawchat_update_account_profile` with `avatar_url`.",
+          "- Targeting: omit `target` to reply here; for a different chat use `target=\"cc:{chat_id}\"` for direct or `target=\"cc:group:{chat_id}\"` for group.",
+          "- ClawChat supports image / file / audio / video media alongside text.",
         ],
       },
       messaging: {

package/src/client.test.ts

@@ -91,7 +91,8 @@ describe("openclaw-clawchat client", () => {
     expect(transport.sent).toHaveLength(1);
     const env = JSON.parse(transport.sent[0]!);
     expect(env.event).toBe("message.created");
-    expect(env.to).toEqual({ id: "user-1", type: "direct" });
+    expect(env.chat_id).toBe("user-1");
+    expect(env.chat_type).toBe("direct");
     // Payload is intentionally minimal: just message_id, no message body /
     // context / sender / streaming metadata.
     expect(env.payload).toEqual({ message_id: "msg-1" });

package/src/client.ts

@@ -64,6 +64,17 @@ export interface EnvelopeRouting {
   chatType: ChatType;
 }
 
+function normalizeRouting(params: {
+  routing?: EnvelopeRouting;
+  to?: { id?: string; type?: ChatType };
+}): EnvelopeRouting {
+  if (params.routing) return params.routing;
+  if (params.to?.id) {
+    return { chatId: params.to.id, chatType: params.to.type ?? "direct" };
+  }
+  throw new Error("openclaw-clawchat streaming emit requires routing");
+}
+
 /**
  * Emit a raw v2 envelope directly over the transport so we can carry
  * `chat_id` + `chat_type` at envelope root (the new protocol). The SDK's
@@ -78,11 +89,16 @@ function emitEnvelope(
   routing: EnvelopeRouting,
 ): void {
   const inner = client as unknown as {
-    opts: {
+    opts?: {
       transport: { send: (data: string) => void };
       traceIdFactory: () => string;
     };
+    emitRaw?: (event: string, payload: object, routing?: { to?: { id: string; type: ChatType } }) => void;
   };
+  if (!inner.opts?.transport) {
+    inner.emitRaw?.(event, payload, { to: { id: routing.chatId, type: routing.chatType } });
+    return;
+  }
   const env = {
     version: "2" as const,
     event,
@@ -107,14 +123,16 @@ export function emitStreamCreated(
   client: ClawlingChatClient,
   params: {
     messageId: string;
-    routing: EnvelopeRouting;
+    routing?: EnvelopeRouting;
+    to?: { id: string; type: ChatType };
   },
 ): void {
+  const routing = normalizeRouting(params);
   emitEnvelope(
     client,
     "message.created",
     { message_id: params.messageId },
-    params.routing,
+    routing,
   );
 }
 
@@ -130,7 +148,8 @@ export function emitStreamAdd(
   client: ClawlingChatClient,
   params: {
     messageId: string;
-    routing: EnvelopeRouting;
+    routing?: EnvelopeRouting;
+    to?: { id: string; type: ChatType };
     sequence: number;
     /** Running cumulative text after this delta is applied. */
     fullText: string;
@@ -139,6 +158,7 @@ export function emitStreamAdd(
   },
 ): void {
   const now = Date.now();
+  const routing = normalizeRouting(params);
   emitEnvelope(
     client,
     "message.add",
@@ -158,7 +178,7 @@ export function emitStreamAdd(
       },
       added_at: now,
     },
-    params.routing,
+    routing,
   );
 }
 
@@ -171,12 +191,14 @@ export function emitStreamDone(
   client: ClawlingChatClient,
   params: {
     messageId: string;
-    routing: EnvelopeRouting;
+    routing?: EnvelopeRouting;
+    to?: { id: string; type: ChatType };
     finalSequence: number;
     finalText: string;
   },
 ): void {
   const now = Date.now();
+  const routing = normalizeRouting(params);
   emitEnvelope(
     client,
     "message.done",
@@ -192,7 +214,7 @@ export function emitStreamDone(
       },
       completed_at: now,
     },
-    params.routing,
+    routing,
   );
 }
 
@@ -211,7 +233,8 @@ export function emitFinalStreamReply(
   params: {
     /** The streaming message_id — must equal the id used on created/add/done. */
     messageId: string;
-    routing: EnvelopeRouting;
+    routing?: EnvelopeRouting;
+    to?: { id: string; type: ChatType };
     /** The user message this stream is a reply to (usually the inbound turn). */
     replyTo: {
       msgId: string;
@@ -223,6 +246,7 @@ export function emitFinalStreamReply(
     mentions?: string[];
   },
 ): void {
+  const routing = normalizeRouting(params);
   emitEnvelope(
     client,
     "message.reply",
@@ -244,7 +268,7 @@ export function emitFinalStreamReply(
         },
       },
     },
-    params.routing,
+    routing,
   );
 }
 
@@ -252,12 +276,14 @@ export function emitStreamFailed(
   client: ClawlingChatClient,
   params: {
     messageId: string;
-    routing: EnvelopeRouting;
+    routing?: EnvelopeRouting;
+    to?: { id: string; type: ChatType };
     sequence: number;
     reason?: string;
   },
 ): void {
   const now = Date.now();
+  const routing = normalizeRouting(params);
   emitEnvelope(
     client,
     "message.failed",
@@ -274,6 +300,6 @@ export function emitStreamFailed(
       },
       failed_at: now,
     },
-    params.routing,
+    routing,
   );
 }

package/src/commands.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it, vi } from "vitest";
+import { registerOpenclawClawlingCommands } from "./commands.ts";
+
+const loginRuntime = vi.hoisted(() => ({
+  runOpenclawClawlingLogin: vi.fn(),
+}));
+
+vi.mock("./login.runtime.ts", () => loginRuntime);
+
+describe("registerOpenclawClawlingCommands", () => {
+  it("registers a distinct slash login command that passes the invite code to login", async () => {
+    loginRuntime.runOpenclawClawlingLogin.mockResolvedValue(undefined);
+    const commands: Array<{ name: string; acceptsArgs?: boolean; handler: (ctx: unknown) => Promise<{ text: string }> }> = [];
+    const api = {
+      registerCommand: (command: (typeof commands)[number]) => commands.push(command),
+    } as never;
+
+    registerOpenclawClawlingCommands(api);
+
+    expect(commands.map((command) => command.name)).toEqual(["clawchat-login"]);
+    expect(commands[0]?.acceptsArgs).toBe(true);
+
+    const result = await commands[0]!.handler({
+      args: "A1B2C3",
+      config: { channels: { "openclaw-clawchat": { websocketUrl: "wss://w" } } },
+    });
+
+    expect(loginRuntime.runOpenclawClawlingLogin).toHaveBeenCalledTimes(1);
+    const params = loginRuntime.runOpenclawClawlingLogin.mock.calls[0]?.[0];
+    await expect(params.readInviteCode()).resolves.toBe("A1B2C3");
+    expect(result.text).toMatch(/activated successfully/i);
+  });
+});

package/src/commands.ts

@@ -0,0 +1,37 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+function extractInviteCode(value: unknown): string {
+  const raw = typeof value === "string" ? value.trim() : "";
+  return raw.match(/\b[A-Z0-9]{6}\b/u)?.[0] ?? "";
+}
+
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+export function registerOpenclawClawlingCommands(api: Pick<OpenClawPluginApi, "registerCommand" | "logger">): void {
+  api.registerCommand({
+    name: "clawchat-login",
+    description: "Activate ClawChat with an invite code, e.g. /clawchat-login A1B2C3.",
+    acceptsArgs: true,
+    requireAuth: true,
+    async handler(ctx) {
+      const code = extractInviteCode(ctx.args ?? ctx.commandBody);
+      if (!code) {
+        return { text: "ClawChat invite code is required. Usage: /clawchat-login A1B2C3" };
+      }
+      try {
+        const { runOpenclawClawlingLogin } = await import("./login.runtime.ts");
+        await runOpenclawClawlingLogin({
+          cfg: ctx.config,
+          accountId: ctx.accountId ?? null,
+          runtime: { log: (message: string) => api.logger?.info?.(message) },
+          readInviteCode: async () => code,
+        });
+        return { text: "✅ ClawChat activated successfully." };
+      } catch (err) {
+        return { text: `❌ ${errorMessage(err)}` };
+      }
+    },
+  });
+}

package/src/config.test.ts

@@ -2,7 +2,10 @@ import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 import { describe, expect, it } from "vitest";
 import {
   CHANNEL_ID,
+  DEFAULT_BASE_URL,
+  DEFAULT_WEBSOCKET_URL,
   DEFAULT_STREAM,
+  mergeOpenclawClawchatToolAllow,
   resolveOpenclawClawlingAccount,
   listOpenclawClawlingAccountIds,
 } from "./config.ts";
@@ -80,19 +83,21 @@ describe("openclaw-clawchat config", () => {
   });
 
   it("falls back to the built-in DEFAULT_BASE_URL when unset", async () => {
-    const { DEFAULT_BASE_URL } = await import("./config.ts");
     const account = resolveOpenclawClawlingAccount({});
     expect(account.baseUrl).toBe(DEFAULT_BASE_URL);
   });
 
   it("falls back to the built-in DEFAULT_WEBSOCKET_URL when unset", async () => {
-    const { DEFAULT_WEBSOCKET_URL } = await import("./config.ts");
     const account = resolveOpenclawClawlingAccount({});
     expect(account.websocketUrl).toBe(DEFAULT_WEBSOCKET_URL);
   });
 
+  it("uses the production ClawChat service as the built-in fallback endpoint", () => {
+    expect(DEFAULT_BASE_URL).toBe("http://company.newbaselab.com:10086");
+    expect(DEFAULT_WEBSOCKET_URL).toBe("ws://company.newbaselab.com:10086/ws");
+  });
+
   it("does NOT include baseUrl in the configured predicate (channel still works without it)", async () => {
-    const { DEFAULT_BASE_URL } = await import("./config.ts");
     const cfg = {
       channels: {
         "openclaw-clawchat": {
@@ -107,4 +112,33 @@ describe("openclaw-clawchat config", () => {
     expect(account.configured).toBe(true);
     expect(account.baseUrl).toBe(DEFAULT_BASE_URL);
   });
+
+  it("adds the plugin to tools.allow when an explicit allowlist is already in use", () => {
+    const cfg = mergeOpenclawClawchatToolAllow({
+      tools: {
+        allow: ["bash"],
+        deny: ["exec"],
+      },
+    } as never) as { tools: Record<string, unknown> };
+
+    expect(cfg.tools.allow).toEqual(["bash", "openclaw-clawchat"]);
+    expect(cfg.tools.deny).toEqual(["exec"]);
+    expect(cfg.tools.alsoAllow).toBeUndefined();
+  });
+
+  it("adds the plugin to tools.alsoAllow when no explicit allowlist is in use", () => {
+    const cfg = mergeOpenclawClawchatToolAllow({
+      tools: {
+        profile: "coding",
+        allow: [],
+      },
+    } as never) as { tools: Record<string, unknown> };
+
+    expect(cfg.tools).toEqual({
+      profile: "coding",
+      allow: [],
+      alsoAllow: ["openclaw-clawchat"],
+    });
+  });
+
 });

package/src/config.ts

@@ -8,10 +8,9 @@ export const CHANNEL_ID = "openclaw-clawchat" as const;
  * login` works out of the box without requiring a prior `openclaw channel
  * setup` call. Operators can still override either one via config.
  *
- * TODO: replace these placeholders with the production URLs.
  */
-export const DEFAULT_BASE_URL = "https://api.clawling.chat" as const;
-export const DEFAULT_WEBSOCKET_URL = "wss://api.clawling.chat/ws" as const;
+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 type ReplyMode = "static" | "stream";
 
@@ -150,6 +149,57 @@ export const openclawClawlingConfigSchema = {
   },
 } as const;
 
+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(
+  cfg: OpenClawConfig,
+  entry: string,
+  isAlreadyCovered: (value: unknown) => boolean,
+): OpenClawConfig {
+  const currentTools = ((cfg as { tools?: Record<string, unknown> }).tools ?? {}) as Record<
+    string,
+    unknown
+  >;
+  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) {
+    return {
+      ...cfg,
+      tools: {
+        ...currentTools,
+        allow: alreadyAllowed ? currentAllow : [...currentAllow, entry],
+      },
+    } as OpenClawConfig;
+  }
+  const alreadyAlsoAllowed = currentAlsoAllow.some(isAlreadyCovered);
+  return {
+    ...cfg,
+    tools: {
+      ...currentTools,
+      alsoAllow: alreadyAlsoAllowed ? currentAlsoAllow : [...currentAlsoAllow, entry],
+    },
+  } as OpenClawConfig;
+}
+
+export function mergeOpenclawClawchatToolAllow(cfg: OpenClawConfig): OpenClawConfig {
+  return mergeToolPolicyEntryAllow(cfg, CHANNEL_ID, isOpenclawClawchatToolAllowEntry);
+}
+
 export type ResolvedOpenclawClawlingAccount = {
   accountId: string;
   name: string;
@@ -274,4 +324,3 @@ export function resolveOpenclawClawlingAccount(
 export function listOpenclawClawlingAccountIds(): string[] {
   return [DEFAULT_ACCOUNT_ID];
 }
-

package/src/inbound.test.ts

@@ -93,7 +93,7 @@ describe("openclaw-clawchat inbound", () => {
       envelope: buildSendEnvelope({ text: "hello there" }),
       cfg: {},
       runtime: {} as never,
-      account: baseAccount(),
+      account: baseAccount({ groupMode: "mention" }),
       ingest,
     });
     expect(ingest).toHaveBeenCalledTimes(1);
@@ -110,7 +110,7 @@ describe("openclaw-clawchat inbound", () => {
       envelope: buildSendEnvelope({ senderType: "direct" }),
       cfg: {},
       runtime: {} as never,
-      account: baseAccount(),
+      account: baseAccount({ groupMode: "mention" }),
       ingest,
     });
     const { wasMentioned } = ingest.mock.calls[0]![0];
@@ -145,7 +145,7 @@ describe("openclaw-clawchat inbound", () => {
       envelope: buildSendEnvelope({ senderType: "group" }),
       cfg: {},
       runtime: {} as never,
-      account: baseAccount(),
+      account: baseAccount({ groupMode: "mention" }),
       ingest,
     });
     expect(ingest).not.toHaveBeenCalled();
@@ -184,7 +184,7 @@ describe("openclaw-clawchat inbound", () => {
     expect(replyCtx).toEqual({
       replyToMessageId: "m-orig",
       replyPreviewSenderId: "user-2",
-      replyPreviewDisplayName: "User Two",
+      replyPreviewNickName: "User Two",
       replyPreviewText: "original text",
     });
   });
@@ -262,7 +262,7 @@ describe("openclaw-clawchat inbound", () => {
     expect(ingest).toHaveBeenCalledTimes(1);
     const call = ingest.mock.calls[0]![0];
     expect(call.senderId).toBe("user-1");
-    expect(call.senderDisplayName).toBe("User One");
+    expect(call.senderNickName).toBe("User One");
     expect(call.peer).toEqual({ kind: "direct", id: "user-1" });
   });
 

package/src/inbound.ts

@@ -52,6 +52,29 @@ 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 {
+  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 : "";
+  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 } : {}) };
+}
+
 export function _resetDedupForTest(): void {
   dedupSeen.length = 0;
   dedupSet.clear();
@@ -101,20 +124,22 @@ export async function dispatchOpenclawClawlingInbound(
       reply: {
         reply_to_msg_id: string;
         reply_preview: {
-          id: string;
-          nick_name: string;
+          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?: { id: string; nick_name: string };
+    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 = envelope.sender ?? message.sender;
-  if (!sender || typeof sender.id !== "string" || !sender.id) {
+  const sender = normalizeSender(envelope.sender ?? message.sender);
+  if (!sender) {
     log?.info?.(
       `[${account.accountId}] openclaw-clawchat skip: missing sender trace=${envelope.trace_id}`,
     );
@@ -122,7 +147,10 @@ export async function dispatchOpenclawClawlingInbound(
   }
   // `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 chatType: ChatType = envelope.chat_type ?? "direct";
+  const legacyTo = (envelope as Envelope<DownlinkMessageSendPayload> & {
+    to?: { type?: ChatType };
+  }).to;
+  const chatType: ChatType = envelope.chat_type ?? sender.type ?? legacyTo?.type ?? "direct";
   const isGroup = chatType === "group";
   if (payload.message_mode !== "normal") {
     log?.info?.(
@@ -166,8 +194,14 @@ export async function dispatchOpenclawClawlingInbound(
   const replyCtx = message.context.reply
     ? {
         replyToMessageId: message.context.reply.reply_to_msg_id,
-        replyPreviewSenderId: message.context.reply.reply_preview.id,
-        replyPreviewNickName: message.context.reply.reply_preview.nick_name,
+        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 ??
+          "",
         replyPreviewText: fragmentsToText(message.context.reply.reply_preview.fragments as never),
       }
     : undefined;
@@ -187,7 +221,7 @@ export async function dispatchOpenclawClawlingInbound(
     accountId: account.accountId,
     peer: { kind: isGroup ? "group" : "direct", id: chatId },
     senderId: sender.id,
-    senderNickName: sender.nick_name,
+    senderNickName: sender.nickName,
     rawBody,
     messageId: payload.message_id,
     traceId: envelope.trace_id,