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

package/README.md

@@ -10,7 +10,7 @@ OpenClaw channel plugin that connects an agent to ClawChat over the ClawChat Pro
 - Outbound text replies in `static` or `stream` mode, with a consolidated final `message.reply`
 - Typing indicators and filtered forwarding for thinking / tool-call content
 - Media fragments (image / file / audio / video) in either direction
-- Invite-code onboarding via `clawchat_activate` or channel login, plus always-registered `clawchat_*` account/media tools
+- Invite-code onboarding via `clawchat_activate` or `/clawchat-login`, plus always-registered `clawchat_*` account/media tools
 
 ## Install
 
@@ -19,9 +19,10 @@ OpenClaw channel plugin that connects an agent to ClawChat over the ClawChat Pro
 npm i @newbase-clawchat/openclaw-clawchat
 ```
 
-Requires `openclaw >= 2026.4.29` as a peer host.
+Requires `openclaw >= 2026.5.4` as a peer host.
 
-For the OpenClaw plugin install/update flow, see [`INSTALL.md`](./INSTALL.md).
+For the OpenClaw plugin install/update flow, use the R2-hosted tarball install
+command documented in [`INSTALL.md`](./INSTALL.md).
 
 Example LLM prompt:
 
@@ -38,15 +39,31 @@ activate ClawChat with invite code A1B2C3
 ```
 
 If the plugin is already loaded by the Gateway, the activation skill calls the
-`clawchat_activate` tool and OpenClaw hot-reloads the updated `channels.*`
-credentials. If the tool is not available yet, use channel login as the CLI
-fallback:
+`clawchat_activate` tool and persists credentials. If you are activating from
+Telegram or another chat platform and the agent does not call the tool, send the
+runtime slash command in that chat:
+
+```text
+/clawchat-login A1B2C3
+```
+
+The slash command is provided by the loaded plugin. It is not a shell command,
+so `openclaw clawchat-login` is expected to fail.
+
+On OpenClaw hosts where the CLI channel catalog includes `openclaw-clawchat`,
+terminal activation can also use:
 
 ```bash
-openclaw channels login --channel openclaw-clawchat
+CLAWCHAT_INVITE_CODE="A1B2C3"
+openclaw channels add --channel openclaw-clawchat --token "$CLAWCHAT_INVITE_CODE"
 openclaw channels status --probe
 ```
 
+OpenClaw 2026.5.5 can load an npm-installed third-party channel while still
+omitting it from the `channels add` CLI catalog. If `channels add` fails with
+`Unknown channel: openclaw-clawchat`, use `clawchat_activate` or
+`/clawchat-login A1B2C3` after a real Gateway restart.
+
 Restart the Gateway after installing/updating the plugin, when config reload is
 disabled, or when the channel probe does not become healthy:
 
