@newbase-clawchat/openclaw-clawchat 2026.4.29 → 2026.4.30

package/openclaw.plugin.json

@@ -3,12 +3,24 @@
   "channels": ["openclaw-clawchat"],
   "skills": ["./skills"],
   "activation": {
+    "onStartup": true,
     "onChannels": ["openclaw-clawchat"],
     "onCommands": ["clawchat-login"]
   },
   "commandAliases": [
     { "name": "clawchat-login", "kind": "runtime-slash" }
   ],
+  "contracts": {
+    "tools": [
+      "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"
+    ]
+  },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@newbase-clawchat/openclaw-clawchat",
-  "version": "2026.4.29",
+  "version": "2026.4.30",
   "description": "OpenClaw ClawChat channel plugin",
   "files": [
+    "dist",
     "index.ts",
     "src",
     "skills",
@@ -11,6 +12,12 @@
   ],
   "type": "module",
   "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest",
+    "test:e2e:install-clawchat-plugin": "bash .e2e/run-install-clawchat-plugin-e2e.sh",
+    "test:e2e:install-clawchat-plugin:smoke": "node --test .e2e/run-install-clawchat-plugin-e2e.test.mjs",
+    "dev:openclaw-source": "test -d tmp/openclaw || git clone --depth=1 https://github.com/openclaw/openclaw.git tmp/openclaw",
+    "prepack": "npm run build",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run typecheck",
     "release": "npm run prepublishOnly && npm publish"
@@ -21,11 +28,12 @@
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
-    "openclaw": "^2026.3.23",
-    "typescript": "^5.4.0"
+    "openclaw": "2026.4.29",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.5"
   },
   "peerDependencies": {
-    "openclaw": "^2026.3.23"
+    "openclaw": "^2026.4.29"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -39,10 +47,22 @@
     "extensions": [
       "./index.ts"
     ],
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ],
+    "channel": {
+      "id": "openclaw-clawchat",
+      "label": "Clawling Chat",
+      "selectionLabel": "Clawling Chat",
+      "docsPath": "/channels/openclaw-clawchat",
+      "docsLabel": "openclaw-clawchat",
+      "blurb": "Clawling Protocol v2 over WebSocket (chat-sdk).",
+      "order": 110
+    },
     "install": {
       "npmSpec": "@newbase-clawchat/openclaw-clawchat",
       "defaultChoice": "npm",
-      "minHostVersion": ">=2026.3.23"
+      "minHostVersion": ">=2026.4.29"
     }
   }
 }

package/skills/clawchat-activate/SKILL.md

@@ -6,24 +6,33 @@ description: |
 
 # ClawChat Activation
 
-Activation must execute the OpenClaw channel login command. Do not edit config files manually, do not call tools for activation, and do not try to execute slash commands from this skill.
+Activation should use the `clawchat_activate` tool when that tool is available. The tool runs the same invite-code login runtime as OpenClaw channel login and persists credentials into `channels.openclaw-clawchat`.
+
+If the tool is not available because the Gateway has not loaded this plugin yet, fall back to OpenClaw channel login. Do not edit config files manually and do not try to execute slash commands from this skill.
 
 ## Workflow
 
 1. Check whether the user is trying to activate or log in ClawChat.
-2. Execute the channel login command:
+2. If `clawchat_activate` is available and the invite code is known, call it with the invite code.
+3. If the invite code is not known, ask the user for it before calling `clawchat_activate`.
+4. If `clawchat_activate` is not available, execute the channel login command:
 
 ```bash
 openclaw channels login --channel openclaw-clawchat
 ```
-3. Do not append the invite code to the command; `openclaw channels login` has no code argument.
-4. When the command prompts for an invite code, provide the user's invite code if one was already present, otherwise ask the user for it.
-5. After channel login succeeds, execute the Gateway restart command:
+5. Do not append the invite code to the command; `openclaw channels login` has no code argument.
+6. When the command prompts for an invite code, provide the user's invite code if one was already present, otherwise ask the user for it.
+7. After activation succeeds, rely on OpenClaw's `channels.*` config hot reload when the plugin is already loaded. Verify channel status if available:
+
+```bash
+openclaw channels status --probe
+```
+8. Execute the Gateway restart command only when the plugin was just installed/updated, the tool was unavailable because the running Gateway had not loaded the plugin, config reload is disabled, or the probe does not become healthy:
 
 ```bash
 openclaw gateway restart
 ```
