@newbase-clawchat/openclaw-clawchat 2026.4.24 → 2026.4.30

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,12 +14,14 @@ import {
 import {
   CHANNEL_ID,
   listOpenclawClawlingAccountIds,
+  mergeOpenclawClawchatToolAllow,
   openclawClawlingConfigSchema,
   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,
@@ -35,6 +37,7 @@ const configAdapter = createTopLevelChannelConfigAdapter<ResolvedOpenclawClawlin
     "replyMode",
     "forwardThinking",
     "forwardToolCalls",
+    "richInteractions",
     "enabled",
   ],
   resolveAllowFrom: (account) => account.allowFrom,
@@ -42,23 +45,24 @@ 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`
- * 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()) {
-      return "Clawling Chat setup requires --code (invite code from your admin).";
+      return "ClawChat invite code is required.";
     }
     return null;
   },
@@ -73,13 +77,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,
@@ -103,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,
     });
   },
 };
@@ -175,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,
           });
         },
       },
@@ -196,13 +206,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,9 @@ 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).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" });
@@ -117,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" },
     ]);
@@ -168,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

@@ -64,12 +64,20 @@ 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
- * `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,
@@ -78,18 +86,22 @@ 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,
     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));
@@ -107,14 +119,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 +144,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 +154,7 @@ export function emitStreamAdd(
   },
 ): void {
   const now = Date.now();
+  const routing = normalizeRouting(params);
   emitEnvelope(
     client,
     "message.add",
@@ -158,7 +174,7 @@ export function emitStreamAdd(
       },
       added_at: now,
     },
-    params.routing,
+    routing,
   );
 }
 
@@ -171,12 +187,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 +210,7 @@ export function emitStreamDone(
       },
       completed_at: now,
     },
-    params.routing,
+    routing,
   );
 }
 
@@ -211,11 +229,12 @@ 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;
-      senderId: string;
+      previewId: string;
       nickName: string;
       fragments: Fragment[];
     };
@@ -223,6 +242,7 @@ export function emitFinalStreamReply(
     mentions?: string[];
   },
 ): void {
+  const routing = normalizeRouting(params);
   emitEnvelope(
     client,
     "message.reply",
@@ -236,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,
             },
@@ -244,7 +264,7 @@ export function emitFinalStreamReply(
         },
       },
     },
-    params.routing,
+    routing,
   );
 }
 
@@ -252,19 +272,26 @@ 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);
+  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,
@@ -272,8 +299,8 @@ export function emitStreamFailed(
         started_at: null,
         completed_at: now,
       },
-      failed_at: now,
+      completed_at: now,
     },
-    params.routing,
+    routing,
   );
 }

package/src/commands.test.ts

@@ -0,0 +1,39 @@
+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),
+      runtime: {
+        config: {
+          mutateConfigFile: vi.fn(),
+        },
+      },
+    } 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];
+    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

@@ -0,0 +1,41 @@
+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() : "";
+  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" | "runtime">): 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,
+          mutateConfigFile: (api.runtime.config as unknown as {
+            mutateConfigFile: OpenclawClawchatMutateConfigFile;
+          }).mutateConfigFile,
+        });
+        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";
@@ -20,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);
   });
 
@@ -33,6 +37,7 @@ describe("openclaw-clawchat config", () => {
           replyMode: "stream",
           forwardThinking: false,
           forwardToolCalls: true,
+          richInteractions: true,
           stream: { flushIntervalMs: 500, minChunkChars: 50, maxBufferChars: 3000 },
         },
       },
@@ -45,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);
@@ -80,19 +86,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 +115,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"],
+    });
+  });
+
 });