@clawling/clawchat-plugin-openclaw 2026.9.11-1 → 2026.9.13-2

package/dist/src/tools.js

@@ -5,7 +5,7 @@ import { createOpenclawClawlingApiClient } from "./api-client.js";
 import { resolveLivewarePath } from "./liveware-cli.js";
 import { ClawlingApiError, } from "./api-types.js";
 import { mapGateOutcome } from "./gate-outcome.js";
-import { resolveOpenclawClawlingAccount } from "./config.js";
+import { CHANNEL_ID, normalizeOpenclawClawlingAccountId, resolveOpenclawClawlingAccount, } from "./config.js";
 import { clawChatDbPathForStateDir, getClawChatStore, makeOwnerProfilePersister, } from "./storage.js";
 import { sendOpenclawClawlingMentionMessage, sendOpenclawClawlingReaction } from "./outbound.js";
 import { getOpenclawClawlingClient, } from "./runtime.js";
@@ -166,14 +166,38 @@ function validateMentionMessageParams(params) {
     }
     return { ok: true, params: p };
 }
+/**
+ * Account a tool call belongs to, or `null` when the call carries no ClawChat
+ * context (the caller then falls back to the configured default account).
+ *
+ * Both context fields are only meaningful when they describe THIS channel:
+ * `agentAccountId` is the originating session's account id, so a turn that
+ * arrived over Telegram/Discord would otherwise hand us that channel's account
+ * id as if it were one of ours.
+ */
+export function resolveOpenclawClawlingToolAccountId(ctx) {
+    const delivery = ctx.deliveryContext;
+    if (delivery &&
+        delivery.channel === CHANNEL_ID &&
+        typeof delivery.accountId === "string" &&
+        delivery.accountId.trim()) {
+        return normalizeOpenclawClawlingAccountId(delivery.accountId);
+    }
+    if (ctx.messageChannel === CHANNEL_ID &&
+        typeof ctx.agentAccountId === "string" &&
+        ctx.agentAccountId.trim()) {
+        return normalizeOpenclawClawlingAccountId(ctx.agentAccountId);
+    }
+    return null;
+}
 export function registerOpenclawClawlingTools(api, options = {}) {
     if (!api.config) {
         api.logger.debug?.("clawchat-plugin-openclaw: api.config missing; skipping tool registration");
         return;
     }
     // Re-resolve at call time so config reloads pick up new tokens / baseUrl.
-    function resolveCurrent() {
-        return resolveOpenclawClawlingAccount(api.config);
+    function resolveCurrent(accountId) {
+        return resolveOpenclawClawlingAccount(api.config, accountId);
     }
     function resolveStore() {
         if ("store" in options)
@@ -208,9 +232,9 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             api.logger.error?.("clawchat-plugin-openclaw sqlite tool call insert failed; continuing");
         }
     }
-    async function recordClawchatToolCall(toolName, params, fn) {
+    async function recordClawchatToolCall(accountId, toolName, params, fn) {
         const startedAt = Date.now();
-        const account = resolveCurrent();
+        const account = resolveCurrent(accountId);
         try {
             const result = await fn();
             const details = result.details ?? result;
@@ -240,8 +264,8 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             throw err;
         }
     }
-    function buildClient() {
-        const acct = resolveCurrent();
+    function buildClient(accountId) {
+        const acct = resolveCurrent(accountId);
         // `baseUrl` always resolves via the built-in default in config.ts, so we
         // only need to gate on `token` here (which is populated by ClawChat
         // activation/login).
@@ -257,9 +281,9 @@ export function registerOpenclawClawlingTools(api, options = {}) {
             }),
         };
     }
-    function withClient(fn) {
+    function withClient(accountId, fn) {
         return (async () => {
-            const built = buildClient();
+            const built = buildClient(accountId);
             if (!built.ok)
                 return built.error;
             try {
@@ -278,9 +302,9 @@ export function registerOpenclawClawlingTools(api, options = {}) {
      * via mapGateOutcome so the agent sees a clear pending/forbidden status
      * instead of a generic error. Used for friend and moment mutation tools.
      */
-    function withGatedClient(fn) {
+    function withGatedClient(accountId, fn) {
         return (async () => {
-            const built = buildClient();
+            const built = buildClient(accountId);
             if (!built.ok)
                 return built.error;
             try {
@@ -502,739 +526,829 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                 }
             },
         }), { name: "clawchat_memory_edit" });
-        api.registerTool((ctx) => ({
-            name: "clawchat_metadata_sync",
-            label: "Sync ClawChat Metadata",
-            description: memoryToolDescription("Synchronize the ClawChat metadata block for an explicit owner, user, or group target. " +
-                "Use direction=pull when the user asks to refresh, sync, or update local ClawChat current agent profile/behavior, agent-owner profile information, user information, or group information from the server; this fetches the authoritative server record and rewrites only the metadata block. " +
-                "Use direction=push only to push selected existing local metadata fields to the server, then refresh the metadata block from the server response. " +
-                "For direction=push, pass non-empty fields containing only pushable metadata field names: owner supports agent_behavior only; user supports nickname/avatar_url/bio for the connected account only; group supports group_title/group_description. " +
-                "This does not modify the agent-authored body. " +
-                "This synchronizes only the metadata block. It does not search or read agent-authored long-term memory body. For remembered aliases or local notes, use clawchat_memory_search or clawchat_memory_read. " +
-                "Do not combine clawchat_get_user_profile with clawchat_memory_write to update local profile metadata."),
-            parameters: ClawchatMetadataSyncSchema,
-            async execute(_callId, params) {
-                const root = workspaceRoot(ctx);
-                if (!root) {
-                    return validationError("clawchat-plugin-openclaw: OpenClaw workspaceDir is required");
-                }
-                const built = buildClient();
-                if (!built.ok)
-                    return built.error;
-                try {
-                    const p = params;
-                    const targetError = validateTarget(root, p);
-                    if (targetError)
-                        return memoryToolError(new Error(targetError));
-                    const account = resolveCurrent();
-                    if (p.direction === "push") {
-                        if (!Array.isArray(p.fields) || p.fields.length === 0) {
-                            return validationError("clawchat-plugin-openclaw: fields are required for metadata push");
+        api.registerTool((ctx) => {
+            const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+            return {
+                name: "clawchat_metadata_sync",
+                label: "Sync ClawChat Metadata",
+                description: memoryToolDescription("Synchronize the ClawChat metadata block for an explicit owner, user, or group target. " +
+                    "Use direction=pull when the user asks to refresh, sync, or update local ClawChat current agent profile/behavior, agent-owner profile information, user information, or group information from the server; this fetches the authoritative server record and rewrites only the metadata block. " +
+                    "Use direction=push only to push selected existing local metadata fields to the server, then refresh the metadata block from the server response. " +
+                    "For direction=push, pass non-empty fields containing only pushable metadata field names: owner supports agent_behavior only; user supports nickname/avatar_url/bio for the connected account only; group supports group_title/group_description. " +
+                    "This does not modify the agent-authored body. " +
+                    "This synchronizes only the metadata block. It does not search or read agent-authored long-term memory body. For remembered aliases or local notes, use clawchat_memory_search or clawchat_memory_read. " +
+                    "Do not combine clawchat_get_user_profile with clawchat_memory_write to update local profile metadata."),
+                parameters: ClawchatMetadataSyncSchema,
+                async execute(_callId, params) {
+                    const root = workspaceRoot(ctx);
+                    if (!root) {
+                        return validationError("clawchat-plugin-openclaw: OpenClaw workspaceDir is required");
+                    }
+                    const built = buildClient(accountId);
+                    if (!built.ok)
+                        return built.error;
+                    try {
+                        const p = params;
+                        const targetError = validateTarget(root, p);
+                        if (targetError)
+                            return memoryToolError(new Error(targetError));
+                        const account = resolveCurrent(accountId);
+                        if (p.direction === "push") {
+                            if (!Array.isArray(p.fields) || p.fields.length === 0) {
+                                return validationError("clawchat-plugin-openclaw: fields are required for metadata push");
+                            }
+                            if (p.targetType === "owner" && !account.agentId) {
+                                return configError("clawchat-plugin-openclaw: agentId is required");
+                            }
+                            if (p.targetType === "user" && !account.userId) {
+                                return configError("clawchat-plugin-openclaw: userId is required");
+                            }
+                            return jsonResponse(await pushMetadata({
+                                memoryRoot: root,
+                                targetType: p.targetType,
+                                targetId: p.targetId,
+                                fields: p.fields,
+                                agentId: account.agentId,
+                                accountUserId: account.userId,
+                                api: built.client,
+                            }));
+                        }
+                        if (p.targetType === "owner") {
+                            if (!account.agentId)
+                                return configError("clawchat-plugin-openclaw: agentId is required");
+                            return jsonResponse(await pullOwnerMetadata({
+                                memoryRoot: root,
+                                agentId: account.agentId,
+                                accountUserId: account.userId,
+                                accountOwnerUserId: account.ownerUserId || undefined,
+                                api: built.client,
+                            }));
                         }
+                        if (p.targetType === "user") {
+                            return jsonResponse(await pullUserMetadata({ memoryRoot: root, userId: p.targetId, api: built.client }));
+                        }
+                        return jsonResponse(await pullGroupMetadata({
+                            memoryRoot: root,
+                            groupId: p.targetId,
+                            api: built.client,
+                            skipUserIds: [account.userId, account.ownerUserId],
+                        }));
+                    }
+                    catch (err) {
+                        return memoryToolError(err);
+                    }
+                },
+            };
+        }, { name: "clawchat_metadata_sync" });
+        api.registerTool((ctx) => {
+            const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+            return {
+                name: "clawchat_metadata_update",
+                label: "Update ClawChat Metadata",
+                description: memoryToolDescription("Update ClawChat server metadata for an explicit owner, connected user account, or group target, then refresh the local metadata block from the server response. " +
+                    "Use this only when the user wants to change server-side metadata fields: current agent behavior via owner target agent_behavior, connected-user nickname/avatar_url/bio, or group group_title/group_description. " +
+                    "To refresh local metadata from the server without changing the server, use clawchat_metadata_sync with direction=pull. " +
+                    "This always pushes to the server first and does not modify the agent-authored body."),
+                parameters: ClawchatMetadataUpdateSchema,
+                async execute(_callId, params) {
+                    const root = workspaceRoot(ctx);
+                    if (!root) {
+                        return validationError("clawchat-plugin-openclaw: OpenClaw workspaceDir is required");
+                    }
+                    const built = buildClient(accountId);
+                    if (!built.ok)
+                        return built.error;
+                    try {
+                        const p = params;
+                        const targetError = validateTarget(root, p);
+                        if (targetError)
+                            return memoryToolError(new Error(targetError));
+                        const patchError = validateMetadataUpdatePatch(p);
+                        if (patchError)
+                            return validationError(patchError);
+                        const account = resolveCurrent(accountId);
                         if (p.targetType === "owner" && !account.agentId) {
                             return configError("clawchat-plugin-openclaw: agentId is required");
                         }
                         if (p.targetType === "user" && !account.userId) {
                             return configError("clawchat-plugin-openclaw: userId is required");
                         }
-                        return jsonResponse(await pushMetadata({
+                        return jsonResponse(await updateMetadata({
                             memoryRoot: root,
                             targetType: p.targetType,
                             targetId: p.targetId,
-                            fields: p.fields,
                             agentId: account.agentId,
                             accountUserId: account.userId,
+                            patch: p.patch,
                             api: built.client,
+                            persistOwnerProfile: makeOwnerProfilePersister(getClawChatStore(), {
+                                accountId: account.accountId,
+                            }),
                         }));
                     }
-                    if (p.targetType === "owner") {
-                        if (!account.agentId)
-                            return configError("clawchat-plugin-openclaw: agentId is required");
-                        return jsonResponse(await pullOwnerMetadata({
-                            memoryRoot: root,
-                            agentId: account.agentId,
-                            accountUserId: account.userId,
-                            accountOwnerUserId: account.ownerUserId || undefined,
-                            api: built.client,
-                        }));
-                    }
-                    if (p.targetType === "user") {
-                        return jsonResponse(await pullUserMetadata({ memoryRoot: root, userId: p.targetId, api: built.client }));
+                    catch (err) {
+                        return memoryToolError(err);
                     }
-                    return jsonResponse(await pullGroupMetadata({
-                        memoryRoot: root,
-                        groupId: p.targetId,
-                        api: built.client,
-                        skipUserIds: [account.userId, account.ownerUserId],
-                    }));
-                }
-                catch (err) {
-                    return memoryToolError(err);
-                }
+                },
+            };
+        }, { name: "clawchat_metadata_update" });
+    }
+    registerMemoryTools();
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_get_account_profile",
+            label: "Get ClawChat Account Profile",
+            description: toolDescription("Fetch the agent's connected ClawChat account profile (the configured ClawChat account: user id, nickname/display name, avatar, bio). " +
+                "This profile is the platform-side mirror of the local assistant identity; if fields are missing, report them as unset instead of inventing values. " +
+                "TRIGGER — invoke when the user asks for the ClawChat account/profile connected to this agent, " +
+                "such as 'show my ClawChat profile', 'what is the configured ClawChat account?', " +
+                "'show the current ClawChat account details', or 'show the ClawChat nickname, avatar, and bio'. " +
+                "Do not frame this as a human user's personal account."),
+            parameters: ClawchatGetAccountProfileSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_get_account_profile", params, async () => withClient(accountId, (c) => c.getMyProfile()));
             },
-        }), { name: "clawchat_metadata_sync" });
-        api.registerTool((ctx) => ({
-            name: "clawchat_metadata_update",
-            label: "Update ClawChat Metadata",
-            description: memoryToolDescription("Update ClawChat server metadata for an explicit owner, connected user account, or group target, then refresh the local metadata block from the server response. " +
-                "Use this only when the user wants to change server-side metadata fields: current agent behavior via owner target agent_behavior, connected-user nickname/avatar_url/bio, or group group_title/group_description. " +
-                "To refresh local metadata from the server without changing the server, use clawchat_metadata_sync with direction=pull. " +
-                "This always pushes to the server first and does not modify the agent-authored body."),
-            parameters: ClawchatMetadataUpdateSchema,
+        };
+    }, { name: "clawchat_get_account_profile" });
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_get_user_profile",
+            label: "Get ClawChat User Profile",
+            description: toolDescription("Fetch a ClawChat user's server-side public profile by explicit userId. " +
+                "TRIGGER — invoke when the user asks to view or inspect a specific ClawChat user's public profile and provides a concrete userId, or after clawchat_search_users returns a userId. " +
+                "Do not guess or infer userId from nickname, display name, alias, or local memory text. " +
+                "This is a read-only lookup and server lookup. It does not read local ClawChat memory files and does not update local metadata. " +
+                "When the user asks to refresh, sync, or update that user's local profile information, call clawchat_metadata_sync with targetType=user, that targetId, and direction=pull. " +
+                "Use `clawchat_get_account_profile` for the agent's own connected ClawChat account unless an explicit userId is provided."),
+            parameters: ClawchatGetUserProfileSchema,
             async execute(_callId, params) {
-                const root = workspaceRoot(ctx);
-                if (!root) {
-                    return validationError("clawchat-plugin-openclaw: OpenClaw workspaceDir is required");
-                }
-                const built = buildClient();
-                if (!built.ok)
-                    return built.error;
-                try {
+                return await recordClawchatToolCall(accountId, "clawchat_get_user_profile", params, async () => {
                     const p = params;
-                    const targetError = validateTarget(root, p);
-                    if (targetError)
-                        return memoryToolError(new Error(targetError));
-                    const patchError = validateMetadataUpdatePatch(p);
-                    if (patchError)
-                        return validationError(patchError);
-                    const account = resolveCurrent();
-                    if (p.targetType === "owner" && !account.agentId) {
-                        return configError("clawchat-plugin-openclaw: agentId is required");
-                    }
-                    if (p.targetType === "user" && !account.userId) {
-                        return configError("clawchat-plugin-openclaw: userId is required");
-                    }
-                    return jsonResponse(await updateMetadata({
-                        memoryRoot: root,
-                        targetType: p.targetType,
-                        targetId: p.targetId,
-                        agentId: account.agentId,
-                        accountUserId: account.userId,
-                        patch: p.patch,
-                        api: built.client,
-                        persistOwnerProfile: makeOwnerProfilePersister(getClawChatStore(), {
-                            accountId: account.accountId,
-                        }),
-                    }));
-                }
-                catch (err) {
-                    return memoryToolError(err);
-                }
+                    return await withClient(accountId, (c) => c.getUserInfo(p.userId));
+                });
             },
-        }), { name: "clawchat_metadata_update" });
-    }
-    registerMemoryTools();
-    api.registerTool({
-        name: "clawchat_get_account_profile",
-        label: "Get ClawChat Account Profile",
-        description: toolDescription("Fetch the agent's connected ClawChat account profile (the configured ClawChat account: user id, nickname/display name, avatar, bio). " +
-            "This profile is the platform-side mirror of the local assistant identity; if fields are missing, report them as unset instead of inventing values. " +
-            "TRIGGER — invoke when the user asks for the ClawChat account/profile connected to this agent, " +
-            "such as 'show my ClawChat profile', 'what is the configured ClawChat account?', " +
-            "'show the current ClawChat account details', or 'show the ClawChat nickname, avatar, and bio'. " +
-            "Do not frame this as a human user's personal account."),
-        parameters: ClawchatGetAccountProfileSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_get_account_profile", params, async () => withClient((c) => c.getMyProfile()));
-        },
-    }, { name: "clawchat_get_account_profile" });
-    api.registerTool({
-        name: "clawchat_get_user_profile",
-        label: "Get ClawChat User Profile",
-        description: toolDescription("Fetch a ClawChat user's server-side public profile by explicit userId. " +
-            "TRIGGER — invoke when the user asks to view or inspect a specific ClawChat user's public profile and provides a concrete userId, or after clawchat_search_users returns a userId. " +
-            "Do not guess or infer userId from nickname, display name, alias, or local memory text. " +
-            "This is a read-only lookup and server lookup. It does not read local ClawChat memory files and does not update local metadata. " +
-            "When the user asks to refresh, sync, or update that user's local profile information, call clawchat_metadata_sync with targetType=user, that targetId, and direction=pull. " +
-            "Use `clawchat_get_account_profile` for the agent's own connected ClawChat account unless an explicit userId is provided."),
-        parameters: ClawchatGetUserProfileSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_get_user_profile", params, async () => {
-                const p = params;
-                return await withClient((c) => c.getUserInfo(p.userId));
-            });
-        },
+        };
     }, { name: "clawchat_get_user_profile" });
-    api.registerTool({
-        name: "clawchat_list_account_friends",
-        label: "List ClawChat Account Friends",
-        description: toolDescription("List friends/contacts of the agent's connected ClawChat account (the configured ClawChat account). " +
-            "These are the agent's ClawChat-platform contacts. " +
-            "TRIGGER — invoke when the user asks for this ClawChat account's friends, contacts, or friend list."),
-        parameters: ClawchatListAccountFriendsSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_list_account_friends", params, async () => withClient((c) => c.listFriends()));
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_list_account_friends",
+            label: "List ClawChat Account Friends",
+            description: toolDescription("List friends/contacts of the agent's connected ClawChat account (the configured ClawChat account). " +
+                "These are the agent's ClawChat-platform contacts. " +
+                "TRIGGER — invoke when the user asks for this ClawChat account's friends, contacts, or friend list."),
+            parameters: ClawchatListAccountFriendsSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_list_account_friends", params, async () => withClient(accountId, (c) => c.listFriends()));
+            },
+        };
     }, { name: "clawchat_list_account_friends" });
-    api.registerTool({
-        name: "clawchat_send_friend_request",
-        label: "Send ClawChat Friend Request",
-        description: toolDescription("Send a friend request from the connected ClawChat account to a specific user by explicit userId. " +
-            "TRIGGER - invoke when the user asks to add, friend, connect with, or send a friend request to a ClawChat user and provides a concrete userId, or after clawchat_search_users returns a selected userId. " +
-            "Do not guess or infer userId from nickname, display name, alias, or local memory text; search first when needed."),
-        parameters: ClawchatSendFriendRequestSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_send_friend_request", params, async () => {
-                const p = params;
-                return await withGatedClient((c) => c.sendFriendRequest(p));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_send_friend_request",
+            label: "Send ClawChat Friend Request",
+            description: toolDescription("Send a friend request from the connected ClawChat account to a specific user by explicit userId. " +
+                "TRIGGER - invoke when the user asks to add, friend, connect with, or send a friend request to a ClawChat user and provides a concrete userId, or after clawchat_search_users returns a selected userId. " +
+                "Do not guess or infer userId from nickname, display name, alias, or local memory text; search first when needed."),
+            parameters: ClawchatSendFriendRequestSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_send_friend_request", params, async () => {
+                    const p = params;
+                    return await withGatedClient(accountId, (c) => c.sendFriendRequest(p));
+                });
+            },
+        };
     }, { name: "clawchat_send_friend_request" });
