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

package/src/client.test.ts

@@ -1,12 +1,14 @@
-import { MockTransport } from "@newbase-clawchat/sdk";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
+import { MockTransport } from "./mock-transport.ts";
+import type { ClawlingChatClient } from "./ws-client.ts";
 import {
   createOpenclawClawlingClient,
   emitStreamCreated,
   emitStreamAdd,
   emitStreamDone,
   emitStreamFailed,
+  emitFinalStreamReply,
 } from "./client.ts";
 import type { ResolvedOpenclawClawlingAccount } from "./config.ts";
 
@@ -20,6 +22,7 @@ function baseAccount(): ResolvedOpenclawClawlingAccount {
     baseUrl: "",
     token: "t",
     userId: "agent-1",
+    ownerUserId: "owner-1",
     replyMode: "static",
     forwardThinking: true,
     forwardToolCalls: false,
@@ -37,11 +40,7 @@ function baseAccount(): ResolvedOpenclawClawlingAccount {
 }
 
 async function authenticate(transport: MockTransport) {
-  // Yield to allow MockTransport.connect's internal Promise.resolve() to fire
-  // onOpen (which transitions state: connecting -> challenging) before we send
-  // the challenge envelope.
   await Promise.resolve();
-  // Challenge from server
   transport.emitInbound(
     JSON.stringify({
       version: "2",
@@ -51,12 +50,14 @@ async function authenticate(transport: MockTransport) {
       payload: { nonce: "nonce-1" },
     }),
   );
-  // hello-ok
+  const connectFrame = transport.sent
+    .map((raw) => JSON.parse(raw))
+    .find((env) => env.event === "connect");
   transport.emitInbound(
     JSON.stringify({
       version: "2",
       event: "hello-ok",
-      trace_id: "t-hello",
+      trace_id: connectFrame.trace_id,
       emitted_at: Date.now(),
       payload: {},
     }),
@@ -74,6 +75,103 @@ describe("openclaw-clawchat client", () => {
     client.close();
   });
 
+  it("sends msghub connect payload without signature fields", async () => {
+    const transport = new MockTransport();
+    const client = createOpenclawClawlingClient(baseAccount(), { transport });
+    const p = client.connect();
+
+    await Promise.resolve();
+    transport.emitInbound(
+      JSON.stringify({
+        version: "2",
+        event: "connect.challenge",
+        trace_id: "challenge-1",
+        emitted_at: Date.now(),
+        payload: { nonce: "nonce-1" },
+      }),
+    );
+
+    const connectFrame = transport.sent
+      .map((raw) => JSON.parse(raw))
+      .find((env) => env.event === "connect");
+    expect(connectFrame.payload).toMatchObject({
+      token: "t",
+      nonce: "nonce-1",
+    });
+    expect(connectFrame.payload).not.toHaveProperty("sign");
+    expect(connectFrame.payload).not.toHaveProperty("signature");
+    expect(connectFrame.payload).not.toHaveProperty("client_id");
+    expect(connectFrame.payload).not.toHaveProperty("client_version");
+
+    transport.emitInbound(
+      JSON.stringify({
+        version: "2",
+        event: "hello-ok",
+        trace_id: connectFrame.trace_id,
+        emitted_at: Date.now(),
+        payload: {},
+      }),
+    );
+    await p;
+    client.close();
+  });
+
+  it("reports connect frames after the transport records them", async () => {
+    const transport = new MockTransport();
+    const onConnectFrameSent = vi.fn((env: { trace_id?: unknown }) => {
+      const sentConnect = transport.sent
+        .map((raw) => JSON.parse(raw))
+        .find((frame) => frame.event === "connect");
+      expect(sentConnect?.trace_id).toBe(env.trace_id);
+    });
+    const client = createOpenclawClawlingClient(baseAccount(), {
+      transport,
+      wsLifecycle: { onConnectFrameSent },
+    });
+
+    const connected = client.connect();
+    await authenticate(transport);
+    await connected;
+
+    expect(onConnectFrameSent).toHaveBeenCalledTimes(1);
+    client.close();
+  });
+
+  it("reports connect frames only after they are sent", async () => {
+    const transport = new MockTransport();
+    const onConnectFrameSent = vi.fn();
+    const originalSend = transport.send.bind(transport);
+    transport.send = vi.fn((wire: string) => {
+      const env = JSON.parse(wire);
+      if (env.event === "connect") throw new Error("send failed");
+      originalSend(wire);
+    });
+    const client = createOpenclawClawlingClient(baseAccount(), {
+      transport,
+      wsLifecycle: { onConnectFrameSent },
+    });
+
+    const connected = client.connect();
+    await Promise.resolve();
+    transport.emitInbound(
+      JSON.stringify({
+        version: "2",
+        event: "connect.challenge",
+        trace_id: "challenge-1",
+        emitted_at: Date.now(),
+        payload: { nonce: "nonce-1" },
+      }),
+    );
+
+    await expect(connected).rejects.toThrow(/send failed/);
+    expect(onConnectFrameSent).not.toHaveBeenCalled();
+  });
+
+  it("creates a local production transport when no override is supplied", () => {
+    const client = createOpenclawClawlingClient(baseAccount());
+    expect(client.transportState).toBe("closed");
+  });
+
   it("emitStreamCreated emits a minimal message.created envelope with just message_id", async () => {
     const transport = new MockTransport();
     const client = createOpenclawClawlingClient(baseAccount(), { transport });
@@ -85,7 +183,7 @@ describe("openclaw-clawchat client", () => {
     emitStreamCreated(client, {
       messageId: "msg-1",
       to: { id: "user-1", type: "direct" },
-      sender: { sender_id: "agent-1", type: "direct", display_name: "Clawling Assistant" },
+      sender: { id: "agent-1", type: "direct", nick_name: "Clawling Assistant" },
     });
 
     expect(transport.sent).toHaveLength(1);
@@ -100,6 +198,66 @@ describe("openclaw-clawchat client", () => {
     client.close();
   });
 
+  it("uses local emitRaw with chat_id routing for stream lifecycle frames", () => {
+    const transportSend = vi.fn();
+    const emitRaw = vi.fn();
+    const client = {
+      opts: {
+        transport: { send: transportSend },
+        traceIdFactory: () => "trace-raw",
+      },
+      emitRaw,
+    } as unknown as ClawlingChatClient;
+
+    emitStreamCreated(client, {
+      messageId: "msg-1",
+      routing: { chatId: "chat-1", chatType: "group" },
+    });
+
+    expect(emitRaw).toHaveBeenCalledWith(
+      "message.created",
+      { message_id: "msg-1" },
+      { chat_id: "chat-1" },
+    );
+    expect(transportSend).not.toHaveBeenCalled();
+  });
+
+  it("uses local emitRaw with chat_id routing when raw transport is unavailable", () => {
+    const emitRaw = vi.fn();
+    const client = { emitRaw } as unknown as ClawlingChatClient;
+
+    emitStreamCreated(client, {
+      messageId: "msg-1",
+      routing: { chatId: "chat-1", chatType: "direct" },
+    });
+
+    expect(emitRaw).toHaveBeenCalledWith(
+      "message.created",
+      { message_id: "msg-1" },
+      { chat_id: "chat-1" },
+    );
+  });
+
+  it("requires raw transport for final stream replies that carry a client message_id", () => {
+    const emitRaw = vi.fn();
+    const client = { emitRaw } as unknown as ClawlingChatClient;
+
+    expect(() =>
+      emitFinalStreamReply(client, {
+        messageId: "agent-stream-1",
+        routing: { chatId: "chat-1", chatType: "direct" },
+        replyTo: {
+          msgId: "user-msg-1",
+          previewId: "user-1",
+          nickName: "User 1",
+          fragments: [{ kind: "text", text: "hello" }],
+        },
+        body: { fragments: [{ kind: "text", text: "reply" }] },
+      }),
+    ).toThrow(/raw transport/);
+    expect(emitRaw).not.toHaveBeenCalled();
+  });
+
   it("emitStreamAdd emits message.add with fragments: [{ text: full, delta: new }]", async () => {
     const transport = new MockTransport();
     const client = createOpenclawClawlingClient(baseAccount(), { transport });
@@ -154,7 +312,7 @@ describe("openclaw-clawchat client", () => {
     client.close();
   });
 
-  it("emitStreamFailed emits message.failed with reason", async () => {
+  it("emitStreamFailed emits message.failed with StreamDonePayload shape", async () => {
     const transport = new MockTransport();
     const client = createOpenclawClawlingClient(baseAccount(), { transport });
     const p = client.connect();
@@ -172,11 +330,39 @@ describe("openclaw-clawchat client", () => {
     const env = JSON.parse(transport.sent[0]!);
     expect(env.event).toBe("message.failed");
     expect(env.payload.message_id).toBe("msg-1");
-    expect(env.payload.reason).toBe("upstream_error");
+    expect(env.payload).not.toHaveProperty("reason");
+    expect(env.payload).not.toHaveProperty("sequence");
     expect(env.payload.fragments).toEqual([{ kind: "text", text: "upstream_error" }]);
     expect(env.payload.streaming.status).toBe("failed");
+    expect(env.payload.streaming.sequence).toBe(4);
     expect(env.payload.streaming.completed_at).toBe(env.payload.completed_at);
     expect(env.payload).not.toHaveProperty("failed_at");
     client.close();
   });
+
+  it("emitStreamFailed emits empty fragments when reason is omitted", async () => {
+    const transport = new MockTransport();
+    const client = createOpenclawClawlingClient(baseAccount(), { transport });
+    const p = client.connect();
+    await authenticate(transport);
+    await p;
+    transport.sent.length = 0;
+
+    emitStreamFailed(client, {
+      messageId: "msg-1",
+      to: { id: "user-1", type: "direct" },
+      sequence: 4,
+    });
+
+    const env = JSON.parse(transport.sent[0]!);
+    expect(env.event).toBe("message.failed");
+    expect(env.payload).toMatchObject({
+      message_id: "msg-1",
+      fragments: [],
+      completed_at: expect.any(Number),
+    });
+    expect(env.payload).not.toHaveProperty("reason");
+    expect(env.payload).not.toHaveProperty("sequence");
+    client.close();
+  });
 });

package/src/client.ts

@@ -1,38 +1,36 @@
-import {
-  createWSClient,
-  type ClawlingChatClient,
-  type CreateWSClientOptions,
-  type Fragment,
-  type Transport,
-} from "@newbase-clawchat/sdk";
+import type { ChatType, Envelope, Fragment, Transport } from "./protocol-types.ts";
+import { createClawChatClient, type ClawlingChatClient } from "./ws-client.ts";
 import type { ResolvedOpenclawClawlingAccount } from "./config.ts";
 
+export type { ChatType } from "./protocol-types.ts";
+
 export interface CreateClientOverrides {
   /** Transport override — only intended for tests (e.g. MockTransport). */
   transport?: Transport;
-  logger?: CreateWSClientOptions["logger"];
+  wsLifecycle?: {
+    onConnectFrameSent?: (env: {
+      trace_id?: unknown;
+      payload?: { device_id?: unknown };
+    }) => void;
+  };
 }
 
 export function createOpenclawClawlingClient(
   account: ResolvedOpenclawClawlingAccount,
   overrides: CreateClientOverrides = {},
 ): ClawlingChatClient {
-  // 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: CreateWSClientOptions["reconnect"] = {
-    enabled: true,
-    initialDelay: account.reconnect.initialDelay,
-    maxDelay: account.reconnect.maxDelay,
-    jitterRatio: account.reconnect.jitterRatio,
-    ...(Number.isFinite(maxRetries) ? { maxRetries } : {}),
-  };
-
-  const options: CreateWSClientOptions = {
+  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,
@@ -42,20 +40,24 @@ export function createOpenclawClawlingClient(
       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: Envelope) => {
+      sendRawEnvelope(env);
+      if (env.event === "connect") {
+        overrides.wsLifecycle?.onConnectFrameSent?.(
+          env as { trace_id?: unknown; payload?: { device_id?: unknown } },
+        );
+      }
+    };
+  }
+  return client;
 }
 
-export type ChatType = "direct" | "group";
-
 export interface StreamSender {
   id: string;
-  type: ChatType;
+  type: "direct";
   nick_name: string;
 }
 
@@ -76,35 +78,32 @@ function normalizeRouting(params: {
 }
 
 /**
- * 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: ClawlingChatClient,
   event: string,
   payload: object,
   routing: EnvelopeRouting,
+  options: { forceRawTransport?: boolean } = {},
 ): void {
-  const inner = client as unknown as {
-    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 } });
+  if (!options.forceRawTransport) {
+    client.emitRaw(event, payload, { chat_id: routing.chatId });
     return;
   }
-  const env = {
+  if (typeof client.nextTraceId !== "function" || typeof client.sendRawEnvelope !== "function") {
+    throw new Error("openclaw-clawchat streaming emit requires local raw transport");
+  }
+  const env: Envelope = {
     version: "2" as const,
     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);
 }
 
 /**
@@ -219,10 +218,8 @@ export function emitStreamDone(
  * 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: ClawlingChatClient,
@@ -265,6 +262,7 @@ export function emitFinalStreamReply(
       },
     },
     routing,
+    { forceRawTransport: true },
   );
 }
 
@@ -280,18 +278,13 @@ 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() }] }
-    : {};
+  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/src/config.test.ts

@@ -5,6 +5,7 @@ import {
   DEFAULT_BASE_URL,
   DEFAULT_WEBSOCKET_URL,
   DEFAULT_STREAM,
+  effectiveGroupMode,
   mergeOpenclawClawchatToolAllow,
   resolveOpenclawClawlingAccount,
   listOpenclawClawlingAccountIds,
@@ -21,6 +22,7 @@ describe("openclaw-clawchat config", () => {
     expect(account.enabled).toBe(true);
     expect(account.configured).toBe(false);
     expect(account.replyMode).toBe("static");
+    expect(account.groupMode).toBe("all");
     expect(account.forwardThinking).toBe(true);
     expect(account.forwardToolCalls).toBe(false);
     expect(account.richInteractions).toBe(false);
@@ -34,6 +36,7 @@ describe("openclaw-clawchat config", () => {
           websocketUrl: "wss://chat.example.com/ws",
           token: "secret",
           userId: "agent-1",
+          ownerUserId: "owner-1",
           replyMode: "stream",
           forwardThinking: false,
           forwardToolCalls: true,
@@ -47,6 +50,7 @@ describe("openclaw-clawchat config", () => {
     expect(account.websocketUrl).toBe("wss://chat.example.com/ws");
     expect(account.token).toBe("secret");
     expect(account.userId).toBe("agent-1");
+    expect(account.ownerUserId).toBe("owner-1");
     expect(account.replyMode).toBe("stream");
     expect(account.forwardThinking).toBe(false);
     expect(account.forwardToolCalls).toBe(true);
@@ -62,6 +66,7 @@ describe("openclaw-clawchat config", () => {
       {
         CLAWCHAT_TOKEN: "env-token",
         CLAWCHAT_USER_ID: "env-user",
+        CLAWCHAT_OWNER_USER_ID: "env-owner",
         CLAWCHAT_BASE_URL: "https://api.env.example",
         CLAWCHAT_WEBSOCKET_URL: "wss://ws.env.example/ws",
       },
@@ -70,6 +75,7 @@ describe("openclaw-clawchat config", () => {
     expect(account.configured).toBe(true);
     expect(account.token).toBe("env-token");
     expect(account.userId).toBe("env-user");
+    expect(account.ownerUserId).toBe("env-owner");
     expect(account.baseUrl).toBe("https://api.env.example");
     expect(account.websocketUrl).toBe("wss://ws.env.example/ws");
   });
@@ -81,6 +87,7 @@ describe("openclaw-clawchat config", () => {
           "openclaw-clawchat": {
             token: "config-token",
             userId: "config-user",
+            ownerUserId: "config-owner",
             baseUrl: "https://api.config.example",
             websocketUrl: "wss://ws.config.example/ws",
           },
@@ -89,6 +96,7 @@ describe("openclaw-clawchat config", () => {
       {
         CLAWCHAT_TOKEN: "env-token",
         CLAWCHAT_USER_ID: "env-user",
+        CLAWCHAT_OWNER_USER_ID: "env-owner",
         CLAWCHAT_BASE_URL: "https://api.env.example",
         CLAWCHAT_WEBSOCKET_URL: "wss://ws.env.example/ws",
       },
@@ -96,6 +104,7 @@ describe("openclaw-clawchat config", () => {
 
     expect(account.token).toBe("config-token");
     expect(account.userId).toBe("config-user");
+    expect(account.ownerUserId).toBe("config-owner");
     expect(account.baseUrl).toBe("https://api.config.example");
     expect(account.websocketUrl).toBe("wss://ws.config.example/ws");
   });
@@ -103,13 +112,104 @@ describe("openclaw-clawchat config", () => {
   it("falls back to static replyMode for unknown values", () => {
     const cfg = {
       channels: {
-        "openclaw-clawchat": { websocketUrl: "w", token: "t", userId: "a", replyMode: "weird" },
+        "openclaw-clawchat": {
+          websocketUrl: "w",
+          token: "t",
+          userId: "a",
+          ownerUserId: "o",
+          replyMode: "weird",
+        },
       },
     };
     const account = resolveOpenclawClawlingAccount(cfg);
     expect(account.replyMode).toBe("static");
   });
 
+  it("preserves explicit mention groupMode", () => {
+    const cfg = {
+      channels: {
+        "openclaw-clawchat": {
+          websocketUrl: "w",
+          token: "t",
+          userId: "a",
+          ownerUserId: "o",
+          groupMode: "mention",
+        },
+      },
+    };
+    const account = resolveOpenclawClawlingAccount(cfg);
+    expect(account.groupMode).toBe("mention");
+  });
+
+  it("falls back to all groupMode for unknown values", () => {
+    const cfg = {
+      channels: {
+        "openclaw-clawchat": {
+          websocketUrl: "w",
+          token: "t",
+          userId: "a",
+          ownerUserId: "o",
+          groupMode: "weird",
+        },
+      },
+    };
+    const account = resolveOpenclawClawlingAccount(cfg);
+    expect(account.groupMode).toBe("all");
+  });
+
+  it("resolves per-group groupMode overrides", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "openclaw-clawchat": {
+          groups: {
+            "group-1": { groupMode: "mention" },
+            "*": { groupMode: "all" },
+          },
+        },
+      },
+    });
+
+    expect(account.groups).toEqual({
+      "group-1": { groupMode: "mention" },
+      "*": { groupMode: "all" },
+    });
+    expect(effectiveGroupMode(account, "group-1")).toBe("mention");
+    expect(effectiveGroupMode(account, "group-2")).toBe("all");
+  });
+
+  it("lets exact per-group groupMode win over wildcard and channel defaults", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "openclaw-clawchat": {
+          groupMode: "mention",
+          groups: {
+            "group-open": { groupMode: "all" },
+            "*": { groupMode: "mention" },
+          },
+        },
+      },
+    });
+
+    expect(effectiveGroupMode(account, "group-open")).toBe("all");
+    expect(effectiveGroupMode(account, "group-other")).toBe("mention");
+  });
+
+  it("normalizes invalid per-group groupMode values to all", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "openclaw-clawchat": {
+          groupMode: "mention",
+          groups: {
+            "group-weird": { groupMode: "weird" },
+          },
+        },
+      },
+    });
+
+    expect(account.groups["group-weird"]?.groupMode).toBe("all");
+    expect(effectiveGroupMode(account, "group-weird")).toBe("all");
+  });
+
   it("lists the default account id", () => {
     expect(listOpenclawClawlingAccountIds()).toEqual([DEFAULT_ACCOUNT_ID]);
   });
@@ -121,6 +221,7 @@ describe("openclaw-clawchat config", () => {
           websocketUrl: "wss://w",
           token: "t",
           userId: "u",
+          ownerUserId: "o",
           baseUrl: "https://api.example.com",
         },
       },
@@ -140,8 +241,8 @@ describe("openclaw-clawchat config", () => {
   });
 
   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");
+    expect(DEFAULT_BASE_URL).toBe("https://app.clawling.com");
+    expect(DEFAULT_WEBSOCKET_URL).toBe("wss://app.clawling.com/ws");
   });
 
   it("does NOT include baseUrl in the configured predicate (channel still works without it)", async () => {
@@ -151,6 +252,7 @@ describe("openclaw-clawchat config", () => {
           websocketUrl: "wss://w",
           token: "t",
           userId: "u",
+          ownerUserId: "o",
           // no baseUrl — resolver uses default
         },
       },
@@ -160,7 +262,7 @@ describe("openclaw-clawchat config", () => {
     expect(account.baseUrl).toBe(DEFAULT_BASE_URL);
   });
 
-  it("adds the plugin to tools.allow when an explicit allowlist is already in use", () => {
+  it("adds the plugin to tools.alsoAllow even when an explicit allowlist is already in use", () => {
     const cfg = mergeOpenclawClawchatToolAllow({
       tools: {
         allow: ["bash"],
@@ -168,9 +270,9 @@ describe("openclaw-clawchat config", () => {
       },
     } as never) as { tools: Record<string, unknown> };
 
-    expect(cfg.tools.allow).toEqual(["bash", "openclaw-clawchat"]);
+    expect(cfg.tools.allow).toEqual(["bash"]);
     expect(cfg.tools.deny).toEqual(["exec"]);
-    expect(cfg.tools.alsoAllow).toBeUndefined();
+    expect(cfg.tools.alsoAllow).toEqual(["openclaw-clawchat"]);
   });
 
   it("adds the plugin to tools.alsoAllow when no explicit allowlist is in use", () => {