@newbase-clawchat/openclaw-clawchat 2026.4.23 → 2026.4.29

package/src/channel.outbound.test.ts

@@ -5,8 +5,6 @@ const getRuntimeMock = vi.hoisted(() => vi.fn());
 const waitForClientMock = vi.hoisted(() => vi.fn());
 const uploadOutboundMediaMock = vi.hoisted(() => vi.fn());
 const createApiClientMock = vi.hoisted(() => vi.fn());
-const sendTextMock = vi.hoisted(() => vi.fn());
-const sendMediaMock = vi.hoisted(() => vi.fn());
 
 vi.mock("./runtime.ts", () => ({
   getOpenclawClawlingClient: getClientMock,
@@ -23,11 +21,6 @@ vi.mock("./api-client.ts", () => ({
   createOpenclawClawlingApiClient: createApiClientMock,
 }));
 
-vi.mock("./outbound.ts", () => ({
-  sendOpenclawClawlingText: sendTextMock,
-  sendOpenclawClawlingMedia: sendMediaMock,
-}));
-
 describe("openclaw-clawchat channel outbound", () => {
   beforeEach(() => {
     vi.resetModules();
@@ -36,15 +29,17 @@ describe("openclaw-clawchat channel outbound", () => {
     waitForClientMock.mockReset();
     uploadOutboundMediaMock.mockReset();
     createApiClientMock.mockReset();
-    sendTextMock.mockReset();
-    sendMediaMock.mockReset();
   });
 
   it("sendText waits for client activation when no active client exists yet", async () => {
-    const client = { sendMessage: vi.fn() };
+    const client = {
+      sendMessage: vi.fn().mockResolvedValue({
+        payload: { message_id: "m-2", accepted_at: 456 },
+        trace_id: "trace-2",
+      }),
+    };
     getClientMock.mockReturnValue(undefined);
     waitForClientMock.mockResolvedValue(client);
-    sendTextMock.mockResolvedValue({ messageId: "m-2", acceptedAt: 456 });
 
     const { openclawClawlingOutbound } = await import("./outbound.ts");
     const result = await openclawClawlingOutbound.sendText!({
@@ -64,12 +59,13 @@ describe("openclaw-clawchat channel outbound", () => {
     });
 
     expect(waitForClientMock).toHaveBeenCalledWith("default");
-    expect(sendTextMock).toHaveBeenCalledWith({
-      client,
-      account: expect.objectContaining({ userId: "agent-1" }),
-      to: { chatId: "user-1", chatType: "direct" },
-      text: "hello",
-    });
+    expect(client.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chat_id: "user-1",
+        chat_type: "direct",
+        body: { fragments: [{ kind: "text", text: "hello" }] },
+      }),
+    );
     expect(result).toEqual({
       channel: "openclaw-clawchat",
       to: "cc:user-1",
@@ -78,7 +74,12 @@ describe("openclaw-clawchat channel outbound", () => {
   });
 
   it("sendMedia uploads mediaUrl and sends resulting fragments", async () => {
-    const client = { sendMessage: vi.fn() };
+    const client = {
+      sendMessage: vi.fn().mockResolvedValue({
+        payload: { message_id: "m-1", accepted_at: 123 },
+        trace_id: "trace-1",
+      }),
+    };
     const runtime = { media: { loadWebMedia: vi.fn() } };
     const apiClient = { uploadMedia: vi.fn() };
     getClientMock.mockReturnValue(client);
@@ -87,7 +88,6 @@ describe("openclaw-clawchat channel outbound", () => {
     uploadOutboundMediaMock.mockResolvedValue([
       { kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" },
     ]);
-    sendMediaMock.mockResolvedValue({ messageId: "m-1", acceptedAt: 123 });
 
     const { openclawClawlingOutbound } = await import("./outbound.ts");
     const result = await openclawClawlingOutbound.sendMedia!({
@@ -118,13 +118,18 @@ describe("openclaw-clawchat channel outbound", () => {
       runtime,
       mediaLocalRoots: ["/tmp"],
     });
-    expect(sendMediaMock).toHaveBeenCalledWith({
-      client,
-      account: expect.objectContaining({ userId: "agent-1", baseUrl: "https://api.example.com" }),
-      to: { chatId: "room-1", chatType: "group" },
-      text: "caption",
-      mediaFragments: [{ kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" }],
-    });
+    expect(client.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chat_id: "room-1",
+        chat_type: "group",
+        body: {
+          fragments: [
+            { kind: "text", text: "caption" },
+            { kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" },
+          ],
+        },
+      }),
+    );
     expect(result).toEqual({
       channel: "openclaw-clawchat",
       to: "cc:group:room-1",
@@ -155,7 +160,12 @@ describe("openclaw-clawchat channel outbound", () => {
   });
 
   it("sendMedia waits for client activation when no active client exists yet", async () => {
-    const client = { sendMessage: vi.fn() };
+    const client = {
+      sendMessage: vi.fn().mockResolvedValue({
+        payload: { message_id: "m-3", accepted_at: 789 },
+        trace_id: "trace-3",
+      }),
+    };
     const runtime = { media: { loadWebMedia: vi.fn() } };
     const apiClient = { uploadMedia: vi.fn() };
     getClientMock.mockReturnValue(undefined);
@@ -165,7 +175,6 @@ describe("openclaw-clawchat channel outbound", () => {
     uploadOutboundMediaMock.mockResolvedValue([
       { kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" },
     ]);
-    sendMediaMock.mockResolvedValue({ messageId: "m-3", acceptedAt: 789 });
 
     const { openclawClawlingOutbound } = await import("./outbound.ts");
     const result = await openclawClawlingOutbound.sendMedia!({
@@ -187,13 +196,18 @@ describe("openclaw-clawchat channel outbound", () => {
     });
 
     expect(waitForClientMock).toHaveBeenCalledWith("default");
-    expect(sendMediaMock).toHaveBeenCalledWith({
-      client,
-      account: expect.objectContaining({ userId: "agent-1", baseUrl: "https://api.example.com" }),
-      to: { chatId: "room-1", chatType: "group" },
-      text: "caption",
-      mediaFragments: [{ kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" }],
-    });
+    expect(client.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chat_id: "room-1",
+        chat_type: "group",
+        body: {
+          fragments: [
+            { kind: "text", text: "caption" },
+            { kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" },
+          ],
+        },
+      }),
+    );
     expect(result).toEqual({
       channel: "openclaw-clawchat",
       to: "cc:group:room-1",

package/src/channel.test.ts

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

package/src/channel.ts

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

package/src/client.test.ts

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

package/src/client.ts

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

package/src/commands.test.ts

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

package/src/commands.ts

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

package/src/config.test.ts

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