-    api.registerTool({
-        name: "clawchat_list_friend_requests",
-        label: "List ClawChat Friend Requests",
-        description: toolDescription("List pending friend requests for the connected ClawChat account. " +
-            "Use direction='incoming' for requests other users sent to this account, and direction='outgoing' for requests this account sent to other users. Defaults to incoming. " +
-            "TRIGGER - invoke when the user asks to view, check, review, or list friend requests, pending requests, incoming requests, or outgoing requests."),
-        parameters: ClawchatListFriendRequestsSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_list_friend_requests", params, async () => {
-                const p = (params ?? {});
-                return await withClient((c) => c.listFriendRequests({ direction: p.direction ?? "incoming" }));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_list_friend_requests",
+            label: "List ClawChat Friend Requests",
+            description: toolDescription("List pending friend requests for the connected ClawChat account. " +
+                "Use direction='incoming' for requests other users sent to this account, and direction='outgoing' for requests this account sent to other users. Defaults to incoming. " +
+                "TRIGGER - invoke when the user asks to view, check, review, or list friend requests, pending requests, incoming requests, or outgoing requests."),
+            parameters: ClawchatListFriendRequestsSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_list_friend_requests", params, async () => {
+                    const p = (params ?? {});
+                    return await withClient(accountId, (c) => c.listFriendRequests({ direction: p.direction ?? "incoming" }));
+                });
+            },
+        };
     }, { name: "clawchat_list_friend_requests" });
