@newbase-clawchat/openclaw-clawchat 2026.4.30 → 2026.5.4-2

package/dist/src/reply-dispatcher.js

@@ -1,4 +1,5 @@
 import { interactiveReplyToPresentation, renderMessagePresentationFallbackText, } from "openclaw/plugin-sdk/interactive-runtime";
+import { resolveOutboundMediaUrls } from "openclaw/plugin-sdk/reply-payload";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
 import { openBufferedStreamingSession, mergeStreamingText, } from "./buffered-stream.js";
 import { emitFinalStreamReply } from "./client.js";
@@ -256,7 +257,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             routing,
             replyTo: {
                 msgId: inboundMessageId ?? streamingMessageId,
-                previewId: inboundForFinalReply?.chatId ?? target.chatId,
+                previewId: inboundForFinalReply?.senderId ?? target.chatId,
                 nickName: inboundForFinalReply?.senderNickName ?? inboundForFinalReply?.senderId ?? target.chatId,
                 fragments: inboundForFinalReply?.bodyText
                     ? [{ kind: "text", text: inboundForFinalReply.bodyText }]
@@ -271,10 +272,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         }
         if (text)
             streamText = mergeStreamingText(streamText, text);
-        const urls = [
-            ...(payload.mediaUrl ? [payload.mediaUrl] : []),
-            ...(payload.mediaUrls ?? []),
-        ].filter((u) => Boolean(u));
+        const urls = resolveOutboundMediaUrls(payload).filter(Boolean);
         for (const url of urls) {
             if (!accumulatedMediaUrls.includes(url))
                 accumulatedMediaUrls.push(url);
@@ -313,10 +311,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         deliver: async (payload, info) => {
             const richFragment = buildRichInteractionFragment(payload);
             const text = richFragment && account.richInteractions ? "" : resolvePayloadText(payload);
-            const urls = [
-                ...(payload.mediaUrl ? [payload.mediaUrl] : []),
-                ...(payload.mediaUrls ?? []),
-            ].filter((u) => Boolean(u));
+            const urls = resolveOutboundMediaUrls(payload).filter(Boolean);
             log?.info?.(`[${account.accountId}] openclaw-clawchat deliver kind=${info?.kind ?? "unknown"} text_len=${text.length} media_urls=${urls.length} reasoning=${payload.isReasoning === true}`);
             if (payload.isReasoning) {
                 if (!account.forwardThinking)

package/dist/src/runtime.js

@@ -76,9 +76,11 @@ export async function startOpenclawClawlingGateway(params) {
     // Obtain PluginRuntime from the stored runtime set via setOpenclawClawlingRuntime.
     const runtime = getOpenclawClawlingRuntime();
     const accountId = account.accountId;
+    log?.info?.(`[${accountId}] openclaw-clawchat runtime start entered configured=${account.configured} enabled=${account.enabled} hasToken=${Boolean(account.token)} hasUserId=${Boolean(account.userId)} websocketUrl=${account.websocketUrl || "(empty)"}`);
     const client = createOpenclawClawlingClient(account, {
         ...(params.transport ? { transport: params.transport } : {}),
     });
+    log?.info?.(`[${accountId}] openclaw-clawchat runtime client created`);
     client.on("state", ({ from, to }) => {
         log?.info?.(`[${accountId}] openclaw-clawchat state ${from} -> ${to}`);
         const next = { ...getStatus(), ...mapClawlingStateToStatus(to) };
@@ -138,16 +140,16 @@ export async function startOpenclawClawlingGateway(params) {
                         timestamp: turn.timestamp,
                         ...rt.reply.resolveEnvelopeFormatOptions(cfg),
                     });
+                    const conversationTarget = `${CHANNEL_ID}:${formatConversationSubject(turn.peer)}`;
                     const ctxPayload = rt.reply.finalizeInboundContext({
                         Body: body,
                         BodyForAgent: turn.rawBody,
                         RawBody: turn.rawBody,
                         CommandBody: turn.rawBody,
-                        // Clawling v2 routes by chat_id. `senderId` is still preserved as
-                        // structured metadata, but the conversation target must be based on
-                        // `peer.id` so follow-up sends address the active chat, not merely
-                        // the human sender identity.
-                        From: `${CHANNEL_ID}:${formatConversationSubject(turn.peer)}`,
+                        // Clawling v2 routes by chat_id. `OriginatingTo` is what the
+                        // message tool uses as the implicit current-chat target, so keep it
+                        // on the conversation id rather than the agent account user id.
+                        From: conversationTarget,
                         To: `${CHANNEL_ID}:${account.userId}`,
                         SessionKey: route.sessionKey,
                         AccountId: route.accountId ?? accountId,
@@ -160,7 +162,7 @@ export async function startOpenclawClawlingGateway(params) {
                         MessageSidFull: turn.messageId,
                         Timestamp: turn.timestamp,
                         OriginatingChannel: CHANNEL_ID,
-                        OriginatingTo: `${CHANNEL_ID}:${account.userId}`,
+                        OriginatingTo: conversationTarget,
                     });
                     // Fetch any inbound media attachments and populate MediaPath/MediaPaths in context.
                     const inboundPaths = turn.mediaItems.length > 0
@@ -250,7 +252,9 @@ export async function startOpenclawClawlingGateway(params) {
     // return without throwing (which would make the gateway supervisor
     // restart us immediately in a tight loop).
     try {
+        log?.info?.(`[${accountId}] openclaw-clawchat runtime calling client.connect()`);
         await client.connect();
+        log?.info?.(`[${accountId}] openclaw-clawchat runtime client.connect() resolved`);
     }
     catch (err) {
         const classified = classifyClawlingClientError(err);
@@ -265,6 +269,7 @@ export async function startOpenclawClawlingGateway(params) {
         return;
     }
     activeClients.set(accountId, client);
+    log?.info?.(`[${accountId}] openclaw-clawchat runtime active client registered`);
     setStatus({
         ...getStatus(),
         connected: true,
@@ -273,6 +278,7 @@ export async function startOpenclawClawlingGateway(params) {
     });
     log?.info?.(`[${accountId}] openclaw-clawchat connected`);
     await waitUntilAbort(abortSignal, async () => {
+        log?.info?.(`[${accountId}] openclaw-clawchat runtime abort received; closing client`);
         activeClients.delete(accountId);
         client.close();
         setStatus({

package/dist/src/tools.js

@@ -118,8 +118,8 @@ export function registerOpenclawClawlingTools(api) {
     function buildClient() {
         const acct = resolveCurrent();
         // `baseUrl` always resolves via the built-in default in config.ts, so we
-        // only need to gate on `token` here (which is populated by `openclaw
-        // channel login`).
+        // only need to gate on `token` here (which is populated by ClawChat
+        // activation/login).
         if (!acct.token) {
             return { ok: false, error: configError("openclaw-clawchat: token is required") };
         }

package/index.ts

@@ -1,31 +1,19 @@
-// import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/channel-core";
 import { openclawClawlingPlugin } from "./src/channel.ts";
 import { registerOpenclawClawlingCommands } from "./src/commands.ts";
+import { openclawClawlingConfigSchema } from "./src/config.ts";
 import { setOpenclawClawlingRuntime } from "./src/runtime.ts";
 import { registerOpenclawClawlingTools } from "./src/tools.ts";
-import { openclawClawlingConfigSchema } from "./src/config.ts";
 
-export default {
+export default defineChannelPluginEntry({
   id: "openclaw-clawchat",
   name: "Clawling Chat",
   description: "Clawling Chat Protocol v2 channel plugin (chat-sdk)",
-  configSchema: openclawClawlingConfigSchema,
-  register(api: OpenClawPluginApi) {
-    setOpenclawClawlingRuntime(api.runtime);
-    api.registerChannel({ plugin: openclawClawlingPlugin });
+  plugin: openclawClawlingPlugin,
+  configSchema: { schema: openclawClawlingConfigSchema },
+  setRuntime: setOpenclawClawlingRuntime,
+  registerFull(api) {
     registerOpenclawClawlingCommands(api);
     registerOpenclawClawlingTools(api);
-  }
-}
-
-// export default defineChannelPluginEntry({
-//   id: "openclaw-clawchat",
-//   name: "Clawling Chat",
-//   description: "Clawling Chat Protocol v2 channel plugin (chat-sdk)",
-//   plugin: openclawClawlingPlugin,
-//   setRuntime: setOpenclawClawlingRuntime,
-//   registerFull(api) {
-//     registerOpenclawClawlingTools(api);
-//   },
-// });
+  },
+});

package/openclaw.plugin.json

@@ -1,5 +1,6 @@
 {
   "id": "openclaw-clawchat",
+  "kind": "channel",
   "channels": ["openclaw-clawchat"],
   "skills": ["./skills"],
   "activation": {
@@ -7,6 +8,15 @@
     "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" }
   ],

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@newbase-clawchat/openclaw-clawchat",
-  "version": "2026.4.30",
+  "version": "2026.5.4-2",
   "description": "OpenClaw ClawChat channel plugin",
   "files": [
     "dist",
     "index.ts",
+    "setup-entry.ts",
     "src",
     "skills",
     "openclaw.plugin.json",
@@ -15,6 +16,8 @@
     "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",
@@ -28,12 +31,12 @@
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
-    "openclaw": "2026.4.29",
+    "openclaw": "2026.5.4",
     "typescript": "^5.4.0",
     "vitest": "^4.1.5"
   },
   "peerDependencies": {
-    "openclaw": "^2026.4.29"
+    "openclaw": ">=2026.5.4"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -50,6 +53,12 @@
     "runtimeExtensions": [
       "./dist/index.js"
     ],
+    "setupEntry": "./setup-entry.ts",
+    "runtimeSetupEntry": "./dist/setup-entry.js",
+    "plugin": {
+      "id": "openclaw-clawchat",
+      "label": "Clawling Chat"
+    },
     "channel": {
       "id": "openclaw-clawchat",
       "label": "Clawling Chat",
@@ -57,12 +66,18 @@
       "docsPath": "/channels/openclaw-clawchat",
       "docsLabel": "openclaw-clawchat",
       "blurb": "Clawling Protocol v2 over WebSocket (chat-sdk).",
-      "order": 110
+      "order": 110,
+      "cliAddOptions": [
+        {
+          "flags": "--token <invite-code>",
+          "description": "ClawChat invite code"
+        }
+      ]
     },
     "install": {
       "npmSpec": "@newbase-clawchat/openclaw-clawchat",
       "defaultChoice": "npm",
-      "minHostVersion": ">=2026.4.29"
+      "minHostVersion": ">=2026.5.4"
     }
   }
 }

package/setup-entry.ts

@@ -0,0 +1,4 @@
+import { defineSetupPluginEntry } from "openclaw/plugin-sdk/channel-core";
+import { openclawClawlingSetupPlugin } from "./src/channel.setup.ts";
+
+export default defineSetupPluginEntry(openclawClawlingSetupPlugin);

package/skills/clawchat-activate/SKILL.md

@@ -8,31 +8,36 @@ description: |
 
 Activation should use the `clawchat_activate` tool when that tool is available. The tool runs the same invite-code login runtime as OpenClaw channel login and persists credentials into `channels.openclaw-clawchat`.
 
-If the tool is not available because the Gateway has not loaded this plugin yet, fall back to OpenClaw channel login. Do not edit config files manually and do not try to execute slash commands from this skill.
+If the tool is not available because the Gateway has not loaded this plugin yet, restart the Gateway after install/update and retry from a new turn. Do not edit config files manually. On OpenClaw 2026.5.5, npm-installed third-party channels may be loaded by the Gateway but still missing from the `channels add` CLI catalog, which fails with `Unknown channel: openclaw-clawchat`. In that case, ask the user to send the runtime slash command `/clawchat-login A1B2C3` in the chat where OpenClaw is running.
 
 ## Workflow
 
 1. Check whether the user is trying to activate or log in ClawChat.
 2. If `clawchat_activate` is available and the invite code is known, call it with the invite code.
 3. If the invite code is not known, ask the user for it before calling `clawchat_activate`.
-4. If `clawchat_activate` is not available, execute the channel login command:
+4. If `clawchat_activate` is not available but the plugin is loaded in a chat session, ask the user to send this runtime slash command in that chat:
+
+```text
+/clawchat-login A1B2C3
+```
+5. If using a host where `openclaw channels add --help` lists `openclaw-clawchat`, terminal activation can also use:
 
 ```bash
-openclaw channels login --channel openclaw-clawchat
+openclaw channels add --channel openclaw-clawchat --token "$CLAWCHAT_INVITE_CODE"
 ```
-5. Do not append the invite code to the command; `openclaw channels login` has no code argument.
-6. When the command prompts for an invite code, provide the user's invite code if one was already present, otherwise ask the user for it.
-7. After activation succeeds, rely on OpenClaw's `channels.*` config hot reload when the plugin is already loaded. Verify channel status if available:
+6. The token argument is the ClawChat invite code on this setup path. Do not use `channels add` on OpenClaw 2026.5.5 when it reports `Unknown channel: openclaw-clawchat`.
+7. Use `openclaw channels login --channel openclaw-clawchat` only to refresh credentials later after the channel already exists and the host recognizes the channel.
+8. After activation succeeds, verify channel status if available:
 
 ```bash
 openclaw channels status --probe
 ```
-8. Execute the Gateway restart command only when the plugin was just installed/updated, the tool was unavailable because the running Gateway had not loaded the plugin, config reload is disabled, or the probe does not become healthy:
+9. Execute the Gateway restart command 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
 ```
-9. Tell the user activation completes after login succeeds and either config hot reload/probe succeeds or Gateway restart succeeds.
+10. Tell the user activation completes after `clawchat_activate`, `/clawchat-login`, or supported channel add/login succeeds and the status probe succeeds after any required Gateway restart.
 
 ## Trigger Examples
 
@@ -42,6 +47,6 @@ openclaw gateway restart
 - `绑定 ClawChat，邀请码 A1B2C3`
 - `激活 ClawChat`
 
-Do not ask the user to enter a bare ClawChat command. If activation is requested and `clawchat_activate` is available, call that tool yourself. If the tool is unavailable, execute `openclaw channels login --channel openclaw-clawchat` yourself, then probe channel status and restart the Gateway only when needed.
+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 but the runtime slash command is available in chat, ask the user to send `/clawchat-login A1B2C3`. If the host's CLI channel catalog supports `openclaw-clawchat`, `openclaw channels add --channel openclaw-clawchat --token "$CLAWCHAT_INVITE_CODE"` is also acceptable; then probe channel status and perform a real Gateway restart if the channel is configured but stopped or disconnected.
 
-When the user asks to activate ClawChat without including a code, ask for the invite code before calling `clawchat_activate`; if falling back to channel login, provide the code when the command needs it.
+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/channel.outbound.test.ts

@@ -88,6 +88,8 @@ describe("openclaw-clawchat channel outbound", () => {
     uploadOutboundMediaMock.mockResolvedValue([
       { kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" },
     ]);
+    const mediaReadFile = vi.fn(async () => Buffer.from("host-read"));
+    const mediaAccess = { localRoots: ["/tmp"], workspaceDir: "/workspace" };
 
     const { openclawClawlingOutbound } = await import("./outbound.ts");
     const result = await openclawClawlingOutbound.sendMedia!({
@@ -105,7 +107,9 @@ describe("openclaw-clawchat channel outbound", () => {
       to: "cc:group:room-1",
       text: "caption",
       mediaUrl: "/tmp/photo.png",
+      mediaAccess,
       mediaLocalRoots: ["/tmp"],
+      mediaReadFile,
     });
 
     expect(createApiClientMock).toHaveBeenCalledWith({
@@ -116,7 +120,9 @@ describe("openclaw-clawchat channel outbound", () => {
     expect(uploadOutboundMediaMock).toHaveBeenCalledWith(["/tmp/photo.png"], {
       apiClient,
       runtime,
+      mediaAccess,
       mediaLocalRoots: ["/tmp"],
+      mediaReadFile,
     });
     expect(client.sendMessage).toHaveBeenCalledWith(
       expect.objectContaining({

package/src/channel.setup.ts

@@ -0,0 +1,156 @@
+import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import type { ChannelSetupInput } from "openclaw/plugin-sdk/channel-setup";
+import type { ChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+import {
+  createComputedAccountStatusAdapter,
+  createDefaultChannelRuntimeState,
+} from "openclaw/plugin-sdk/status-helpers";
+import {
+  CHANNEL_ID,
+  listOpenclawClawlingAccountIds,
+  mergeOpenclawClawchatToolAllow,
+  openclawClawlingConfigSchema,
+  resolveOpenclawClawlingAccount,
+  type ResolvedOpenclawClawlingAccount,
+} from "./config.ts";
+import type { OpenclawClawchatMutateConfigFile } from "./login.runtime.ts";
+
+const configAdapter = createTopLevelChannelConfigAdapter<ResolvedOpenclawClawlingAccount>({
+  sectionKey: CHANNEL_ID,
+  resolveAccount: (cfg) => resolveOpenclawClawlingAccount(cfg),
+  listAccountIds: () => listOpenclawClawlingAccountIds(),
+  defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+  deleteMode: "clear-fields",
+  clearBaseFields: [
+    "websocketUrl",
+    "baseUrl",
+    "token",
+    "userId",
+    "replyMode",
+    "forwardThinking",
+    "forwardToolCalls",
+    "richInteractions",
+    "enabled",
+  ],
+  resolveAllowFrom: (account) => account.allowFrom,
+  formatAllowFrom: () => [],
+});
+
+/**
+ * Invite-code setup adapter used by OpenClaw setup surfaces.
+ *
+ * `channels add --token` passes the invite code as setup input. The first
+ * config write only enables the channel; `afterAccountConfigWritten` exchanges
+ * the invite code and persists token/userId through the host runtime mutator.
+ */
+const setupAdapter: NonNullable<ChannelPlugin<ResolvedOpenclawClawlingAccount>["setup"]> = {
+  resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+  validateInput: ({ input }: { cfg: OpenClawConfig; accountId: string; input: ChannelSetupInput }) => {
+    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;
+  },
+  applyAccountConfig: ({ cfg }: { cfg: OpenClawConfig; accountId: string; input: ChannelSetupInput }) => {
+    const channels = (cfg.channels ?? {}) as Record<string, unknown>;
+    const current = (channels[CHANNEL_ID] ?? {}) as Record<string, unknown>;
+    return mergeOpenclawClawchatToolAllow({
+      ...cfg,
+      channels: {
+        ...channels,
+        [CHANNEL_ID]: { ...current, enabled: true },
+      },
+    });
+  },
+  afterAccountConfigWritten: async ({ cfg, input, runtime }) => {
+    runtime.log("[default] openclaw-clawchat setup afterAccountConfigWritten invoked");
+    const code =
+      typeof input.code === "string" && input.code.trim()
+        ? input.code.trim()
+        : typeof input.token === "string"
+          ? input.token.trim()
+          : "";
+    if (!code) {
+      runtime.log("[default] openclaw-clawchat setup afterAccountConfigWritten skipped: empty invite code");
+      return;
+    }
+    const { runOpenclawClawlingLogin } = await import("./login.runtime.ts");
+    await runOpenclawClawlingLogin({
+      cfg,
+      accountId: null,
+      runtime: { log: (message: string) => runtime.log(message) },
+      readInviteCode: async () => code,
+      mutateConfigFile: mutateConfigFile as OpenclawClawchatMutateConfigFile,
+    });
+    runtime.log("[default] openclaw-clawchat setup afterAccountConfigWritten completed");
+  },
+};
+
+type OpenclawClawlingSetupPlugin = Pick<
+  ChannelPlugin<ResolvedOpenclawClawlingAccount>,
+  "id" | "meta" | "capabilities" | "reload" | "configSchema" | "config" | "setup" | "status"
+>;
+
+export const openclawClawlingSetupPlugin: OpenclawClawlingSetupPlugin = {
+  id: CHANNEL_ID,
+  meta: {
+    id: CHANNEL_ID,
+    label: "Clawling Chat",
+    selectionLabel: "Clawling Chat",
+    docsPath: "/channels/openclaw-clawchat",
+    docsLabel: "openclaw-clawchat",
+    blurb: "Clawling Protocol v2 over WebSocket (chat-sdk).",
+    order: 110,
+  },
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    media: true,
+    reactions: false,
+    threads: false,
+    polls: false,
+    blockStreaming: true,
+  },
+  reload: {
+    configPrefixes: [`channels.${CHANNEL_ID}`],
+  },
+  configSchema: {
+    schema: openclawClawlingConfigSchema,
+  },
+  config: {
+    ...configAdapter,
+    isConfigured: (account) => account.configured,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+    }),
+  },
+  setup: setupAdapter,
+  status: createComputedAccountStatusAdapter<ResolvedOpenclawClawlingAccount>({
+    defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, {
+      connected: false,
+      lastInboundAt: null,
+      lastOutboundAt: null,
+    }),
+    resolveAccountSnapshot: ({ account }) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+      extra: {
+        websocketUrl: account.websocketUrl || null,
+        baseUrl: account.baseUrl || null,
+        userId: account.userId || null,
+      },
+    }),
+  }),
+};

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", () => {
@@ -117,10 +123,32 @@ describe("openclaw-clawchat plugin", () => {
     expect(normalized).toBe("usr_01KPN6SQFQEGM9HR11CHRHPMMT");
   });
 
+  it("declares ClawChat target prefixes for OpenClaw channel selection", () => {
+    expect(openclawClawlingPlugin.messaging?.targetPrefixes).toEqual([
+      "cc",
+      "clawchat",
+      "openclaw-clawchat",
+    ]);
+  });
+
   it("parses openclaw-clawchat target prefix as a direct recipient", () => {
     expect(parseOpenclawRecipient("openclaw-clawchat:usr_01KPN6SQFQEGM9HR11CHRHPMMT")).toEqual({
       chatId: "usr_01KPN6SQFQEGM9HR11CHRHPMMT",
       chatType: "direct",
     });
   });
+
+  it("parses host-normalized group targets as group recipients", () => {
+    expect(parseOpenclawRecipient("group:cnv_01KR2NBGTKEQ0S0CAYCEQP3YPW")).toEqual({
+      chatId: "cnv_01KR2NBGTKEQ0S0CAYCEQP3YPW",
+      chatType: "group",
+    });
+  });
+
+  it("parses host-normalized direct targets as direct recipients", () => {
+    expect(parseOpenclawRecipient("direct:cnv_01KR2NBGTKEQ0S0CAYCEQP3YPW")).toEqual({
+      chatId: "cnv_01KR2NBGTKEQ0S0CAYCEQP3YPW",
+      chatType: "direct",
+    });
+  });
 });