-6. Tell the user activation completes after channel login and Gateway restart both succeed.
+9. Tell the user activation completes after login succeeds and either config hot reload/probe succeeds or Gateway restart succeeds.
 
 ## Trigger Examples
 
@@ -33,6 +42,6 @@ openclaw gateway restart
 - `绑定 ClawChat，邀请码 A1B2C3`
 - `激活 ClawChat`
 
-Do not ask the user to enter a bare ClawChat command. If activation is requested, execute `openclaw channels login --channel openclaw-clawchat` yourself, then execute `openclaw gateway restart`.
+Do not ask the user to enter a bare ClawChat command. If activation is requested and `clawchat_activate` is available, call that tool yourself. If the tool is unavailable, execute `openclaw channels login --channel openclaw-clawchat` yourself, then probe channel status and restart the Gateway only when needed.
 
-When the user asks to activate ClawChat without including a code, run channel login and ask for the invite code when the command needs it.
+When the user asks to activate ClawChat without including a code, ask for the invite code before calling `clawchat_activate`; if falling back to channel login, provide the code when the command needs it.

package/src/buffered-stream.test.ts

@@ -53,6 +53,7 @@ describe("openBufferedStreamingSession", () => {
       maxBufferChars: 1000,
     });
     expect(typing).toEqual([["u1", true]]);
+    expect((client.typing as ReturnType<typeof vi.fn>).mock.calls).toEqual([["u1", true]]);
     expect(sent.map((s) => s.event)).toEqual(["message.created"]);
   });
 
@@ -101,6 +102,7 @@ describe("openBufferedStreamingSession", () => {
       [{ kind: "text", text: "Hello ", delta: "Hello " }],
       [{ kind: "text", text: "Hello world", delta: "world" }],
     ]);
+    expect(adds.map((a) => a.payload.sequence)).toEqual([0, 1]);
     expect(session.currentText).toBe("Hello world");
   });
 
@@ -125,6 +127,10 @@ describe("openBufferedStreamingSession", () => {
       ["u1", true],
       ["u1", false],
     ]);