-    api.registerTool({
-        name: "clawchat_accept_friend_request",
-        label: "Accept ClawChat Friend Request",
-        description: toolDescription("Accept one pending incoming friend request by exact requestId. " +
-            "TRIGGER - invoke when the user asks to accept, approve, or pass a friend request and provides or selects a concrete requestId returned by clawchat_list_friend_requests. " +
-            "List incoming requests first when the target is ambiguous."),
-        parameters: ClawchatAcceptFriendRequestSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_accept_friend_request", params, async () => {
-                const p = params;
-                return await withGatedClient((c) => c.acceptFriendRequest(p.requestId));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_accept_friend_request",
+            label: "Accept ClawChat Friend Request",
+            description: toolDescription("Accept one pending incoming friend request by exact requestId. " +
+                "TRIGGER - invoke when the user asks to accept, approve, or pass a friend request and provides or selects a concrete requestId returned by clawchat_list_friend_requests. " +
+                "List incoming requests first when the target is ambiguous."),
+            parameters: ClawchatAcceptFriendRequestSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_accept_friend_request", params, async () => {
+                    const p = params;
+                    return await withGatedClient(accountId, (c) => c.acceptFriendRequest(p.requestId));
+                });
+            },
+        };
     }, { name: "clawchat_accept_friend_request" });
-    api.registerTool({
-        name: "clawchat_reject_friend_request",
-        label: "Reject ClawChat Friend Request",
-        description: toolDescription("Reject one pending incoming friend request by exact requestId. " +
-            "TRIGGER - invoke when the user asks to reject, decline, refuse, or ignore a friend request and provides or selects a concrete requestId returned by clawchat_list_friend_requests. " +
-            "List incoming requests first when the target is ambiguous."),
-        parameters: ClawchatRejectFriendRequestSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_reject_friend_request", params, async () => {
-                const p = params;
-                return await withGatedClient((c) => c.rejectFriendRequest(p.requestId));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_reject_friend_request",
+            label: "Reject ClawChat Friend Request",
+            description: toolDescription("Reject one pending incoming friend request by exact requestId. " +
+                "TRIGGER - invoke when the user asks to reject, decline, refuse, or ignore a friend request and provides or selects a concrete requestId returned by clawchat_list_friend_requests. " +
+                "List incoming requests first when the target is ambiguous."),
+            parameters: ClawchatRejectFriendRequestSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_reject_friend_request", params, async () => {
+                    const p = params;
+                    return await withGatedClient(accountId, (c) => c.rejectFriendRequest(p.requestId));
+                });
+            },
+        };
     }, { name: "clawchat_reject_friend_request" });
-    api.registerTool({
-        name: "clawchat_remove_friend",
-        label: "Remove ClawChat Friend",
-        description: toolDescription("Remove an accepted friend from the connected ClawChat account by explicit friendUserId. " +
-            "TRIGGER - invoke when the user asks to delete, remove, unfriend, or disconnect an existing ClawChat friend and provides a concrete friendUserId. " +
-            "Use clawchat_list_account_friends first when the target is ambiguous; do not guess ids from names."),
-        parameters: ClawchatRemoveFriendSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_remove_friend", params, async () => {
-                const p = params;
-                return await withGatedClient((c) => c.removeFriend(p.friendUserId));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_remove_friend",
+            label: "Remove ClawChat Friend",
+            description: toolDescription("Remove an accepted friend from the connected ClawChat account by explicit friendUserId. " +
+                "TRIGGER - invoke when the user asks to delete, remove, unfriend, or disconnect an existing ClawChat friend and provides a concrete friendUserId. " +
+                "Use clawchat_list_account_friends first when the target is ambiguous; do not guess ids from names."),
+            parameters: ClawchatRemoveFriendSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_remove_friend", params, async () => {
+                    const p = params;
+                    return await withGatedClient(accountId, (c) => c.removeFriend(p.friendUserId));
+                });
+            },
+        };
     }, { name: "clawchat_remove_friend" });
-    api.registerTool({
-        name: "clawchat_search_users",
-        label: "Search ClawChat Users",
-        description: toolDescription("Search ClawChat users by username or nickname. Search server-side ClawChat users in the ClawChat user directory. " +
-            "TRIGGER - invoke when the user asks to search, find, or look up ClawChat users in the server directory by a typed query, username, or public nickname, such as \"search ClawChat users named Alice\", \"find ClawChat user Alice\", or \"look up nickname Alice\". " +
-            "This does not search local ClawChat memory files, aliases, known_as notes, relationship notes, group notes, or agent-authored Markdown memory. For remembered aliases, local notes, relationships, or prior ClawChat memory, use clawchat_memory_search. " +
-            "Empty q returns no users. Use this tool before fetching a public profile when the user only provides a server-side nickname or search term; do not guess a userId from query text."),
-        parameters: ClawchatSearchUsersSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_search_users", params, async () => {
-                const p = (params ?? {});
-                return await withClient((c) => c.searchUsers({
-                    ...(typeof p.q === "string" ? { q: p.q } : {}),
-                    ...(typeof p.limit === "number" ? { limit: p.limit } : {}),
-                }));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_search_users",
+            label: "Search ClawChat Users",
+            description: toolDescription("Search ClawChat users by username or nickname. Search server-side ClawChat users in the ClawChat user directory. " +
+                "TRIGGER - invoke when the user asks to search, find, or look up ClawChat users in the server directory by a typed query, username, or public nickname, such as \"search ClawChat users named Alice\", \"find ClawChat user Alice\", or \"look up nickname Alice\". " +
+                "This does not search local ClawChat memory files, aliases, known_as notes, relationship notes, group notes, or agent-authored Markdown memory. For remembered aliases, local notes, relationships, or prior ClawChat memory, use clawchat_memory_search. " +
+                "Empty q returns no users. Use this tool before fetching a public profile when the user only provides a server-side nickname or search term; do not guess a userId from query text."),
+            parameters: ClawchatSearchUsersSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_search_users", params, async () => {
+                    const p = (params ?? {});
+                    return await withClient(accountId, (c) => c.searchUsers({
+                        ...(typeof p.q === "string" ? { q: p.q } : {}),
+                        ...(typeof p.limit === "number" ? { limit: p.limit } : {}),
+                    }));
+                });
+            },
+        };
     }, { name: "clawchat_search_users" });
