@newbase-clawchat/openclaw-clawchat 2026.4.29 → 2026.5.4

package/openclaw.plugin.json

@@ -3,12 +3,33 @@
   "channels": ["openclaw-clawchat"],
   "skills": ["./skills"],
   "activation": {
+    "onStartup": true,
     "onChannels": ["openclaw-clawchat"],
     "onCommands": ["clawchat-login"]
   },
+  "channelEnvVars": {
+    "openclaw-clawchat": [
+      "CLAWCHAT_TOKEN",
+      "CLAWCHAT_USER_ID",
+      "CLAWCHAT_REFRESH_TOKEN",
+      "CLAWCHAT_BASE_URL",
+      "CLAWCHAT_WEBSOCKET_URL"
+    ]
+  },
   "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.5.4",
   "description": "OpenClaw ClawChat channel plugin",
   "files": [
+    "dist",
     "index.ts",
     "src",
     "skills",
@@ -11,6 +12,14 @@
   ],
   "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:agent": "bash .e2e/run-install-clawchat-plugin-agent-e2e.sh",
+    "test:e2e:install-clawchat-plugin:agent:smoke": "node --test .e2e/run-install-clawchat-plugin-agent-e2e.test.mjs",
+    "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 +30,12 @@
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
-    "openclaw": "^2026.3.23",
-    "typescript": "^5.4.0"
+    "openclaw": "2026.5.4",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.5"
   },
   "peerDependencies": {
-    "openclaw": "^2026.3.23"
+    "openclaw": ">=2026.5.4"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -39,10 +49,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.5.4"
     }
   }
 }

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 add for first-time CLI activation. 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 add command with the invite code:
+
+```bash
+openclaw channels add --channel openclaw-clawchat --token "$CLAWCHAT_INVITE_CODE"
+```
+5. `channels add --token` is the first-time CLI activation path; the token argument is the ClawChat invite code on this setup path.
+6. Use `openclaw channels login --channel openclaw-clawchat` only to refresh credentials later after the channel already exists.
+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 login --channel openclaw-clawchat
+openclaw channels status --probe
 ```
-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:
+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 channel add/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 add --channel openclaw-clawchat --token "$CLAWCHAT_INVITE_CODE"` 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` or falling back to channel add.

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.test.ts

@@ -28,9 +28,12 @@ describe("openclaw-clawchat plugin", () => {
     expect(
       validate!({ cfg: {}, accountId: "default", input: { code: "  " } }),
     ).toMatch(/invite code is required/i);
+    expect(
+      validate!({ cfg: {}, accountId: "default", input: { token: "  " } }),
+    ).toMatch(/invite code is required/i);
   });
 
-  it("setup.validateInput passes when code is present", () => {
+  it("setup.validateInput passes when code or token is present", () => {
     const validate = openclawClawlingPlugin.setup?.validateInput as (args: {
       cfg: unknown;
       accountId: string;
@@ -39,6 +42,9 @@ describe("openclaw-clawchat plugin", () => {
     expect(
       validate({ cfg: {}, accountId: "default", input: { code: "INV-XXXX" } }),
     ).toBeNull();
+    expect(
+      validate({ cfg: {}, accountId: "default", input: { token: "INV-XXXX" } }),
+    ).toBeNull();
   });
 
   it("setup.applyAccountConfig marks the channel enabled without touching credentials", () => {

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,
@@ -48,18 +50,24 @@ const configAdapter = createTopLevelChannelConfigAdapter<ResolvedOpenclawClawlin
  * 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`.
+ * Setup takes an invite code from `code` or from OpenClaw's generic
+ * `channels add --token` input. URL + token + userId come from the login flow
+ * which is triggered automatically in `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,
   validateInput: ({ input }: { cfg: unknown; accountId: string; input: ChannelSetupInput }) => {
-    if (!input.code?.trim()) {
+    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;
@@ -94,7 +102,12 @@ const setupAdapter = {
     runtime: { log: (message: string) => void };
     previousCfg: OpenClawConfig;
   }) => {
-    const code = input.code?.trim();
+    const code =
+      typeof input.code === "string" && input.code.trim()
+        ? input.code.trim()
+        : typeof input.token === "string"
+          ? input.token.trim()
+          : "";
     if (!code) return;
     // Lazy-import the login runtime to keep @clack/prompts / readline /
     // config-runtime off the plugin's cold-start path. `readInviteCode`
@@ -105,6 +118,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 +193,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,11 +50,56 @@ 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);
   });
 
+  it("resolves credentials from ClawChat environment variables when config omits them", () => {
+    const account = resolveOpenclawClawlingAccount(
+      {},
+      {
+        CLAWCHAT_TOKEN: "env-token",
+        CLAWCHAT_USER_ID: "env-user",
+        CLAWCHAT_BASE_URL: "https://api.env.example",
+        CLAWCHAT_WEBSOCKET_URL: "wss://ws.env.example/ws",
+      },
+    );
+
+    expect(account.configured).toBe(true);
+    expect(account.token).toBe("env-token");
+    expect(account.userId).toBe("env-user");
+    expect(account.baseUrl).toBe("https://api.env.example");
+    expect(account.websocketUrl).toBe("wss://ws.env.example/ws");
+  });
+
+  it("prefers explicit channel config over ClawChat environment variables", () => {
+    const account = resolveOpenclawClawlingAccount(
+      {
+        channels: {
+          "openclaw-clawchat": {
+            token: "config-token",
+            userId: "config-user",
+            baseUrl: "https://api.config.example",
+            websocketUrl: "wss://ws.config.example/ws",
+          },
+        },
+      },
+      {
+        CLAWCHAT_TOKEN: "env-token",
+        CLAWCHAT_USER_ID: "env-user",
+        CLAWCHAT_BASE_URL: "https://api.env.example",
+        CLAWCHAT_WEBSOCKET_URL: "wss://ws.env.example/ws",
+      },
+    );
+
+    expect(account.token).toBe("config-token");
+    expect(account.userId).toBe("config-user");
+    expect(account.baseUrl).toBe("https://api.config.example");
+    expect(account.websocketUrl).toBe("wss://ws.config.example/ws");
+  });
+
   it("falls back to static replyMode for unknown values", () => {
     const cfg = {
       channels: {