+    expect((client.typing as ReturnType<typeof vi.fn>).mock.calls).toEqual([
+      ["u1", true],
+      ["u1", false],
+    ]);
   });
 
   it("done() is idempotent", async () => {
@@ -158,7 +164,11 @@ describe("openBufferedStreamingSession", () => {
     await session.fail("boom");
     const failed = sent.find((s) => s.event === "message.failed")!;
     expect(failed.payload.reason).toBe("boom");
+    expect(failed.payload.sequence).toBe(0);
+    expect(failed.payload).toHaveProperty("completed_at");
+    expect(failed.payload).not.toHaveProperty("failed_at");
     expect(typing.at(-1)).toEqual(["u1", false]);
+    expect((client.typing as ReturnType<typeof vi.fn>).mock.calls.at(-1)).toEqual(["u1", false]);
   });
 
   it("deduplicates a snapshot that is a substring of the buffered snapshot", async () => {

package/src/buffered-stream.ts

@@ -93,7 +93,7 @@ export function openBufferedStreamingSession(
   const routing = resolveRouting(options);
   const emitTyping = options.emitTyping !== false;
   if (emitTyping)
-    options.client.typing(routing.chatId, true, routing.chatType);
+    options.client.typing(routing.chatId, true);
   emitStreamCreated(options.client, {
     messageId: options.messageId,
     routing,
@@ -101,7 +101,7 @@ export function openBufferedStreamingSession(
 
   let bufferedSnapshot = "";
   let flushedSnapshot = "";
-  let sequence = 0;
+  let sequence = -1;
   let flushTimer: ReturnType<typeof setTimeout> | null = null;
   let pendingFlush: Promise<void> = Promise.resolve();
   let closed = false;
@@ -177,11 +177,11 @@ export function openBufferedStreamingSession(
     emitStreamDone(options.client, {
       messageId: options.messageId,
       routing,
-      finalSequence: sequence,
+      finalSequence: Math.max(sequence, 0),
       finalText: bufferedSnapshot,
     });
     if (emitTyping)
-      options.client.typing(routing.chatId, false, routing.chatType);
+      options.client.typing(routing.chatId, false);
   };
 
   const fail = async (reason?: string): Promise<void> => {
@@ -191,11 +191,11 @@ export function openBufferedStreamingSession(
     emitStreamFailed(options.client, {
       messageId: options.messageId,
       routing,
-      sequence: sequence + 1,
+      sequence: Math.max(sequence, 0),
       ...(reason !== undefined ? { reason } : {}),
     });
     if (emitTyping)
-      options.client.typing(routing.chatId, false, routing.chatType);
+      options.client.typing(routing.chatId, false);
   };
 
   return {

package/src/channel.outbound.test.ts

@@ -62,10 +62,10 @@ describe("openclaw-clawchat channel outbound", () => {
     expect(client.sendMessage).toHaveBeenCalledWith(
       expect.objectContaining({
         chat_id: "user-1",
-        chat_type: "direct",
         body: { fragments: [{ kind: "text", text: "hello" }] },
       }),
     );
+    expect(client.sendMessage.mock.calls[0][0]).not.toHaveProperty("chat_type");
     expect(result).toEqual({
       channel: "openclaw-clawchat",
       to: "cc:user-1",
@@ -121,7 +121,6 @@ describe("openclaw-clawchat channel outbound", () => {
     expect(client.sendMessage).toHaveBeenCalledWith(
       expect.objectContaining({
         chat_id: "room-1",
-        chat_type: "group",
         body: {
           fragments: [
             { kind: "text", text: "caption" },
@@ -130,6 +129,7 @@ describe("openclaw-clawchat channel outbound", () => {
         },
       }),
     );
+    expect(client.sendMessage.mock.calls[0][0]).not.toHaveProperty("chat_type");
     expect(result).toEqual({
       channel: "openclaw-clawchat",
       to: "cc:group:room-1",
@@ -199,7 +199,6 @@ describe("openclaw-clawchat channel outbound", () => {
     expect(client.sendMessage).toHaveBeenCalledWith(
       expect.objectContaining({
         chat_id: "room-1",
-        chat_type: "group",
         body: {
           fragments: [
             { kind: "text", text: "caption" },
@@ -208,6 +207,7 @@ describe("openclaw-clawchat channel outbound", () => {
         },
       }),
     );
+    expect(client.sendMessage.mock.calls[0][0]).not.toHaveProperty("chat_type");
     expect(result).toEqual({
       channel: "openclaw-clawchat",
       to: "cc:group:room-1",

package/src/channel.ts

@@ -19,8 +19,9 @@ import {
   resolveOpenclawClawlingAccount,
   type ResolvedOpenclawClawlingAccount,
 } from "./config.ts";
+import type { OpenclawClawchatMutateConfigFile } from "./login.runtime.ts";
 import { openclawClawlingOutbound } from "./outbound.ts";
-import { startOpenclawClawlingGateway } from "./runtime.ts";
+import { getOpenclawClawlingRuntime, startOpenclawClawlingGateway } from "./runtime.ts";
 
 const configAdapter = createTopLevelChannelConfigAdapter<ResolvedOpenclawClawlingAccount>({
   sectionKey: CHANNEL_ID,
@@ -36,6 +37,7 @@ const configAdapter = createTopLevelChannelConfigAdapter<ResolvedOpenclawClawlin
     "replyMode",
     "forwardThinking",
     "forwardToolCalls",
+    "richInteractions",
     "enabled",
   ],
   resolveAllowFrom: (account) => account.allowFrom,
@@ -53,8 +55,8 @@ const configAdapter = createTopLevelChannelConfigAdapter<ResolvedOpenclawClawlin
  * `afterAccountConfigWritten`.
  *
  * `applyAccountConfig` itself only marks the section `enabled: true`;
- * credentials are written by `runOpenclawClawlingLogin` which calls `writeConfigFile`
- * on its own after the `/v1/agents/connect` response lands.
+ * credentials are written by `runOpenclawClawlingLogin` via the runtime config
+ * mutator after the `/v1/agents/connect` response lands.
  */
 const setupAdapter = {
   resolveAccountId: () => DEFAULT_ACCOUNT_ID,
@@ -105,6 +107,9 @@ const setupAdapter = {
       accountId: null,
       runtime: { log: (message: string) => runtime.log(message) },
       readInviteCode: async () => code,
+      mutateConfigFile: (getOpenclawClawlingRuntime().config as unknown as {
+        mutateConfigFile: OpenclawClawchatMutateConfigFile;
+      }).mutateConfigFile,
     });
   },
 };
@@ -177,6 +182,9 @@ export const openclawClawlingPlugin: ChannelPlugin<ResolvedOpenclawClawlingAccou
             cfg,
             accountId: accountId ?? null,
             runtime: { log: (message: string) => runtime.log(message) },
+            mutateConfigFile: (getOpenclawClawlingRuntime().config as unknown as {
+              mutateConfigFile: OpenclawClawchatMutateConfigFile;
+            }).mutateConfigFile,
           });
         },
       },

package/src/client.test.ts

@@ -92,7 +92,8 @@ describe("openclaw-clawchat client", () => {
     const env = JSON.parse(transport.sent[0]!);
     expect(env.event).toBe("message.created");
     expect(env.chat_id).toBe("user-1");
-    expect(env.chat_type).toBe("direct");
+    expect(env).not.toHaveProperty("chat_type");
+    expect(env).not.toHaveProperty("sender");
     // Payload is intentionally minimal: just message_id, no message body /
     // context / sender / streaming metadata.
     expect(env.payload).toEqual({ message_id: "msg-1" });
@@ -118,6 +119,9 @@ describe("openclaw-clawchat client", () => {
     const env = JSON.parse(transport.sent[0]!);
     expect(env.event).toBe("message.add");
     expect(env.payload.sequence).toBe(3);
+    expect(env.chat_id).toBe("user-1");
+    expect(env).not.toHaveProperty("chat_type");
+    expect(env).not.toHaveProperty("sender");
     expect(env.payload.fragments).toEqual([
       { kind: "text", text: "Hello, wor", delta: "wor" },
     ]);
@@ -169,7 +173,10 @@ describe("openclaw-clawchat client", () => {
     expect(env.event).toBe("message.failed");
     expect(env.payload.message_id).toBe("msg-1");
     expect(env.payload.reason).toBe("upstream_error");
+    expect(env.payload.fragments).toEqual([{ kind: "text", text: "upstream_error" }]);
     expect(env.payload.streaming.status).toBe("failed");
+    expect(env.payload.streaming.completed_at).toBe(env.payload.completed_at);
+    expect(env.payload).not.toHaveProperty("failed_at");
     client.close();
   });
 });

package/src/client.ts

@@ -76,11 +76,8 @@ function normalizeRouting(params: {
 }
 
 /**
- * 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
- * `emitRaw` can't express `chat_type` and always writes `to`; we bypass it
- * entirely for the events we construct ourselves (streaming lifecycle +
- * message.reply finalize).
+ * Emit a raw v2 envelope directly over the transport so we can carry top-level
+ * `chat_id` routing without SDK-injected `to` metadata.
  */
 function emitEnvelope(
   client: ClawlingChatClient,
@@ -105,7 +102,6 @@ function emitEnvelope(
     trace_id: inner.opts.traceIdFactory(),
     emitted_at: Date.now(),
     chat_id: routing.chatId,
-    chat_type: routing.chatType,
     payload,
   };
   inner.opts.transport.send(JSON.stringify(env));
@@ -238,7 +234,7 @@ export function emitFinalStreamReply(
     /** The user message this stream is a reply to (usually the inbound turn). */
     replyTo: {
       msgId: string;
-      senderId: string;
+      previewId: string;
       nickName: string;
       fragments: Fragment[];
     };
@@ -260,7 +256,7 @@ export function emitFinalStreamReply(
           reply: {
             reply_to_msg_id: params.replyTo.msgId,
             reply_preview: {
-              id: params.replyTo.senderId,
+              id: params.replyTo.previewId,
               nick_name: params.replyTo.nickName,
               fragments: params.replyTo.fragments,
             },
@@ -284,13 +280,18 @@ export function emitStreamFailed(
 ): void {
   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() }] }
+    : {};
   emitEnvelope(
     client,
     "message.failed",
     {
       message_id: params.messageId,
       sequence: params.sequence,
-      reason: params.reason ?? "unknown",
+      reason,
+      ...reasonFragment,
       streaming: {
         status: "failed",
         sequence: params.sequence,
@@ -298,7 +299,7 @@ export function emitStreamFailed(
         started_at: null,
         completed_at: now,
       },
-      failed_at: now,
+      completed_at: now,
     },
     routing,
   );

package/src/commands.test.ts

@@ -13,6 +13,11 @@ describe("registerOpenclawClawlingCommands", () => {
     const commands: Array<{ name: string; acceptsArgs?: boolean; handler: (ctx: unknown) => Promise<{ text: string }> }> = [];
     const api = {
       registerCommand: (command: (typeof commands)[number]) => commands.push(command),
+      runtime: {
+        config: {
+          mutateConfigFile: vi.fn(),
+        },
+      },
     } as never;
 
     registerOpenclawClawlingCommands(api);
@@ -27,6 +32,7 @@ describe("registerOpenclawClawlingCommands", () => {
 
     expect(loginRuntime.runOpenclawClawlingLogin).toHaveBeenCalledTimes(1);
     const params = loginRuntime.runOpenclawClawlingLogin.mock.calls[0]?.[0];
+    expect(params.mutateConfigFile).toBe(api.runtime.config.mutateConfigFile);
     await expect(params.readInviteCode()).resolves.toBe("A1B2C3");
     expect(result.text).toMatch(/activated successfully/i);
   });

package/src/commands.ts

@@ -1,4 +1,5 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { OpenclawClawchatMutateConfigFile } from "./login.runtime.ts";
 
 function extractInviteCode(value: unknown): string {
   const raw = typeof value === "string" ? value.trim() : "";
@@ -9,7 +10,7 @@ function errorMessage(err: unknown): string {
   return err instanceof Error ? err.message : String(err);
 }
 
-export function registerOpenclawClawlingCommands(api: Pick<OpenClawPluginApi, "registerCommand" | "logger">): void {
+export function registerOpenclawClawlingCommands(api: Pick<OpenClawPluginApi, "registerCommand" | "logger" | "runtime">): void {
   api.registerCommand({
     name: "clawchat-login",
     description: "Activate ClawChat with an invite code, e.g. /clawchat-login A1B2C3.",
@@ -27,6 +28,9 @@ export function registerOpenclawClawlingCommands(api: Pick<OpenClawPluginApi, "r
           accountId: ctx.accountId ?? null,
           runtime: { log: (message: string) => api.logger?.info?.(message) },
           readInviteCode: async () => code,
+          mutateConfigFile: (api.runtime.config as unknown as {
+            mutateConfigFile: OpenclawClawchatMutateConfigFile;
+          }).mutateConfigFile,
         });
         return { text: "✅ ClawChat activated successfully." };
       } catch (err) {

package/src/config.test.ts

@@ -23,6 +23,7 @@ describe("openclaw-clawchat config", () => {
     expect(account.replyMode).toBe("static");
     expect(account.forwardThinking).toBe(true);
     expect(account.forwardToolCalls).toBe(false);
+    expect(account.richInteractions).toBe(false);
     expect(account.stream).toEqual(DEFAULT_STREAM);
   });
 
@@ -36,6 +37,7 @@ describe("openclaw-clawchat config", () => {
           replyMode: "stream",
           forwardThinking: false,
           forwardToolCalls: true,
+          richInteractions: true,
           stream: { flushIntervalMs: 500, minChunkChars: 50, maxBufferChars: 3000 },
         },
       },
@@ -48,6 +50,7 @@ describe("openclaw-clawchat config", () => {
     expect(account.replyMode).toBe("stream");
     expect(account.forwardThinking).toBe(false);
     expect(account.forwardToolCalls).toBe(true);
+    expect(account.richInteractions).toBe(true);
     expect(account.stream.flushIntervalMs).toBe(500);
     expect(account.stream.minChunkChars).toBe(50);
     expect(account.stream.maxBufferChars).toBe(3000);

package/src/config.ts

@@ -91,6 +91,8 @@ export type OpenclawClawlingConfig = {
   groupMode?: GroupMode;
   forwardThinking?: boolean;
   forwardToolCalls?: boolean;
+  /** Emit approval/action rich fragments instead of plain fallback text. */
+  richInteractions?: boolean;
   stream?: OpenclawClawlingStreamConfig;
   reconnect?: OpenclawClawlingReconnectConfig;
   heartbeat?: OpenclawClawlingHeartbeatConfig;
@@ -111,6 +113,7 @@ export const openclawClawlingConfigSchema = {
     groupMode: { type: "string", enum: ["mention", "all"] },
     forwardThinking: { type: "boolean" },
     forwardToolCalls: { type: "boolean" },
+    richInteractions: { type: "boolean" },
     stream: {
       type: "object",
       additionalProperties: false,
@@ -213,6 +216,7 @@ export type ResolvedOpenclawClawlingAccount = {
   groupMode: GroupMode;
   forwardThinking: boolean;
   forwardToolCalls: boolean;
+  richInteractions: boolean;
   allowFrom: string[];
   stream: Required<OpenclawClawlingStreamConfig>;
   reconnect: Required<OpenclawClawlingReconnectConfig>;
@@ -299,6 +303,8 @@ export function resolveOpenclawClawlingAccount(
     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;
 
   return {
     accountId: DEFAULT_ACCOUNT_ID,
@@ -313,6 +319,7 @@ export function resolveOpenclawClawlingAccount(
     groupMode,
     forwardThinking,
     forwardToolCalls,
+    richInteractions,
     allowFrom: [],
     stream: readStream(channel.stream),
     reconnect: readReconnect(channel.reconnect),

package/src/inbound.test.ts

@@ -41,6 +41,7 @@ function buildSendEnvelope(
     mentions: string[];
     reply: unknown;
     messageId: string;
+    chatId: string;
   }> = {},
 ): Envelope<DownlinkMessageSendPayload> {
   return {
@@ -48,6 +49,7 @@ function buildSendEnvelope(
     event: overrides.event ?? "message.send",
     trace_id: "trace-1",
     emitted_at: 1776162600000,
+    chat_id: overrides.chatId,
     to: { id: "agent-1", type: overrides.senderType ?? "direct" },
     sender: {
       sender_id: "user-1",
@@ -174,7 +176,7 @@ describe("openclaw-clawchat inbound", () => {
       },
     };
     await dispatchOpenclawClawlingInbound({
-      envelope: buildSendEnvelope({ event: "message.reply", reply: replyRef }),
+      envelope: buildSendEnvelope({ event: "message.reply", reply: replyRef, chatId: "chat-1" }),
       cfg: {},
       runtime: {} as never,
       account: baseAccount(),
@@ -183,6 +185,7 @@ describe("openclaw-clawchat inbound", () => {
     const { replyCtx } = ingest.mock.calls[0]![0];
     expect(replyCtx).toEqual({
       replyToMessageId: "m-orig",
+      replyPreviewChatId: "chat-1",
       replyPreviewSenderId: "user-2",
       replyPreviewNickName: "User Two",
       replyPreviewText: "original text",

package/src/inbound.ts

@@ -29,6 +29,7 @@ export interface IngestTurnParams {
   mediaItems: MediaItem[];
   replyCtx?: {
     replyToMessageId: string;
+    replyPreviewChatId: string;
     replyPreviewSenderId: string;
     replyPreviewNickName: string;
     replyPreviewText: string;
@@ -191,9 +192,19 @@ export async function dispatchOpenclawClawlingInbound(
     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 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 ??
@@ -206,16 +217,6 @@ export async function dispatchOpenclawClawlingInbound(
       }
     : undefined;
 
-  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 as Envelope<DownlinkMessageSendPayload> & { chat_id?: string }).chat_id ??
-    sender.id;
-
   await params.ingest({
     channel: "openclaw-clawchat",
     accountId: account.accountId,

package/src/login.runtime.test.ts

@@ -112,6 +112,42 @@ describe("runOpenclawClawlingLogin", () => {
     expect(log).toHaveBeenCalledWith(expect.stringContaining("login succeeded"));
   });
 
+  it("uses the runtime config mutator with auto reload intent for config writes", async () => {
+    const cfg = buildCfg({
+      baseUrl: "https://api.example.com",
+      websocketUrl: "wss://ws.example.com/v2/client",
+    });
+    const agentsConnect = vi.fn().mockResolvedValue({
+      agent: { user_id: "agent-123", nickname: "Bot" },
+      access_token: "access-tok",
+      refresh_token: "refresh-tok",
+    });
+    let mutatedCfg: OpenClawConfig | undefined;
+    const mutateConfigFile = vi.fn(async (params) => {
+      expect(params.afterWrite).toEqual({ mode: "auto" });
+      const draft = structuredClone(cfg) as OpenClawConfig;
+      await params.mutate(draft, { snapshot: {} as never, previousHash: "before" });
+      mutatedCfg = draft;
+      return { nextConfig: draft } as never;
+    });
+
+    await runOpenclawClawlingLogin({
+      cfg,
+      runtime: { log: vi.fn() },
+      readInviteCode: async () => "INV-ABC",
+      apiClientFactory: () => makeApiClient({ agentsConnect }),
+      mutateConfigFile,
+    });
+
+    expect(mutateConfigFile).toHaveBeenCalledTimes(1);
+    const section = (mutatedCfg!.channels as Record<string, Record<string, unknown>>)[
+      CHANNEL_ID
+    ]!;
+    expect(section.token).toBe("access-tok");
+    expect(section.refreshToken).toBe("refresh-tok");
+    expect(section.userId).toBe("agent-123");
+  });
+
   it("preserves other configured channels when persisting ClawChat credentials", async () => {
     const cfg = {
       channels: {