-    api.registerTool({
-        name: "clawchat_get_conversation",
-        label: "Get ClawChat Conversation",
-        description: toolDescription("Fetch read-only ClawChat conversation details, including group membership when returned by the API. " +
-            "TRIGGER - invoke when the user asks to inspect a specific ClawChat conversation or group and provides a concrete conversationId. " +
-            "This is read-only and does not create, update, leave, dissolve, or administer conversations."),
-        parameters: ClawchatGetConversationSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_get_conversation", params, async () => {
-                const p = params;
-                const built = buildClient();
-                if (!built.ok)
-                    return built.error;
-                try {
-                    const data = await built.client.getConversation(p.conversationId);
-                    return jsonResponse(data);
-                }
-                catch (err) {
-                    if (err instanceof ClawlingApiError) {
-                        return apiError(err);
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_get_conversation",
+            label: "Get ClawChat Conversation",
+            description: toolDescription("Fetch read-only ClawChat conversation details, including group membership when returned by the API. " +
+                "TRIGGER - invoke when the user asks to inspect a specific ClawChat conversation or group and provides a concrete conversationId. " +
+                "This is read-only and does not create, update, leave, dissolve, or administer conversations."),
+            parameters: ClawchatGetConversationSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_get_conversation", params, async () => {
+                    const p = params;
+                    const built = buildClient(accountId);
+                    if (!built.ok)
+                        return built.error;
+                    try {
+                        const data = await built.client.getConversation(p.conversationId);
+                        return jsonResponse(data);
                     }
-                    return genericError(err);
-                }
-            });
-        },
+                    catch (err) {
+                        if (err instanceof ClawlingApiError) {
+                            return apiError(err);
+                        }
+                        return genericError(err);
+                    }
+                });
+            },
+        };
     }, { name: "clawchat_get_conversation" });
-    api.registerTool({
-        name: "clawchat_leave_group",
-        label: "Leave ClawChat Group",
-        description: toolDescription("Leave a ClawChat group conversation the agent is currently a member of. " +
-            "TRIGGER - invoke only when the user explicitly asks the agent to leave, exit, or quit a specific ClawChat group and provides a concrete conversationId. " +
-            "Groups only: direct conversations are rejected by the server. " +
-            "If the agent is the group owner, leaving auto-transfers ownership to the earliest human member; if no human member remains, the group is dissolved. " +
-            "After this tool succeeds, output only <clawchat:no-reply/> and do not send a normal follow-up reply."),
-        parameters: ClawchatLeaveGroupSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_leave_group", params, async () => {
-                const p = params;
-                const built = buildClient();
-                if (!built.ok)
-                    return built.error;
-                try {
-                    const data = await built.client.leaveConversation(p.conversationId);
-                    return jsonResponse(data);
-                }
-                catch (err) {
-                    if (err instanceof ClawlingApiError) {
-                        return apiError(err);
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_leave_group",
+            label: "Leave ClawChat Group",
+            description: toolDescription("Leave a ClawChat group conversation the agent is currently a member of. " +
+                "TRIGGER - invoke only when the user explicitly asks the agent to leave, exit, or quit a specific ClawChat group and provides a concrete conversationId. " +
+                "Groups only: direct conversations are rejected by the server. " +
+                "If the agent is the group owner, leaving auto-transfers ownership to the earliest human member; if no human member remains, the group is dissolved. " +
+                "After this tool succeeds, output only <clawchat:no-reply/> and do not send a normal follow-up reply."),
+            parameters: ClawchatLeaveGroupSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_leave_group", params, async () => {
+                    const p = params;
+                    const built = buildClient(accountId);
+                    if (!built.ok)
+                        return built.error;
+                    try {
+                        const data = await built.client.leaveConversation(p.conversationId);
+                        return jsonResponse(data);
                     }
-                    return genericError(err);
-                }
-            });
-        },
+                    catch (err) {
+                        if (err instanceof ClawlingApiError) {
+                            return apiError(err);
+                        }
+                        return genericError(err);
+                    }
+                });
+            },
+        };
     }, { name: "clawchat_leave_group" });
-    api.registerTool({
-        name: "clawchat_add_group_member",
-        label: "Add ClawChat Group Member",
-        description: toolDescription("Add a specified ClawChat user to a group conversation the agent is a member of. " +
-            "TRIGGER - invoke only when the user explicitly asks the agent to add, invite, or pull a specific person into a specific ClawChat group, and both a concrete conversationId and a concrete userId are available. " +
-            "Never guess a userId from a name or nickname — use ids from ClawChat Group Message Metadata, clawchat_list_account_friends, or clawchat_search_users. " +
-            "Groups only: direct conversations are rejected by the server. " +
-            "The target must already be the agent's ClawChat friend, and the agent needs the group-management permission granted by its owner; if the call fails for either reason, explain that to the user and do not retry."),
-        parameters: ClawchatAddGroupMemberSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_add_group_member", params, async () => {
-                const p = params;
-                const built = buildClient();
-                if (!built.ok)
-                    return built.error;
-                try {
-                    const data = await built.client.addConversationMember(p.conversationId, p.userId);
-                    return jsonResponse(data);
-                }
-                catch (err) {
-                    if (err instanceof ClawlingApiError) {
-                        return apiError(err);
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_add_group_member",
+            label: "Add ClawChat Group Member",
+            description: toolDescription("Add a specified ClawChat user to a group conversation the agent is a member of. " +
+                "TRIGGER - invoke only when the user explicitly asks the agent to add, invite, or pull a specific person into a specific ClawChat group, and both a concrete conversationId and a concrete userId are available. " +
+                "Never guess a userId from a name or nickname — use ids from ClawChat Group Message Metadata, clawchat_list_account_friends, or clawchat_search_users. " +
+                "Groups only: direct conversations are rejected by the server. " +
+                "The target must already be the agent's ClawChat friend, and the agent needs the group-management permission granted by its owner; if the call fails for either reason, explain that to the user and do not retry."),
+            parameters: ClawchatAddGroupMemberSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_add_group_member", params, async () => {
+                    const p = params;
+                    const built = buildClient(accountId);
+                    if (!built.ok)
+                        return built.error;
+                    try {
+                        const data = await built.client.addConversationMember(p.conversationId, p.userId);
+                        return jsonResponse(data);
                     }
-                    return genericError(err);
-                }
-            });
-        },
+                    catch (err) {
+                        if (err instanceof ClawlingApiError) {
+                            return apiError(err);
+                        }
+                        return genericError(err);
+                    }
+                });
+            },
+        };
     }, { name: "clawchat_add_group_member" });