@@ -55,17 +72,20 @@ openclaw gateway restart
 ```
 
 If you run the gateway manually instead of as a service and it is not already
-running, start it after login:
+running, start it after activation:
 
 ```bash
 openclaw gateway run
 ```
 
-The invite code is not a token; token fields are written only after login. The
-plugin registers `clawchat_activate` and the six account/media tools at plugin
-load time so they stay visible before activation. Before login, account/media
+The `--token` value above is the ClawChat invite code for OpenClaw's generic
+`channels add` CLI surface on hosts that expose this plugin in the channel
+catalog; persisted token fields are written only after the invite code exchange
+succeeds. The plugin registers `clawchat_activate` and the six account/media tools at plugin
+load time so they stay visible before activation. Before activation, account/media
 tools return a config error instead of disappearing; after activation/login, the
-channel is enabled and the same tools read the hot-reloaded token/userId.
+channel is enabled and the same tools read the persisted token/userId after the
+Gateway restarts.
 
 After activation/login, the channel section is enabled and has credentials:
 
@@ -157,6 +177,38 @@ npm run dev:openclaw-source
 This checkout is local-only. It is ignored by git and is not required to run the
 plugin tests or publish the package.
 
+## R2 package scripts
+
+Create and upload the OpenClaw plugin tarball to the R2 `openclaw/` prefix:
+
+```bash
+./package_openclaw_plugin.sh
+```
+
+The script runs `npm pack`, uploads the generated `.tgz` to the configured R2
+bucket, and prints the public URL. R2 credentials are read from `.env.r2`, which
+is ignored by git. Use `--no-upload` to build the tarball without uploading it.
+
+```bash
+AWS_ACCESS_KEY_ID=...
+AWS_SECRET_ACCESS_KEY=...
+AWS_DEFAULT_REGION=auto
+R2_ENDPOINT=https://...
+R2_BUCKET=...
+```
+
+Install the R2-hosted tarball on a device or container with OpenClaw available:
+
+```bash
+./install_openclaw.sh
+```
+
+To install a specific uploaded tarball, pass its URL explicitly:
+
+```bash
+./install_openclaw.sh https://dddddddddddddtest.clawling.chat/openclaw/newbase-clawchat-openclaw-clawchat-2026.5.4-2.tgz
+```
+
 ## License
 
 See the repository root.

package/dist/index.js

@@ -1,27 +1,18 @@
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/channel-core";
 import { openclawClawlingPlugin } from "./src/channel.js";
 import { registerOpenclawClawlingCommands } from "./src/commands.js";
+import { openclawClawlingConfigSchema } from "./src/config.js";
 import { setOpenclawClawlingRuntime } from "./src/runtime.js";
 import { registerOpenclawClawlingTools } from "./src/tools.js";
-import { openclawClawlingConfigSchema } from "./src/config.js";
-export default {
+export default defineChannelPluginEntry({
     id: "openclaw-clawchat",
     name: "Clawling Chat",
     description: "Clawling Chat Protocol v2 channel plugin (chat-sdk)",
-    configSchema: openclawClawlingConfigSchema,
-    register(api) {
-        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/dist/setup-entry.js

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

package/dist/src/channel.js

@@ -1,145 +1,15 @@
-import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
-import { createChatChannelPlugin, } from "openclaw/plugin-sdk/core";
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
 import { createEmptyChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-runtime";
-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, } from "./config.js";
+import { CHANNEL_ID, resolveOpenclawClawlingAccount, } from "./config.js";
 import { openclawClawlingOutbound } from "./outbound.js";
 import { getOpenclawClawlingRuntime, startOpenclawClawlingGateway } from "./runtime.js";
-const configAdapter = createTopLevelChannelConfigAdapter({
-    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 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`.
- *
- * `applyAccountConfig` itself only marks the section `enabled: true`;
- * 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 }) => {
-        if (!input.code?.trim()) {
-            return "ClawChat invite code is required.";
-        }
-        return null;
-    },
-    applyAccountConfig: ({ cfg, }) => {
-        // Base config: just enable the channel. Credentials arrive via
-        // `afterAccountConfigWritten` → `runOpenclawClawlingLogin`.
-        const channels = (cfg.channels ?? {});
-        const current = (channels[CHANNEL_ID] ?? {});
-        return mergeOpenclawClawchatToolAllow({
-            ...cfg,
-            channels: {
-                ...channels,
-                [CHANNEL_ID]: { ...current, enabled: true },
-            },
-        });
-    },
-    afterAccountConfigWritten: async ({ cfg, input, runtime, }) => {
-        const code = input.code?.trim();
-        if (!code)
-            return;
-        // Lazy-import the login runtime to keep @clack/prompts / readline /
-        // config-runtime off the plugin's cold-start path. `readInviteCode`
-        // feeds the fixed code so the stdin prompt is skipped entirely.
-        const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
-        await runOpenclawClawlingLogin({
-            cfg,
-            accountId: null,
-            runtime: { log: (message) => runtime.log(message) },
-            readInviteCode: async () => code,
-            mutateConfigFile: getOpenclawClawlingRuntime().config.mutateConfigFile,
-        });
-    },
-};
+import { openclawClawlingSetupPlugin } from "./channel.setup.js";
 export const openclawClawlingPlugin = createChatChannelPlugin({
     base: {
-        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,
-            }),
-        },
+        ...openclawClawlingSetupPlugin,
         directory: createEmptyChannelDirectoryAdapter(),
