@clawling/clawchat-plugin-openclaw 2026.5.12-28 → 2026.5.12-31

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CLAWLING PTE. LTD.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,12 +5,11 @@ OpenClaw channel plugin that connects an agent to ClawChat over ClawChat Protoco
 ## Features
 
 - Plugin-owned WebSocket transport with auto-reconnect (exponential backoff + jitter), heartbeat, and ack tracking
-- Invite-code onboarding — no raw credentials required
 - Inbound `message.send` / `message.reply` with reply context
 - 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 supported `openclaw channels add`, plus always-registered `clawchat_*` account/media tools
+- Invite-code onboarding (no raw credentials) via `/clawchat-activate` or supported `openclaw channels add`, plus always-registered `clawchat_*` account/media tools
 
 ## Install
 
@@ -21,13 +20,10 @@ npm i @clawling/clawchat-plugin-openclaw
 
 Requires `openclaw >= 2026.5.4` as a peer host.
 
-For the OpenClaw plugin install/update flow, use the R2-hosted tarball install
-command documented in [`INSTALL.md`](./INSTALL.md).
-
 Example LLM prompt:
 
 ```text
-Use https://raw.githubusercontent.com/clawling/clawchat-plugin-openclaw/refs/heads/main/INSTALL.md to install and activate the ClawChat plugin. The invite code is XXXXXX.
+Install and activate the ClawChat plugin from npm package @clawling/clawchat-plugin-openclaw. The invite code is XXXXXX.
 ```
 
 ## Current activation paths
@@ -166,7 +162,8 @@ npm run typecheck
 
 Tests live next to the source they cover (`*.test.ts`). The development entrypoint stays in TypeScript for the OpenClaw extension loader, while npm installs use the compiled runtime entrypoint generated by `npm run build` / `prepack` under `dist/`.
 
-Functional e2e test cases are documented in `.e2e/docs/install-clawchat-plugin-e2e.md`; keep that guide updated when adding or changing e2e flows.
+Functional E2E test cases are documented in the root ClawChat workspace E2E
+docs; keep that guide updated when adding or changing E2E flows.
 
 For OpenClaw host SDK/source lookup while developing this plugin, optionally
 clone OpenClaw into `tmp/openclaw`:
@@ -179,49 +176,6 @@ 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
-./scripts/package_openclaw_plugin.sh
-```
-
-The script runs `npm pack`, removes `devDependencies` from the generated `.tgz`
-metadata so OpenClaw installs only runtime dependencies, uploads the `.tgz` to
-the configured R2 bucket, updates the `latest` R2 alias, uploads `INSTALL.md` as
-`openclaw/install.md`, and prints the public URLs. R2 credentials are read from
-`scripts/.env.r2`, which is ignored by git. Copy `scripts/.env.r2.example` to
-`scripts/.env.r2` and fill in the credentials. 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 latest tarball on a device or container with OpenClaw
-available:
-
-```bash
-./scripts/install_openclaw.sh
-```
-
-To install a specific uploaded version, pass the version string:
-
-```bash
-./scripts/install_openclaw.sh 2026.5.16-1
-```
-
-To install a specific uploaded tarball URL, pass its URL explicitly:
-
-```bash
-./scripts/install_openclaw.sh https://plugin.clawling.chat/openclaw/newbase-clawchat-clawchat-plugin-openclaw-2026.5.16-1.tgz
-```
-
 ## License
 
 See the repository root.

package/dist/src/api-client.js

@@ -5,9 +5,16 @@ export function createOpenclawClawlingApiClient(opts) {
         throw new ClawlingApiError("validation", `clawchat-plugin-openclaw baseUrl must start with http:// or https:// (got "${opts.baseUrl}")`);
     }
     const baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    let mediaBaseUrl = baseUrl;
+    if (opts.mediaBaseUrl && opts.mediaBaseUrl.trim()) {
+        if (!/^https?:\/\//i.test(opts.mediaBaseUrl)) {
+            throw new ClawlingApiError("validation", `clawchat-plugin-openclaw mediaBaseUrl must start with http:// or https:// (got "${opts.mediaBaseUrl}")`);
+        }
+        mediaBaseUrl = opts.mediaBaseUrl.replace(/\/+$/, "");
+    }
     const fetchImpl = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