-    api.registerTool({
-        name: "clawchat_mention_message",
-        label: "Send ClawChat Mention Message",
-        description: toolDescription("Send a real ClawChat mention message to a direct or group conversation. " +
-            "TRIGGER - invoke when the user asks to @, mention, notify, or address ClawChat users. " +
-            "Use `mentioned_users` or `sender_id` from current ClawChat sender/group message metadata as `mentions[].userId` when present. " +
-            "Use `clawchat_search_users` only when no explicit or locally available id exists. " +
-            "Never guess userId from names, nicknames, or plain @name text. Plain @name is not a real mention. " +
-            "Pass the visible label as `mentions[].display` when known. Do not copy the visible @mention into `text`; put only the message body in `text`. If display is unknown but a concrete userId is available and a human-readable label matters, call clawchat_get_user_profile first and use the returned nickname. " +
-            "After this tool succeeds, the mention message has already been sent; output only <clawchat:no-reply/> and do not send a normal follow-up reply."),
-        parameters: ClawchatMentionMessageSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_mention_message", params, async () => {
-                const validated = validateMentionMessageParams(params);
-                if (!validated.ok)
-                    return validationError(validated.message);
-                const account = resolveCurrent();
-                if (!account.configured) {
-                    return configError("clawchat-plugin-openclaw: account is not configured");
-                }
-                try {
-                    const p = validated.params;
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_mention_message",
+            label: "Send ClawChat Mention Message",
+            description: toolDescription("Send a real ClawChat mention message to a direct or group conversation. " +
+                "TRIGGER - invoke when the user asks to @, mention, notify, or address ClawChat users. " +
+                "Use `mentioned_users` or `sender_id` from current ClawChat sender/group message metadata as `mentions[].userId` when present. " +
+                "Use `clawchat_search_users` only when no explicit or locally available id exists. " +
+                "Never guess userId from names, nicknames, or plain @name text. Plain @name is not a real mention. " +
+                "Pass the visible label as `mentions[].display` when known. Do not copy the visible @mention into `text`; put only the message body in `text`. If display is unknown but a concrete userId is available and a human-readable label matters, call clawchat_get_user_profile first and use the returned nickname. " +
+                "After this tool succeeds, the mention message has already been sent; output only <clawchat:no-reply/> and do not send a normal follow-up reply."),
+            parameters: ClawchatMentionMessageSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_mention_message", params, async () => {
+                    const validated = validateMentionMessageParams(params);
+                    if (!validated.ok)
+                        return validationError(validated.message);
+                    const account = resolveCurrent(accountId);
+                    if (!account.configured) {
+                        return configError("clawchat-plugin-openclaw: account is not configured");
+                    }
+                    try {
+                        const p = validated.params;
+                        const client = getOpenclawClawlingClient(account.accountId);
+                        if (!client) {
+                            return configError("ClawChat websocket client is not ready");
+                        }
+                        const result = await sendOpenclawClawlingMentionMessage({
+                            client,
+                            account,
+                            to: {
+                                chatId: p.chatId.trim(),
+                                chatType: p.chatType ?? "group",
+                            },
+                            ...(p.text !== undefined ? { text: p.text } : {}),
+                            mentions: p.mentions,
+                            ...(p.replyToMessageId
+                                ? {
+                                    replyCtx: {
+                                        replyToMessageId: p.replyToMessageId,
+                                    },
+                                }
+                                : {}),
+                            log: api.logger,
+                        });
+                        if (!result)
+                            return jsonResponse(result);
+                        markTerminalClawChatSend({
+                            accountId: account.accountId,
+                            chatId: p.chatId.trim(),
+                            messageId: result.messageId,
+                        });
+                        return jsonResponse({
+                            sent: true,
+                            terminal: true,
+                            noFollowupReply: true,
+                            instruction: "The mention message has already been sent to ClawChat. If a follow-up response is required, output only <clawchat:no-reply/> and do not send a normal follow-up reply.",
+                            ...result,
+                        });
+                    }
+                    catch (err) {
+                        return genericError(err);
+                    }
+                });
+            },
+        };
+    }, { name: "clawchat_mention_message" });
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_react_message",
+            label: "React to ClawChat Message",
+            description: toolDescription("React to a ClawChat message with a single quick emoji (the bubble long-press reaction), instead of sending a text message. " +
+                "TRIGGER - invoke when a short acknowledgement or emotional beat (agreement, thanks, laughter, celebration, sympathy) reads more naturally as an emoji on the message than as a sentence, e.g. a simple 👍 to \"done\" or ❤️ to good news. " +
+                "Omit targetMessageId and chatId to react to the message that triggered the current turn; pass targetMessageId to react to an earlier message. " +
+                "Set remove:true to take back your reaction. " +
+                "Prefer the quick set 👍 ❤️ 😂 😮 😢 🙏 🎉 👏 🔥 😍 🤔. " +
+                "When a reaction is all you want to send, do not also send a normal text reply."),
+            parameters: ClawchatReactMessageSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_react_message", params, async () => {
+                    const p = params;
+                    if (!p.emoji?.trim()) {
+                        return validationError("clawchat-plugin-openclaw: emoji is required");
+                    }
+                    const account = resolveCurrent(accountId);
+                    if (!account.configured) {
+                        return configError("clawchat-plugin-openclaw: account is not configured");
+                    }
+                    const scope = getCurrentTerminalSendScope();
+                    const chatId = p.chatId?.trim() || scope?.chatId;
+                    const targetMessageId = p.targetMessageId?.trim() || scope?.messageId;
+                    if (!chatId) {
+                        return validationError("clawchat-plugin-openclaw: chatId is required (no current-turn chat to default from)");
+                    }
+                    if (!targetMessageId) {
+                        return validationError("clawchat-plugin-openclaw: targetMessageId is required (no current-turn message to default from)");
+                    }
                     const client = getOpenclawClawlingClient(account.accountId);
                     if (!client) {
                         return configError("ClawChat websocket client is not ready");
                     }
-                    const result = await sendOpenclawClawlingMentionMessage({
-                        client,
-                        account,
-                        to: {
-                            chatId: p.chatId.trim(),
-                            chatType: p.chatType ?? "group",
-                        },
-                        ...(p.text !== undefined ? { text: p.text } : {}),
-                        mentions: p.mentions,
-                        ...(p.replyToMessageId
-                            ? {
-                                replyCtx: {
-                                    replyToMessageId: p.replyToMessageId,
-                                },
-                            }
-                            : {}),
-                        log: api.logger,
-                    });
-                    if (!result)
-                        return jsonResponse(result);
-                    markTerminalClawChatSend({
-                        accountId: account.accountId,
-                        chatId: p.chatId.trim(),
-                        messageId: result.messageId,
-                    });
-                    return jsonResponse({
-                        sent: true,
-                        terminal: true,
-                        noFollowupReply: true,
-                        instruction: "The mention message has already been sent to ClawChat. If a follow-up response is required, output only <clawchat:no-reply/> and do not send a normal follow-up reply.",
-                        ...result,
-                    });
-                }
-                catch (err) {
-                    return genericError(err);
-                }
-            });
-        },
-    }, { name: "clawchat_mention_message" });
-    api.registerTool({
-        name: "clawchat_react_message",
-        label: "React to ClawChat Message",
-        description: toolDescription("React to a ClawChat message with a single quick emoji (the bubble long-press reaction), instead of sending a text message. " +
-            "TRIGGER - invoke when a short acknowledgement or emotional beat (agreement, thanks, laughter, celebration, sympathy) reads more naturally as an emoji on the message than as a sentence, e.g. a simple 👍 to \"done\" or ❤️ to good news. " +
-            "Omit targetMessageId and chatId to react to the message that triggered the current turn; pass targetMessageId to react to an earlier message. " +
-            "Set remove:true to take back your reaction. " +
-            "Prefer the quick set 👍 ❤️ 😂 😮 😢 🙏 🎉 👏 🔥 😍 🤔. " +
-            "When a reaction is all you want to send, do not also send a normal text reply."),
-        parameters: ClawchatReactMessageSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_react_message", params, async () => {
-                const p = params;
-                if (!p.emoji?.trim()) {
-                    return validationError("clawchat-plugin-openclaw: emoji is required");
-                }
-                const account = resolveCurrent();
-                if (!account.configured) {
-                    return configError("clawchat-plugin-openclaw: account is not configured");
-                }
-                const scope = getCurrentTerminalSendScope();
-                const chatId = p.chatId?.trim() || scope?.chatId;
-                const targetMessageId = p.targetMessageId?.trim() || scope?.messageId;
-                if (!chatId) {
-                    return validationError("clawchat-plugin-openclaw: chatId is required (no current-turn chat to default from)");
-                }
-                if (!targetMessageId) {
-                    return validationError("clawchat-plugin-openclaw: targetMessageId is required (no current-turn message to default from)");
-                }
-                const client = getOpenclawClawlingClient(account.accountId);
-                if (!client) {
-                    return configError("ClawChat websocket client is not ready");
-                }
-                const emoji = p.emoji.trim();
-                const removed = p.remove === true;
-                try {
-                    sendOpenclawClawlingReaction({ client, chatId, targetMessageId, emoji, removed, log: api.logger });
-                    return jsonResponse({ reacted: true, targetMessageId, emoji, removed });
-                }
-                catch (err) {
-                    return genericError(err);
-                }
-            });
-        },
+                    const emoji = p.emoji.trim();
+                    const removed = p.remove === true;
+                    try {
+                        sendOpenclawClawlingReaction({ client, chatId, targetMessageId, emoji, removed, log: api.logger });
+                        return jsonResponse({ reacted: true, targetMessageId, emoji, removed });
+                    }
+                    catch (err) {
+                        return genericError(err);
+                    }
+                });
+            },
+        };
     }, { name: "clawchat_react_message" });
-    api.registerTool({
-        name: "clawchat_list_moments",
-        label: "List ClawChat Moments",
-        description: toolDescription("List the configured ClawChat account's visible moments feed, including moments from the account and its friends. " +
-            "TRIGGER - invoke when the user asks to view, browse, refresh, or paginate ClawChat moments/dynamics/feed, such as \"show my ClawChat moments\", \"view dynamics\", \"show friend moments\", or \"more moments\". " +
-            "Use before/comment/reaction/delete actions when the user needs to choose a moment id. This is a friends-only feed endpoint, not a global public timeline."),
-        parameters: ClawchatListMomentsSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_list_moments", params, async () => {
-                const p = (params ?? {});
-                return await withClient((c) => c.listMoments({
-                    ...(typeof p.before === "number" ? { before: p.before } : {}),
-                    ...(typeof p.limit === "number" ? { limit: p.limit } : {}),
-                }));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_list_moments",
+            label: "List ClawChat Moments",
+            description: toolDescription("List the configured ClawChat account's visible moments feed, including moments from the account and its friends. " +
+                "TRIGGER - invoke when the user asks to view, browse, refresh, or paginate ClawChat moments/dynamics/feed, such as \"show my ClawChat moments\", \"view dynamics\", \"show friend moments\", or \"more moments\". " +
+                "Use before/comment/reaction/delete actions when the user needs to choose a moment id. This is a friends-only feed endpoint, not a global public timeline."),
+            parameters: ClawchatListMomentsSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_list_moments", params, async () => {
+                    const p = (params ?? {});
+                    return await withClient(accountId, (c) => c.listMoments({
+                        ...(typeof p.before === "number" ? { before: p.before } : {}),
+                        ...(typeof p.limit === "number" ? { limit: p.limit } : {}),
+                    }));
+                });
+            },
+        };
     }, { name: "clawchat_list_moments" });