-        setup: setupAdapter,
-        status: createComputedAccountStatusAdapter({
-            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,
-                },
-            }),
-        }),
         auth: {
             login: async ({ cfg, accountId, runtime }) => {
-                // Lazy-load login.runtime: it pulls in @clack/prompts and other
-                // heavy modules that have no business loading on every plugin
-                // boot. Only the rare `openclaw channels login --channel
-                // openclaw-clawchat` invocation pays the import cost.
                 const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
                 await runOpenclawClawlingLogin({
                     cfg,
@@ -152,17 +22,24 @@ export const openclawClawlingPlugin = createChatChannelPlugin({
         gateway: {
             startAccount: async (ctx) => {
                 const account = ctx.account ?? resolveOpenclawClawlingAccount(ctx.cfg);
+                ctx.log?.info?.(`[${account.accountId}] openclaw-clawchat lifecycle startAccount invoked configured=${account.configured} enabled=${account.enabled} hasToken=${Boolean(account.token)} hasUserId=${Boolean(account.userId)} websocketUrl=${account.websocketUrl || "(empty)"}`);
                 if (!account.configured) {
+                    ctx.log?.error?.(`[${account.accountId}] openclaw-clawchat lifecycle startAccount refused: websocketUrl/token/userId are required`);
                     throw new Error("Clawling Chat websocketUrl/token/userId are required");
                 }
-                return await startOpenclawClawlingGateway({
-                    cfg: ctx.cfg,
-                    account,
-                    abortSignal: ctx.abortSignal,
-                    setStatus: ctx.setStatus,
-                    getStatus: ctx.getStatus,
-                    log: ctx.log,
-                });
+                try {
+                    await startOpenclawClawlingGateway({
+                        cfg: ctx.cfg,
+                        account,
+                        abortSignal: ctx.abortSignal,
+                        setStatus: ctx.setStatus,
+                        getStatus: ctx.getStatus,
+                        log: ctx.log,
+                    });
+                }
+                finally {
+                    ctx.log?.info?.(`[${account.accountId}] openclaw-clawchat lifecycle startAccount completed/stopped`);
+                }
             },
         },
         agentPrompt: {
@@ -176,6 +53,7 @@ export const openclawClawlingPlugin = createChatChannelPlugin({
             ],
         },
         messaging: {
+            targetPrefixes: ["cc", "clawchat", CHANNEL_ID],
             normalizeTarget: (target) => target
                 .trim()
                 .replace(/^openclaw-clawchat:/i, "")

package/dist/src/channel.setup.js

@@ -0,0 +1,133 @@
+import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+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, } from "./config.js";
+const configAdapter = createTopLevelChannelConfigAdapter({
+    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 = {
+    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    validateInput: ({ input }) => {
+        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 }) => {
+        const channels = (cfg.channels ?? {});
+        const current = (channels[CHANNEL_ID] ?? {});
+        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.js");
+        await runOpenclawClawlingLogin({
+            cfg,
+            accountId: null,
+            runtime: { log: (message) => runtime.log(message) },
+            readInviteCode: async () => code,
+            mutateConfigFile: mutateConfigFile,
+        });
+        runtime.log("[default] openclaw-clawchat setup afterAccountConfigWritten completed");
+    },
+};
+export const 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({
+        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/dist/src/client.js

@@ -44,12 +44,19 @@ 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.
  */
-function emitEnvelope(client, event, payload, routing) {
+function emitEnvelope(client, event, payload, routing, options = {}) {
     const inner = client;
-    if (!inner.opts?.transport) {
-        inner.emitRaw?.(event, payload, { to: { id: routing.chatId, type: routing.chatType } });
+    if (!options.forceRawTransport && inner.emitRaw) {
+        inner.emitRaw(event, payload, { chat_id: routing.chatId });
         return;
     }
+    if (!inner.opts?.transport) {
+        if (!options.forceRawTransport && inner.emitRaw) {
+            inner.emitRaw(event, payload, { chat_id: routing.chatId });
+            return;
+        }
+        throw new Error("openclaw-clawchat streaming emit requires SDK raw transport");
+    }
     const env = {
         version: "2",
         event,
@@ -150,7 +157,7 @@ export function emitFinalStreamReply(client, params) {
                 },
             },
         },
-    }, routing);
+    }, routing, { forceRawTransport: true });
 }
 export function emitStreamFailed(client, params) {
     const now = Date.now();

package/dist/src/config.js

@@ -1,5 +1,10 @@
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 export const CHANNEL_ID = "openclaw-clawchat";
+export const CLAWCHAT_TOKEN_ENV = "CLAWCHAT_TOKEN";
+export const CLAWCHAT_USER_ID_ENV = "CLAWCHAT_USER_ID";
+export const CLAWCHAT_REFRESH_TOKEN_ENV = "CLAWCHAT_REFRESH_TOKEN";
+export const CLAWCHAT_BASE_URL_ENV = "CLAWCHAT_BASE_URL";
+export const CLAWCHAT_WEBSOCKET_URL_ENV = "CLAWCHAT_WEBSOCKET_URL";
 /**
  * Built-in defaults for the Clawling Chat endpoints so `openclaw channel
  * login` works out of the box without requiring a prior `openclaw channel
@@ -134,6 +139,9 @@ function readChannelSection(cfg) {
 function readOptionalString(value) {
     return typeof value === "string" ? value.trim() : "";
 }
+function readEnvString(env, key) {
+    return readOptionalString(env[key]);
+}
 function readReplyMode(value) {
     return value === "stream" ? "stream" : "static";
 }
@@ -175,13 +183,17 @@ function readAck(raw) {
             : DEFAULT_ACK.autoResendOnTimeout,
     };
 }
-export function resolveOpenclawClawlingAccount(cfg) {
+export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
     const channel = readChannelSection(cfg);
     // Apply built-in defaults so login/gateway work without prior setup.
-    const websocketUrl = readOptionalString(channel.websocketUrl) || DEFAULT_WEBSOCKET_URL;
-    const baseUrl = readOptionalString(channel.baseUrl) || DEFAULT_BASE_URL;
-    const token = readOptionalString(channel.token);
-    const userId = readOptionalString(channel.userId);
+    const websocketUrl = readOptionalString(channel.websocketUrl) ||
+        readEnvString(env, CLAWCHAT_WEBSOCKET_URL_ENV) ||
+        DEFAULT_WEBSOCKET_URL;
+    const baseUrl = readOptionalString(channel.baseUrl) ||
+        readEnvString(env, CLAWCHAT_BASE_URL_ENV) ||
+        DEFAULT_BASE_URL;
+    const token = readOptionalString(channel.token) || readEnvString(env, CLAWCHAT_TOKEN_ENV);
+    const userId = readOptionalString(channel.userId) || readEnvString(env, CLAWCHAT_USER_ID_ENV);
     const enabled = typeof channel.enabled === "boolean" ? channel.enabled : true;
     const replyMode = readReplyMode(channel.replyMode);
     const groupMode = readGroupMode(channel.groupMode);

package/dist/src/login.runtime.js

@@ -54,22 +54,31 @@ function buildLoginConfig(cfg, result) {
 }
 async function persistLoginConfig(params, result) {
     if (params.mutateConfigFile) {
+        params.runtime.log(`Persisting ClawChat credentials for userId=${result.agent.user_id} with Gateway restart intent.`);
         await params.mutateConfigFile({
-            afterWrite: { mode: "auto" },
+            afterWrite: {
+                mode: "restart",
+                reason: "openclaw-clawchat credentials changed",
+            },
             mutate(draft) {
                 Object.assign(draft, buildLoginConfig(draft, result));
             },
         });
+        params.runtime.log(`ClawChat credentials persisted for userId=${result.agent.user_id}.`);
         return;
     }
     if (params.persistConfig) {
+        params.runtime.log(`Persisting ClawChat credentials for userId=${result.agent.user_id}.`);
         await params.persistConfig(buildLoginConfig(params.cfg, result));
+        params.runtime.log(`ClawChat credentials persisted for userId=${result.agent.user_id}.`);
         return;
     }
     throw new Error("openclaw-clawchat: mutateConfigFile is required to persist login credentials");
 }
 /**
- * Run the `openclaw channels login --channel openclaw-clawchat` flow:
+ * Run the invite-code credential exchange used by `clawchat_activate`,
+ * `openclaw channels add --channel openclaw-clawchat --token <invite-code>`,
+ * and `openclaw channels login --channel openclaw-clawchat`:
  *   1. Read the existing channel section; require `baseUrl` to be set so we
  *      know which server to hit.
  *   2. Prompt the user for an invite code on stdin.

package/dist/src/media-runtime.js

@@ -1,3 +1,4 @@
+import { buildOutboundMediaLoadOptions, } from "openclaw/plugin-sdk/media-runtime";
 export function inferMediaKindFromMime(mime) {
     if (!mime)
         return "file";
@@ -56,12 +57,12 @@ export async function uploadOutboundMedia(urls, ctx) {
     const out = [];
     for (const url of urls) {
         try {
-            const loaded = await ctx.runtime.media.loadWebMedia(url, {
+            const loaded = await ctx.runtime.media.loadWebMedia(url, buildOutboundMediaLoadOptions({
                 maxBytes,
-                ...(ctx.mediaLocalRoots && ctx.mediaLocalRoots.length > 0
-                    ? { localRoots: ctx.mediaLocalRoots }
-                    : {}),
-            });
+                ...(ctx.mediaAccess ? { mediaAccess: ctx.mediaAccess } : {}),
+                ...(ctx.mediaLocalRoots ? { mediaLocalRoots: ctx.mediaLocalRoots } : {}),
+                ...(ctx.mediaReadFile ? { mediaReadFile: ctx.mediaReadFile } : {}),
+            }));
             const uploaded = await ctx.apiClient.uploadMedia({
                 buffer: loaded.buffer,
                 filename: loaded.fileName ?? "upload.bin",

package/dist/src/outbound.js

@@ -19,6 +19,8 @@ import { getOpenclawClawlingClient, getOpenclawClawlingRuntime, waitForOpenclawC
  *   - `clawchat:group:{chat_id}`      → group
  *   - `openclaw-clawchat:direct:{chat_id}` → direct
  *   - `openclaw-clawchat:group:{chat_id}`  → group
+ *   - `direct:{chat_id}`              → direct (host-normalized)
+ *   - `group:{chat_id}`               → group (host-normalized)
  *   - bare `{chat_id}`                → direct (backward compat)
  */
 export function parseOpenclawRecipient(to) {
@@ -30,6 +32,12 @@ export function parseOpenclawRecipient(to) {
         return { chatId: raw, chatType: "direct" };
     const scheme = raw.slice(0, firstColon).toLowerCase();
     const rest = raw.slice(firstColon + 1);
+    if (scheme === "direct" || scheme === "group") {
+        const chatId = rest.trim();
+        if (!chatId)
+            throw new Error(`openclaw-clawchat: missing chat_id in "${to}"`);
+        return { chatId, chatType: scheme };
+    }
     if (scheme !== "cc" && scheme !== "clawchat" && scheme !== CHANNEL_ID) {
         return { chatId: raw, chatType: "direct" };
     }
@@ -74,7 +82,7 @@ export async function sendOpenclawClawlingText(params) {
             mode: "normal",
             replyTo: {
                 msgId: params.replyCtx.replyToMessageId,
-                senderId: params.replyCtx.replyPreviewChatId ?? params.replyCtx.replyPreviewSenderId,
+                senderId: params.replyCtx.replyPreviewSenderId,
                 nickName: params.replyCtx.replyPreviewNickName,
                 fragments: [{ kind: "text", text: params.replyCtx.replyPreviewText }],
             },
@@ -144,7 +152,7 @@ export const openclawClawlingOutbound = {
                 messageId: result?.messageId ?? `${account.userId}-${Date.now()}`,
             };
         },
-        sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots }) => {
+        sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile }) => {
             const account = resolveOpenclawClawlingAccount(cfg);
             const client = getOpenclawClawlingClient(account.accountId) ??
                 (await waitForOpenclawClawlingClient(account.accountId));
@@ -160,7 +168,9 @@ export const openclawClawlingOutbound = {
             const mediaFragments = await uploadOutboundMedia([mediaUrl.trim()], {
                 apiClient,
                 runtime,
+                ...(mediaAccess ? { mediaAccess } : {}),
                 ...(mediaLocalRoots ? { mediaLocalRoots } : {}),
+                ...(mediaReadFile ? { mediaReadFile } : {}),
             });
             if (mediaFragments.length === 0) {
                 throw new Error(`openclaw-clawchat failed to upload media: ${mediaUrl}`);