-    function url(path) {
-        return `${baseUrl}${path}`;
+    function url(path, base = baseUrl) {
+        return `${base}${path}`;
     }
     function authHeaders(extra = {}) {
         // `X-Device-Id` is sent on every request so the server can correlate
@@ -75,7 +82,7 @@ export function createOpenclawClawlingApiClient(opts) {
             if (init?.body !== undefined) {
                 requestInit.body = init.body;
             }
-            res = await fetchImpl(url(path), requestInit);
+            res = await fetchImpl(url(path, init?.baseUrl || undefined), requestInit);
         }
         catch (err) {
             throw new ClawlingApiError("transport", `fetch failed: ${err instanceof Error ? err.message : String(err)}`, { path });
@@ -148,6 +155,32 @@ export function createOpenclawClawlingApiClient(opts) {
         async listFriends() {
             return await call("GET", "/v1/friendships");
         },
+        async sendFriendRequest(params) {
+            assertNonBlankId(params.userId, "sendFriendRequest: userId");
+            return await call("POST", "/v1/friendships", {
+                body: JSON.stringify({
+                    user_id: params.userId,
+                    ...(typeof params.greeting === "string" ? { greeting: params.greeting } : {}),
+                }),
+                headers: { "content-type": "application/json" },
+            });
+        },
+        async listFriendRequests(params) {
+            if (params.direction !== "incoming" && params.direction !== "outgoing") {
+                throw new ClawlingApiError("validation", "listFriendRequests: direction must be incoming or outgoing");
+            }
+            return await call("GET", `/v1/friendships/requests/${params.direction}`);
+        },
+        async acceptFriendRequest(requestId) {
+            return await call("POST", `/v1/friendships/requests/${encodeURIComponent(String(requestId))}/accept`);
+        },
+        async rejectFriendRequest(requestId) {
+            return await call("POST", `/v1/friendships/requests/${encodeURIComponent(String(requestId))}/reject`);
+        },
+        async removeFriend(friendUserId) {
+            assertNonBlankId(friendUserId, "removeFriend: friendUserId");
+            return await call("DELETE", `/v1/friendships/${encodeURIComponent(friendUserId)}`);
+        },
         async searchUsers(params) {
             const sp = new URLSearchParams();
             if (typeof params.q === "string")
@@ -245,7 +278,7 @@ export function createOpenclawClawlingApiClient(opts) {
             });
             const fd = new FormData();
             fd.set("file", file);
-            const data = await call("POST", "/media/upload", { body: fd });
+            const data = await call("POST", "/media/upload", { body: fd, baseUrl: mediaBaseUrl });
             return parseUploadResult(data, "/media/upload");
         },
         async uploadAvatar(params) {

package/dist/src/channel.js

@@ -1,6 +1,6 @@
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
 import { createEmptyChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-runtime";
-import { CHANNEL_ID, resolveOpenclawClawlingAccount, } from "./config.js";
+import { CHANNEL_ID, canStartOpenclawClawlingAccount, resolveOpenclawClawlingAccount, } from "./config.js";
 import { openclawClawlingOutbound } from "./outbound.js";
 import { getOpenclawClawlingRuntime, startOpenclawClawlingGateway } from "./runtime.js";
 import { openclawClawlingSetupPlugin } from "./channel.setup.js";
@@ -27,9 +27,9 @@ export const openclawClawlingPlugin = createChatChannelPlugin({
             startAccount: async (ctx) => {
                 const account = ctx.account ?? resolveOpenclawClawlingAccount(ctx.cfg);
                 ctx.log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw lifecycle START_ACCOUNT_CALLED 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}] clawchat-plugin-openclaw lifecycle startAccount refused: websocketUrl/token/userId are required`);
-                    throw new Error("Clawling Chat websocketUrl/token/userId are required");
+                if (!canStartOpenclawClawlingAccount(account)) {
+                    ctx.log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw lifecycle startAccount refused: websocketUrl is required`);
+                    throw new Error("Clawling Chat websocketUrl is required");
                 }
                 try {
                     await startOpenclawClawlingGateway({

package/dist/src/channel.setup.js

@@ -2,7 +2,7 @@ import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-
 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, openclawClawlingConfigSchema, resolveOpenclawClawlingAccount, } from "./config.js";
+import { CHANNEL_ID, canStartOpenclawClawlingAccount, listOpenclawClawlingAccountIds, openclawClawlingConfigSchema, resolveOpenclawClawlingAccount, } from "./config.js";
 const configAdapter = createTopLevelChannelConfigAdapter({
     sectionKey: CHANNEL_ID,
     resolveAccount: (cfg) => resolveOpenclawClawlingAccount(cfg),
@@ -89,7 +89,7 @@ export const openclawClawlingSetupPlugin = {
     },
     config: {
         ...configAdapter,
-        isConfigured: (account) => account.configured,
+        isConfigured: (account) => canStartOpenclawClawlingAccount(account),
         describeAccount: (account) => ({
             accountId: account.accountId,
             name: account.name,

package/dist/src/commands.js

@@ -1,3 +1,4 @@
+import { CHANNEL_ID } from "./config.js";
 function extractInviteCode(value) {
     const raw = typeof value === "string" ? value.trim() : "";
     return raw.match(/\b[A-Z0-9]{6}\b/u)?.[0] ?? "";
@@ -5,6 +6,80 @@ function extractInviteCode(value) {
 function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }
+function readRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function extractOutputVisibility(value) {
+    const raw = typeof value === "string" ? value.trim().toLowerCase() : "";
+    const token = raw.split(/\s+/, 1)[0] ?? "";
+    return token === "minimal" || token === "normal" || token === "full" ? token : null;
+}
+function stripChannelPrefix(value) {
+    const raw = value.trim();
+    const prefix = `${CHANNEL_ID}:`;
+    return raw.startsWith(prefix) ? raw.slice(prefix.length) : raw;
+}
+function extractChatIdFromRoute(value) {
+    if (typeof value !== "string")
+        return "";
+    const stripped = stripChannelPrefix(value);
+    if (!stripped)
+        return "";
+    if (stripped.startsWith("group:"))
+        return stripped.slice("group:".length).trim();
+    if (stripped.startsWith("direct:"))
+        return stripped.slice("direct:".length).trim();
+    return stripped.trim();
+}
+function resolveCommandChatId(ctx) {
+    return extractChatIdFromRoute(ctx.from)
+        || extractChatIdFromRoute(ctx.to)
+        || (typeof ctx.threadParentId === "string" ? ctx.threadParentId.trim() : "")
+        || (typeof ctx.messageThreadId === "string" || typeof ctx.messageThreadId === "number"
+            ? String(ctx.messageThreadId).trim()
+            : "");
+}
+function persistOutputVisibility(draft, chatId, outputVisibility) {
+    const channels = readRecord(draft.channels);
+    const channel = readRecord(channels[CHANNEL_ID]);
+    const chats = readRecord(channel.chats);
+    const chat = readRecord(chats[chatId]);
+    Object.assign(draft, {
+        ...draft,
+        channels: {
+            ...channels,
+            [CHANNEL_ID]: {
+                ...channel,
+                chats: {
+                    ...chats,
+                    [chatId]: {
+                        ...chat,
+                        outputVisibility,
+                    },
+                },
+            },
+        },
+    });
+}
+function formatOutputVisibilityResult(outputVisibility) {
+    const runtimeStatus = outputVisibility === "full" ? "on" : "off";
+    const detailLevel = {
+        minimal: "quiet",
+        normal: "normal",
+        full: "verbose",
+    };
+    return [
+        "**ClawChat output updated**",
+        "",
+        `- visibility: \`${outputVisibility}\``,
+        `- runtime status: \`${runtimeStatus}\``,
+        `- detail level: \`${detailLevel[outputVisibility]}\``,
+        "",
+        "Applies to new ClawChat messages.",
+    ].join("\n");
+}
 export function registerOpenclawClawlingCommands(api) {
     api.registerCommand({
         name: "clawchat-activate",
@@ -32,4 +107,31 @@ export function registerOpenclawClawlingCommands(api) {
             }
         },
     });
+    api.registerCommand({
+        name: "clawchat-output",
+        description: "Set ClawChat output visibility for the current conversation.",
+        acceptsArgs: true,
+        requireAuth: true,
+        async handler(ctx) {
+            const outputVisibility = extractOutputVisibility(ctx.args ?? ctx.commandBody);
+            if (!outputVisibility) {
+                return { text: "Usage: /clawchat-output minimal|normal|full" };
+            }
+            const chatId = resolveCommandChatId(ctx);
+            if (!chatId) {
+                return { text: "Unable to determine the current ClawChat conversation for /clawchat-output." };
+            }
+            const mutateConfigFile = api.runtime.config.mutateConfigFile;
+            if (!mutateConfigFile) {
+                return { text: "OpenClaw runtime config mutation is unavailable for /clawchat-output." };
+            }
+            await mutateConfigFile({
+                afterWrite: { mode: "auto" },
+                mutate(draft) {
+                    persistOutputVisibility(draft, chatId, outputVisibility);
+                },
+            });
+            return { text: formatOutputVisibilityResult(outputVisibility) };
+        },
+    });
 }

package/dist/src/config.js

@@ -7,6 +7,7 @@ export const CLAWCHAT_OWNER_USER_ID_ENV = "CLAWCHAT_OWNER_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";
+export const CLAWCHAT_MEDIA_BASE_URL_ENV = "CLAWCHAT_MEDIA_BASE_URL";
 /**
  * Built-in defaults for the Clawling Chat endpoints so `openclaw channel
  * login` works out of the box without requiring a prior `openclaw channel
@@ -46,11 +47,23 @@ export const openclawClawlingConfigSchema = {
         enabled: { type: "boolean" },
         websocketUrl: { type: "string" },
         baseUrl: { type: "string" },
+        mediaBaseUrl: { type: "string" },
         token: { type: "string" },
         refreshToken: { type: "string" },
         agentId: { type: "string" },
         userId: { type: "string" },
         ownerUserId: { type: "string" },
+        outputVisibility: { type: "string", enum: ["minimal", "normal", "full"] },
+        chats: {
+            type: "object",
+            additionalProperties: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    outputVisibility: { type: "string", enum: ["minimal", "normal", "full"] },
+                },
+            },
+        },
         groupMode: { type: "string", enum: ["mention", "all"] },
         groupCommandMode: { type: "string", enum: ["owner", "all", "off"] },
         groups: {
@@ -61,6 +74,7 @@ export const openclawClawlingConfigSchema = {
                 properties: {
                     groupMode: { type: "string", enum: ["mention", "all"] },
                     groupCommandMode: { type: "string", enum: ["owner", "all", "off"] },
+                    outputVisibility: { type: "string", enum: ["minimal", "normal", "full"] },
                 },
             },
         },
@@ -154,6 +168,12 @@ export function mergeOpenclawClawchatRuntimePluginActivation(cfg) {
         plugins: nextPlugins,
     };
 }
+export function hasOpenclawClawlingConnectCredentials(account) {
+    return Boolean(account.websocketUrl && account.token && account.userId && account.ownerUserId);
+}
+export function canStartOpenclawClawlingAccount(account) {
+    return Boolean(account.enabled && account.websocketUrl);
+}
 function readChannelSection(cfg) {
     const channels = (cfg.channels ?? {});
     const channel = channels[CHANNEL_ID];
@@ -235,6 +255,7 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
     const baseUrl = readOptionalString(channel.baseUrl) ||
         readEnvString(env, CLAWCHAT_BASE_URL_ENV) ||
         DEFAULT_BASE_URL;
+    const mediaBaseUrl = readOptionalString(channel.mediaBaseUrl) || readEnvString(env, CLAWCHAT_MEDIA_BASE_URL_ENV);
     const token = readOptionalString(channel.token) || readEnvString(env, CLAWCHAT_TOKEN_ENV);
     const agentId = readOptionalString(channel.agentId) || readEnvString(env, CLAWCHAT_AGENT_ID_ENV);
     const userId = readOptionalString(channel.userId) || readEnvString(env, CLAWCHAT_USER_ID_ENV);
@@ -250,9 +271,15 @@ export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
         accountId: DEFAULT_ACCOUNT_ID,
         name: CHANNEL_ID,
         enabled,
-        configured: Boolean(websocketUrl && token && userId && ownerUserId),
+        configured: hasOpenclawClawlingConnectCredentials({
+            websocketUrl,
+            token,
+            userId,
+            ownerUserId,
+        }),
         websocketUrl,
         baseUrl,
+        mediaBaseUrl,
         token,
         agentId,
         userId,

package/dist/src/group-message-coalescer.js

@@ -1,11 +1,3 @@
-function formatTurnTime(timestamp) {
-    if (!Number.isFinite(timestamp))
-        return "unknown-time";
-    const time = new Date(timestamp);
-    if (Number.isNaN(time.getTime()))
-        return "unknown-time";
-    return time.toISOString();
-}
 function formatSenderRelation(turn) {
     return turn.senderRelation || "peer_user";
 }
@@ -21,40 +13,31 @@ function formatMessageBody(rawBody) {
 function formatField(value) {
     return value.replace(/\\/g, "\\\\").replace(/\r/g, "\\r").replace(/\n/g, "\\n");
 }
-function formatMentionedUsers(turn) {
-    const mentionedUsers = turn.mentionedUsers && turn.mentionedUsers.length > 0
-        ? turn.mentionedUsers
-        : turn.mentionedUserIds.map((id) => ({ id }));
-    if (mentionedUsers.length === 0)
-        return "-";
-    return mentionedUsers.map((mention) => {
-        const id = formatField(mention.id);
-        const display = mention.display?.trim();
-        return display ? `${id}(${formatField(display)})` : id;
-    }).join(",");
-}
 export function formatCoalescedGroupBody(turns, timing = { idleSeconds: 10, maxWaitSeconds: 30 }) {
-    const header = `ClawChat group batch (${turns.length} ${turns.length === 1 ? "message" : "messages"}, ${timing.idleSeconds}s idle, ${timing.maxWaitSeconds}s max):`;
+    void timing;
     return [
-        header,
-        turns.map((turn) => {
+        "ClawChat group messages:",
+        turns.map((turn, index) => {
             const senderName = turn.senderNickName || turn.senderId;
-            const senderIsAgentOwner = turn.senderIsOwner ?? formatSenderRelation(turn) === "owner";
-            return [
-                "[message]",
-                `sender_id: ${formatField(turn.senderId)}`,
-                `sender_name: ${formatField(senderName)}`,
-                `sender_profile_type: ${formatField(formatSenderProfileType(turn))}`,
-                `sender_is_agent_owner: ${senderIsAgentOwner ? "true" : "false"}`,
-                `sender_is_group_owner: ${turn.senderIsGroupOwner ? "true" : "false"}`,
-                `mentions_current_agent: ${turn.wasMentioned ? "true" : "false"}`,
-                `mentioned_users: ${formatMentionedUsers(turn)}`,
-                "text:",
-                formatMessageBody(turn.rawBody),
-            ].join("\n");
-        }).join("\n\n"),
+            const label = `[message ${index + 1}] ${formatField(senderName)}:`;
+            const body = formatMessageBody(turn.rawBody);
+            return body.includes("\n") ? `${label}\n${body}` : `${label} ${body}`;
+        }).join("\n"),
     ].join("\n");
 }
+function groupMessageForPrompt(turn) {
+    return {
+        senderId: turn.senderId,
+        senderName: turn.senderNickName || turn.senderId,
+        senderRelation: turn.senderRelation,
+        senderProfileType: formatSenderProfileType(turn),
+        senderIsOwner: turn.senderIsOwner ?? formatSenderRelation(turn) === "owner",
+        senderIsGroupOwner: turn.senderIsGroupOwner,
+        wasMentioned: turn.wasMentioned,
+        mentionedUserIds: turn.mentionedUserIds,
+        mentionedUsers: turn.mentionedUsers,
+    };
+}
 export function mergeGroupTurns(turns, timing = { idleSeconds: 10, maxWaitSeconds: 30 }) {
     if (turns.length === 0)
         throw new Error("cannot merge empty group turn batch");
@@ -62,6 +45,7 @@ export function mergeGroupTurns(turns, timing = { idleSeconds: 10, maxWaitSecond
     return {
         ...latest,
         rawBody: formatCoalescedGroupBody(turns, timing),
+        groupMessages: turns.map(groupMessageForPrompt),
         mediaItems: turns.flatMap((turn) => turn.mediaItems),
         wasMentioned: turns.some((turn) => turn.wasMentioned),
         mentionedUserIds: Array.from(new Set(turns.flatMap((turn) => turn.mentionedUserIds))),

package/dist/src/login.runtime.js

@@ -131,6 +131,7 @@ export async function runOpenclawClawlingLogin(params) {
     }
     const apiClient = (params.apiClientFactory ?? createOpenclawClawlingApiClient)({
         baseUrl: account.baseUrl,
+        mediaBaseUrl: account.mediaBaseUrl,
         // Pre-login we may not have a token yet. Send the current one (or empty)
         // — the server should accept an unauthenticated invite-code exchange.
         token: account.token || "",

package/dist/src/outbound.js

@@ -581,6 +581,7 @@ export const openclawClawlingOutbound = {
             const runtime = getOpenclawClawlingRuntime();
             const apiClient = createOpenclawClawlingApiClient({
                 baseUrl: account.baseUrl,
+                mediaBaseUrl: account.mediaBaseUrl,
                 token: account.token,
                 userId: account.userId,
             });