-    api.registerTool({
-        name: "clawchat_get_moment",
-        label: "Get ClawChat Moment",
-        description: toolDescription("Fetch a single ClawChat moment by id together with the comments visible to this agent. TRIGGER - after a moment.comment.created / moment.comment.replied awareness note, call this with the moment id to read the new comment before deciding whether to reply."),
-        parameters: ClawchatGetMomentSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_get_moment", params, async () => {
-                const p = (params ?? {});
-                return await withClient((c) => c.getMoment(p.momentId));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_get_moment",
+            label: "Get ClawChat Moment",
+            description: toolDescription("Fetch a single ClawChat moment by id together with the comments visible to this agent. TRIGGER - after a moment.comment.created / moment.comment.replied awareness note, call this with the moment id to read the new comment before deciding whether to reply."),
+            parameters: ClawchatGetMomentSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_get_moment", params, async () => {
+                    const p = (params ?? {});
+                    return await withClient(accountId, (c) => c.getMoment(p.momentId));
+                });
+            },
+        };
     }, { name: "clawchat_get_moment" });
-    api.registerTool({
-        name: "clawchat_create_moment",
-        label: "Create ClawChat Moment",
-        description: toolDescription("Create a new ClawChat moment/dynamic for the configured ClawChat account. " +
-            "TRIGGER - invoke when the user asks to publish, post, or send a ClawChat moment/dynamic, such as \"post a ClawChat moment saying ...\", \"publish a dynamic ...\", or \"send a friend moment ...\". " +
-            "At least one of text or images must be present. For local image files, upload first with the appropriate media upload tool and pass the returned URLs in images; do not pass local file paths as images."),
-        parameters: ClawchatCreateMomentSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_create_moment", params, async () => {
-                const p = (params ?? {});
-                const text = typeof p.text === "string" ? p.text : undefined;
-                const images = Array.isArray(p.images) ? p.images : undefined;
-                if (!text && (!images || images.length === 0)) {
-                    return validationError("clawchat-plugin-openclaw: at least one of text or images is required");
-                }
-                return await withGatedClient((c) => c.createMoment({
-                    ...(text !== undefined ? { text } : {}),
-                    ...(images !== undefined ? { images } : {}),
-                }));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_create_moment",
+            label: "Create ClawChat Moment",
+            description: toolDescription("Create a new ClawChat moment/dynamic for the configured ClawChat account. " +
+                "TRIGGER - invoke when the user asks to publish, post, or send a ClawChat moment/dynamic, such as \"post a ClawChat moment saying ...\", \"publish a dynamic ...\", or \"send a friend moment ...\". " +
+                "At least one of text or images must be present. For local image files, upload first with the appropriate media upload tool and pass the returned URLs in images; do not pass local file paths as images."),
+            parameters: ClawchatCreateMomentSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_create_moment", params, async () => {
+                    const p = (params ?? {});
+                    const text = typeof p.text === "string" ? p.text : undefined;
+                    const images = Array.isArray(p.images) ? p.images : undefined;
+                    if (!text && (!images || images.length === 0)) {
+                        return validationError("clawchat-plugin-openclaw: at least one of text or images is required");
+                    }
+                    return await withGatedClient(accountId, (c) => c.createMoment({
+                        ...(text !== undefined ? { text } : {}),
+                        ...(images !== undefined ? { images } : {}),
+                    }));
+                });
+            },
+        };
     }, { name: "clawchat_create_moment" });
-    api.registerTool({
-        name: "clawchat_delete_moment",
-        label: "Delete ClawChat Moment",
-        description: toolDescription("Delete a ClawChat moment by moment id. " +
-            "TRIGGER - invoke when the user asks to delete/remove one of the configured account's ClawChat moments/dynamics and provides or selects a concrete moment id. " +
-            "Only the moment author can delete it. Do not guess the id; list moments first if the user refers to a moment ambiguously."),
-        parameters: ClawchatDeleteMomentSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_delete_moment", params, async () => {
-                const p = params;
-                return await withGatedClient((c) => c.deleteMoment(p.momentId));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_delete_moment",
+            label: "Delete ClawChat Moment",
+            description: toolDescription("Delete a ClawChat moment by moment id. " +
+                "TRIGGER - invoke when the user asks to delete/remove one of the configured account's ClawChat moments/dynamics and provides or selects a concrete moment id. " +
+                "Only the moment author can delete it. Do not guess the id; list moments first if the user refers to a moment ambiguously."),
+            parameters: ClawchatDeleteMomentSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_delete_moment", params, async () => {
+                    const p = params;
+                    return await withGatedClient(accountId, (c) => c.deleteMoment(p.momentId));
+                });
+            },
+        };
     }, { name: "clawchat_delete_moment" });
-    api.registerTool({
-        name: "clawchat_toggle_moment_reaction",
-        label: "Toggle ClawChat Moment Reaction",
-        description: toolDescription("Toggle an emoji reaction on a ClawChat moment. " +
-            "TRIGGER - invoke when the user asks to react, like, unlike, emoji-react, or remove the same emoji reaction on a specific ClawChat moment, such as \"like moment 123 with thumbs up\", \"add a thumbs-up reaction to moment 123\", or \"remove this reaction\". " +
-            "The API adds the reaction if missing and removes it if already present. Require a concrete moment id and emoji."),
-        parameters: ClawchatToggleMomentReactionSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_toggle_moment_reaction", params, async () => {
-                const p = params;
-                if (!p.emoji?.trim()) {
-                    return validationError("clawchat-plugin-openclaw: emoji is required");
-                }
-                return await withGatedClient((c) => c.toggleMomentReaction({ momentId: p.momentId, emoji: p.emoji }));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_toggle_moment_reaction",
+            label: "Toggle ClawChat Moment Reaction",
+            description: toolDescription("Toggle an emoji reaction on a ClawChat moment. " +
+                "TRIGGER - invoke when the user asks to react, like, unlike, emoji-react, or remove the same emoji reaction on a specific ClawChat moment, such as \"like moment 123 with thumbs up\", \"add a thumbs-up reaction to moment 123\", or \"remove this reaction\". " +
+                "The API adds the reaction if missing and removes it if already present. Require a concrete moment id and emoji."),
+            parameters: ClawchatToggleMomentReactionSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_toggle_moment_reaction", params, async () => {
+                    const p = params;
+                    if (!p.emoji?.trim()) {
+                        return validationError("clawchat-plugin-openclaw: emoji is required");
+                    }
+                    return await withGatedClient(accountId, (c) => c.toggleMomentReaction({ momentId: p.momentId, emoji: p.emoji }));
+                });
+            },
+        };
     }, { name: "clawchat_toggle_moment_reaction" });
-    api.registerTool({
-        name: "clawchat_create_moment_comment",
-        label: "Create ClawChat Moment Comment",
-        description: toolDescription("Create a top-level comment on a ClawChat moment. " +
-            "TRIGGER - invoke when the user asks to comment/reply directly to a moment/dynamic, not to another comment, such as \"comment on moment 123: ...\", \"leave a comment on dynamic 123 ...\", or \"write under this moment ...\". " +
-            "Require a concrete moment id and non-empty text. Use clawchat_reply_moment_comment when the user is replying to another user's comment."),
-        parameters: ClawchatCreateMomentCommentSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_create_moment_comment", params, async () => {
-                const p = params;
-                if (!p.text?.trim()) {
-                    return validationError("clawchat-plugin-openclaw: text is required");
-                }
-                return await withGatedClient((c) => c.createMomentComment({ momentId: p.momentId, text: p.text }));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_create_moment_comment",
+            label: "Create ClawChat Moment Comment",
+            description: toolDescription("Create a top-level comment on a ClawChat moment. " +
+                "TRIGGER - invoke when the user asks to comment/reply directly to a moment/dynamic, not to another comment, such as \"comment on moment 123: ...\", \"leave a comment on dynamic 123 ...\", or \"write under this moment ...\". " +
+                "Require a concrete moment id and non-empty text. Use clawchat_reply_moment_comment when the user is replying to another user's comment."),
+            parameters: ClawchatCreateMomentCommentSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_create_moment_comment", params, async () => {
+                    const p = params;
+                    if (!p.text?.trim()) {
+                        return validationError("clawchat-plugin-openclaw: text is required");
+                    }
+                    return await withGatedClient(accountId, (c) => c.createMomentComment({ momentId: p.momentId, text: p.text }));
+                });
+            },
+        };
     }, { name: "clawchat_create_moment_comment" });
-    api.registerTool({
-        name: "clawchat_reply_moment_comment",
-        label: "Reply To ClawChat Moment Comment",
-        description: toolDescription("Reply to an existing ClawChat moment comment with a single-level reply. " +
-            "TRIGGER - invoke when the user asks to reply to another user's comment on a moment/dynamic, such as \"reply to comment 456 on moment 123: ...\", \"reply to comment 456 ...\", or \"reply to that comment ...\". " +
-            "Require concrete moment and comment ids; do not use this for top-level comments."),
-        parameters: ClawchatReplyMomentCommentSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_reply_moment_comment", params, async () => {
-                const p = params;
-                if (!p.text?.trim()) {
-                    return validationError("clawchat-plugin-openclaw: text is required");
-                }
-                return await withGatedClient((c) => c.replyMomentComment({
-                    momentId: p.momentId,
-                    replyToCommentId: p.replyToCommentId,
-                    text: p.text,
-                }));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_reply_moment_comment",
+            label: "Reply To ClawChat Moment Comment",
+            description: toolDescription("Reply to an existing ClawChat moment comment with a single-level reply. " +
+                "TRIGGER - invoke when the user asks to reply to another user's comment on a moment/dynamic, such as \"reply to comment 456 on moment 123: ...\", \"reply to comment 456 ...\", or \"reply to that comment ...\". " +
+                "Require concrete moment and comment ids; do not use this for top-level comments."),
+            parameters: ClawchatReplyMomentCommentSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_reply_moment_comment", params, async () => {
+                    const p = params;
+                    if (!p.text?.trim()) {
+                        return validationError("clawchat-plugin-openclaw: text is required");
+                    }
+                    return await withGatedClient(accountId, (c) => c.replyMomentComment({
+                        momentId: p.momentId,
+                        replyToCommentId: p.replyToCommentId,
+                        text: p.text,
+                    }));
+                });
+            },
+        };
     }, { name: "clawchat_reply_moment_comment" });
-    api.registerTool({
-        name: "clawchat_delete_moment_comment",
-        label: "Delete ClawChat Moment Comment",
-        description: toolDescription("Delete a comment on a ClawChat moment. " +
-            "TRIGGER - invoke when the user asks to delete/remove a specific comment or reply from a ClawChat moment/dynamic and provides concrete moment and comment ids. " +
-            "The caller may delete comments they authored or comments on moments they authored. Do not guess ids; list moments first if needed."),
-        parameters: ClawchatDeleteMomentCommentSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_delete_moment_comment", params, async () => {
-                const p = params;
-                return await withGatedClient((c) => c.deleteMomentComment({ momentId: p.momentId, commentId: p.commentId }));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_delete_moment_comment",
+            label: "Delete ClawChat Moment Comment",
+            description: toolDescription("Delete a comment on a ClawChat moment. " +
+                "TRIGGER - invoke when the user asks to delete/remove a specific comment or reply from a ClawChat moment/dynamic and provides concrete moment and comment ids. " +
+                "The caller may delete comments they authored or comments on moments they authored. Do not guess ids; list moments first if needed."),
+            parameters: ClawchatDeleteMomentCommentSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_delete_moment_comment", params, async () => {
+                    const p = params;
+                    return await withGatedClient(accountId, (c) => c.deleteMomentComment({ momentId: p.momentId, commentId: p.commentId }));
+                });
+            },
+        };
     }, { name: "clawchat_delete_moment_comment" });
-    api.registerTool({
-        name: "clawchat_update_account_profile",
-        label: "Update ClawChat Account Profile",
-        description: toolDescription("Update nickname/avatar_url/bio on the agent's connected ClawChat account (the configured ClawChat account), which mirrors the local assistant identity. " +
-            "TRIGGER — invoke this tool whenever the user's message asks to change the ClawChat account profile or local assistant name/profile while ClawChat is connected: " +
-            "(1) ClawChat account nickname/name change: 'change the ClawChat account nickname to X', " +
-            "'set this assistant name to X', 'change the assistant nickname to X', 'set the account name to X' " +
-            "→ call with `nickname = X`; " +
-            "(2) ClawChat account avatar/profile-picture change: 'change the ClawChat account avatar', " +
-            "'use this image as the assistant profile picture', 'change the account avatar to this image' " +
-            "→ first obtain the avatar URL (upload via `clawchat_upload_avatar_image`, OR use a provided URL directly), " +
-            "then call this tool with `avatar_url = <url>`; " +
-            "(3) ClawChat account bio/self-introduction change: 'update the ClawChat bio', " +
-            "'set the assistant self-introduction to X', 'change the account bio to X' " +
-            "→ call with `bio = X`. " +
-            "You can pass `nickname`, `avatar_url`, and `bio` together in one call, or just one of them. " +
-            "At least one of the three must be present. Do not frame this as updating a human user's personal account."),
-        parameters: ClawchatUpdateAccountProfileSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_update_account_profile", params, async () => {
-                const p = (params ?? {});
-                const patch = {};
-                if (typeof p.nickname === "string")
-                    patch.nickname = p.nickname;
-                if (typeof p.avatar_url === "string")
-                    patch.avatar_url = p.avatar_url;
-                if (typeof p.bio === "string")
-                    patch.bio = p.bio;
-                if (Object.keys(patch).length === 0) {
-                    return validationError("clawchat-plugin-openclaw: at least one of nickname / avatar / bio is required");
-                }
-                return await withClient((c) => c.updateMyProfile(patch));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_update_account_profile",
+            label: "Update ClawChat Account Profile",
+            description: toolDescription("Update nickname/avatar_url/bio on the agent's connected ClawChat account (the configured ClawChat account), which mirrors the local assistant identity. " +
+                "TRIGGER — invoke this tool whenever the user's message asks to change the ClawChat account profile or local assistant name/profile while ClawChat is connected: " +
+                "(1) ClawChat account nickname/name change: 'change the ClawChat account nickname to X', " +
+                "'set this assistant name to X', 'change the assistant nickname to X', 'set the account name to X' " +
+                "→ call with `nickname = X`; " +
+                "(2) ClawChat account avatar/profile-picture change: 'change the ClawChat account avatar', " +
+                "'use this image as the assistant profile picture', 'change the account avatar to this image' " +
+                "→ first obtain the avatar URL (upload via `clawchat_upload_avatar_image`, OR use a provided URL directly), " +
+                "then call this tool with `avatar_url = <url>`; " +
+                "(3) ClawChat account bio/self-introduction change: 'update the ClawChat bio', " +
+                "'set the assistant self-introduction to X', 'change the account bio to X' " +
+                "→ call with `bio = X`. " +
+                "You can pass `nickname`, `avatar_url`, and `bio` together in one call, or just one of them. " +
+                "At least one of the three must be present. Do not frame this as updating a human user's personal account."),
+            parameters: ClawchatUpdateAccountProfileSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_update_account_profile", params, async () => {
+                    const p = (params ?? {});
+                    const patch = {};
+                    if (typeof p.nickname === "string")
+                        patch.nickname = p.nickname;
+                    if (typeof p.avatar_url === "string")
+                        patch.avatar_url = p.avatar_url;
+                    if (typeof p.bio === "string")
+                        patch.bio = p.bio;
+                    if (Object.keys(patch).length === 0) {
+                        return validationError("clawchat-plugin-openclaw: at least one of nickname / avatar / bio is required");
+                    }
+                    return await withClient(accountId, (c) => c.updateMyProfile(patch));
+                });
+            },
+        };
     }, { name: "clawchat_update_account_profile" });
-    api.registerTool({
-        name: "clawchat_upload_avatar_image",
-        label: "Upload ClawChat Avatar Image",
-        description: toolDescription("Upload an absolute local image path for use as the agent's connected ClawChat account avatar (max 20MB), returning a hosted avatar URL. " +
-            "TRIGGER — invoke when the user provides an absolute local image path and asks to upload it for the ClawChat account avatar/profile picture. " +
-            "This tool does not update or set the account avatar by itself; when the user asked to set or sync the avatar, call `clawchat_update_account_profile` with `avatar_url` after this tool returns a URL."),
-        parameters: ClawchatUploadAvatarImageSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_upload_avatar_image", params, async () => {
-                const p = params;
-                if (!p.filePath || !path.isAbsolute(p.filePath)) {
-                    return validationError("clawchat-plugin-openclaw: filePath must be an absolute local path");
-                }
-                let stat;
-                try {
-                    stat = fs.statSync(p.filePath);
-                }
-                catch (err) {
-                    return validationError(`clawchat-plugin-openclaw: cannot stat ${p.filePath}: ${err instanceof Error ? err.message : String(err)}`);
-                }
-                if (!stat.isFile()) {
-                    return validationError(`clawchat-plugin-openclaw: ${p.filePath} is not a regular file`);
-                }
-                if (stat.size > MAX_UPLOAD_BYTES) {
-                    return validationError(`clawchat-plugin-openclaw: file too large (${stat.size} bytes; max 20MB)`);
-                }
-                const buffer = fs.readFileSync(p.filePath);
-                const filename = path.basename(p.filePath);
-                const mime = inferMimeFromPath(p.filePath);
-                return await withClient((c) => c.uploadAvatar({ buffer, filename, mime }));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_upload_avatar_image",
+            label: "Upload ClawChat Avatar Image",
+            description: toolDescription("Upload an absolute local image path for use as the agent's connected ClawChat account avatar (max 20MB), returning a hosted avatar URL. " +
+                "TRIGGER — invoke when the user provides an absolute local image path and asks to upload it for the ClawChat account avatar/profile picture. " +
+                "This tool does not update or set the account avatar by itself; when the user asked to set or sync the avatar, call `clawchat_update_account_profile` with `avatar_url` after this tool returns a URL."),
+            parameters: ClawchatUploadAvatarImageSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_upload_avatar_image", params, async () => {
+                    const p = params;
+                    if (!p.filePath || !path.isAbsolute(p.filePath)) {
+                        return validationError("clawchat-plugin-openclaw: filePath must be an absolute local path");
+                    }
+                    let stat;
+                    try {
+                        stat = fs.statSync(p.filePath);
+                    }
+                    catch (err) {
+                        return validationError(`clawchat-plugin-openclaw: cannot stat ${p.filePath}: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    if (!stat.isFile()) {
+                        return validationError(`clawchat-plugin-openclaw: ${p.filePath} is not a regular file`);
+                    }
+                    if (stat.size > MAX_UPLOAD_BYTES) {
+                        return validationError(`clawchat-plugin-openclaw: file too large (${stat.size} bytes; max 20MB)`);
+                    }
+                    const buffer = fs.readFileSync(p.filePath);
+                    const filename = path.basename(p.filePath);
+                    const mime = inferMimeFromPath(p.filePath);
+                    return await withClient(accountId, (c) => c.uploadAvatar({ buffer, filename, mime }));
+                });
+            },
+        };
     }, { name: "clawchat_upload_avatar_image" });
-    api.registerTool({
-        name: "clawchat_register_app",
-        label: "Register ClawChat App",
-        description: toolDescription("Register a liveware-tunneled web app to ClawChat so it appears in the owner's chat with this agent. " +
-            "Call AFTER `liveware tunnel bind` returns a public URL. Params: name, appId (liveware app id), url (public URL)."),
-        parameters: ClawchatRegisterAppSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_register_app", params, async () => {
-                const p = params;
-                return await withClient((c) => c.registerApp({ name: p.name, appId: p.appId, url: p.url }));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_register_app",
+            label: "Register ClawChat App",
+            description: toolDescription("Register a liveware-tunneled web app to ClawChat so it appears in the owner's chat with this agent. " +
+                "Call AFTER `liveware tunnel bind` returns a public URL. Params: name, appId (liveware app id), url (public URL)."),
+            parameters: ClawchatRegisterAppSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_register_app", params, async () => {
+                    const p = params;
+                    return await withClient(accountId, (c) => c.registerApp({ name: p.name, appId: p.appId, url: p.url }));
+                });
+            },
+        };
     }, { name: "clawchat_register_app" });
-    api.registerTool({
-        name: "clawchat_list_apps",
-        label: "List ClawChat Apps",
-        description: toolDescription("List the liveware web apps this agent has registered to ClawChat."),
-        parameters: ClawchatListAppsSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_list_apps", params, async () => withClient((c) => c.listApps()));
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_list_apps",
+            label: "List ClawChat Apps",
+            description: toolDescription("List the liveware web apps this agent has registered to ClawChat."),
+            parameters: ClawchatListAppsSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_list_apps", params, async () => withClient(accountId, (c) => c.listApps()));
+            },
+        };
     }, { name: "clawchat_list_apps" });
-    api.registerTool({
-        name: "clawchat_unregister_app",
-        label: "Unregister ClawChat App",
-        description: toolDescription("Unregister a previously registered liveware app from ClawChat. Param: appId (liveware app id)."),
-        parameters: ClawchatUnregisterAppSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_unregister_app", params, async () => {
-                const p = params;
-                return await withClient((c) => c.unregisterApp(p.appId));
-            });
-        },
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_unregister_app",
+            label: "Unregister ClawChat App",
+            description: toolDescription("Unregister a previously registered liveware app from ClawChat. Param: appId (liveware app id)."),
+            parameters: ClawchatUnregisterAppSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_unregister_app", params, async () => {
+                    const p = params;
+                    return await withClient(accountId, (c) => c.unregisterApp(p.appId));
+                });
+            },
+        };
     }, { name: "clawchat_unregister_app" });
-    api.registerTool({
-        name: "clawchat_liveware_login",
-        label: "Login to Liveware",
-        description: toolDescription("Log in to liveware CLI using the plugin-held ClawChat access token. " +
-            "The token is resolved from the plugin's own credential store and is never passed through the LLM context. " +
-            "Call this BEFORE any liveware tunnel or app commands; it is idempotent. " +
-            "Returns { ok: true } on success. Returns an error if liveware is not installed, the ClawChat account is not activated, or login fails."),
-        parameters: ClawchatLivewareLoginSchema,
-        async execute(_callId, params) {
-            return await recordClawchatToolCall("clawchat_liveware_login", params, async () => {
-                const acct = resolveCurrent();
-                const token = acct.token;
-                if (!token) {
-                    return configError("clawchat-plugin-openclaw: token is required");
-                }
-                return await new Promise((resolve) => {
-                    const livewarePath = resolveLivewarePath(api.runtime.state?.resolveStateDir?.());
-                    if (!livewarePath) {
-                        resolve(jsonResponse({
-                            error: "config",
-                            message: "liveware CLI not found in PATH; install liveware before calling this tool",
-                        }));
-                        return;
+    api.registerTool((ctx) => {
+        const accountId = resolveOpenclawClawlingToolAccountId(ctx);
+        return {
+            name: "clawchat_liveware_login",
+            label: "Login to Liveware",
+            description: toolDescription("Log in to liveware CLI using the plugin-held ClawChat access token. " +
+                "The token is resolved from the plugin's own credential store and is never passed through the LLM context. " +
+                "Call this BEFORE any liveware tunnel or app commands; it is idempotent. " +
+                "Returns { ok: true } on success. Returns an error if liveware is not installed, the ClawChat account is not activated, or login fails."),
+            parameters: ClawchatLivewareLoginSchema,
+            async execute(_callId, params) {
+                return await recordClawchatToolCall(accountId, "clawchat_liveware_login", params, async () => {
+                    const acct = resolveCurrent(accountId);
+                    const token = acct.token;
+                    if (!token) {
+                        return configError("clawchat-plugin-openclaw: token is required");
                     }
-                    // Security: the token is passed as a child process argv value using
-                    // liveware's documented --access-token interface. It is in the child
-                    // argv briefly during process creation; env-var or stdin delivery
-                    // would be preferred if liveware supported it.
-                    // NEVER log the argv array; scrub token from any captured output below.
-                    execFile(livewarePath, ["login", "--access-token", token], { timeout: 30000 }, (err, stdout, stderr) => {
-                        const scrub = (s) => (token ? s.split(token).join("***") : s);
-                        const safeStdout = scrub(stdout ?? "").trim();
-                        const safeStderr = scrub(stderr ?? "").trim();
-                        if (err) {
-                            if (err.code === "ENOENT") {
-                                resolve(jsonResponse({
-                                    error: "config",
-                                    message: "liveware CLI not found in PATH; install liveware before calling this tool",
-                                }));
-                                return;
-                            }
-                            const detail = [safeStderr, safeStdout].filter(Boolean).join("\n").trim();
+                    return await new Promise((resolve) => {
+                        const livewarePath = resolveLivewarePath(api.runtime.state?.resolveStateDir?.());
+                        if (!livewarePath) {
                             resolve(jsonResponse({
-                                error: "liveware_login_failed",
-                                message: "liveware login failed" + (detail ? `: ${detail}` : ""),
+                                error: "config",
+                                message: "liveware CLI not found in PATH; install liveware before calling this tool",
                             }));
                             return;
                         }
-                        resolve(jsonResponse({ ok: true }));
+                        // Security: the token is passed as a child process argv value using
+                        // liveware's documented --access-token interface. It is in the child
+                        // argv briefly during process creation; env-var or stdin delivery
+                        // would be preferred if liveware supported it.
+                        // NEVER log the argv array; scrub token from any captured output below.
+                        execFile(livewarePath, ["login", "--access-token", token], { timeout: 30000 }, (err, stdout, stderr) => {
+                            const scrub = (s) => (token ? s.split(token).join("***") : s);
+                            const safeStdout = scrub(stdout ?? "").trim();
+                            const safeStderr = scrub(stderr ?? "").trim();
+                            if (err) {
+                                if (err.code === "ENOENT") {
+                                    resolve(jsonResponse({
+                                        error: "config",
+                                        message: "liveware CLI not found in PATH; install liveware before calling this tool",
+                                    }));
+                                    return;
+                                }
+                                const detail = [safeStderr, safeStdout].filter(Boolean).join("\n").trim();
+                                resolve(jsonResponse({
+                                    error: "liveware_login_failed",
+                                    message: "liveware login failed" + (detail ? `: ${detail}` : ""),
+                                }));
+                                return;
+                            }
+                            resolve(jsonResponse({ ok: true }));
+                        });
                     });
                 });
-            });
-        },
+            },
+        };
     }, { name: "clawchat_liveware_login" });
     api.logger.debug?.("clawchat-plugin-openclaw: registered 31 clawchat_* tools (get_account_profile, get_user_profile, list_account_friends, send_friend_request, list_friend_requests, accept_friend_request, reject_friend_request, remove_friend, search_users, get_conversation, mention_message, list_moments, get_moment, create_moment, delete_moment, toggle_moment_reaction, create_moment_comment, reply_moment_comment, delete_moment_comment, update_account_profile, upload_avatar_image, memory_search, memory_read, memory_write, memory_edit, metadata_sync, metadata_update, register_app, list_apps, unregister_app, liveware_login)");
 }