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

package/src/tools.ts

@@ -10,7 +10,11 @@ import {
   type Profile,
 } from "./api-types.ts";
 import { mapGateOutcome } from "./gate-outcome.ts";
-import { resolveOpenclawClawlingAccount } from "./config.ts";
+import {
+  CHANNEL_ID,
+  normalizeOpenclawClawlingAccountId,
+  resolveOpenclawClawlingAccount,
+} from "./config.ts";
 import {
   clawChatDbPathForStateDir,
   getClawChatStore,
@@ -280,6 +284,35 @@ function validateMentionMessageParams(params: unknown):
   return { ok: true, params: p as ClawchatMentionMessageParams };
 }
 
+/**
+ * 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: OpenClawPluginToolContext): string | null {
+  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: OpenClawPluginApi,
   options: { store?: ToolStore | null } = {},
@@ -290,8 +323,8 @@ export function registerOpenclawClawlingTools(
   }
 
   // Re-resolve at call time so config reloads pick up new tokens / baseUrl.
-  function resolveCurrent() {
-    return resolveOpenclawClawlingAccount(api.config!);
+  function resolveCurrent(accountId: string | null) {
+    return resolveOpenclawClawlingAccount(api.config!, accountId);
   }
 
   function resolveStore(): ToolStore | null {
@@ -326,12 +359,13 @@ export function registerOpenclawClawlingTools(
   }
 
   async function recordClawchatToolCall<T>(
+    accountId: string | null,
     toolName: string,
     params: unknown,
     fn: () => Promise<OpenClawAgentToolResult<T>>,
   ): Promise<OpenClawAgentToolResult<T>> {
     const startedAt = Date.now();
-    const account = resolveCurrent();
+    const account = resolveCurrent(accountId);
     try {
       const result = await fn();
       const details = (result as { details?: unknown }).details ?? result;
@@ -365,8 +399,8 @@ export function registerOpenclawClawlingTools(
     | { ok: false; error: OpenClawAgentToolResult<unknown> }
     | { ok: true; client: ReturnType<typeof createOpenclawClawlingApiClient> };
 
-  function buildClient(): ClientResult {
-    const acct = resolveCurrent();
+  function buildClient(accountId: string | null): ClientResult {
+    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).
@@ -384,10 +418,11 @@ export function registerOpenclawClawlingTools(
   }
 
   function withClient<T>(
+    accountId: string | null,
     fn: (client: ReturnType<typeof createOpenclawClawlingApiClient>) => Promise<T>,
   ): Promise<OpenClawAgentToolResult<unknown>> {
     return (async (): Promise<OpenClawAgentToolResult<unknown>> => {
-      const built = buildClient();
+      const built = buildClient(accountId);
       if (!built.ok) return built.error;
       try {
         const data = await fn(built.client);
@@ -405,10 +440,11 @@ export function registerOpenclawClawlingTools(
    * instead of a generic error. Used for friend and moment mutation tools.
    */
   function withGatedClient<T>(
+    accountId: string | null,
     fn: (client: ReturnType<typeof createOpenclawClawlingApiClient>) => Promise<T>,
   ): Promise<OpenClawAgentToolResult<unknown>> {
     return (async (): Promise<OpenClawAgentToolResult<unknown>> => {
-      const built = buildClient();
+      const built = buildClient(accountId);
       if (!built.ok) return built.error;
       try {
         const data = await fn(built.client);
@@ -662,136 +698,142 @@ export function registerOpenclawClawlingTools(
     );
 
     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 as ClawchatMetadataSyncParams;
-            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");
+      (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 as ClawchatMetadataSyncParams;
+              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" && !account.agentId) {
-                return configError("clawchat-plugin-openclaw: agentId is required");
+              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" && !account.userId) {
-                return configError("clawchat-plugin-openclaw: userId is required");
+              if (p.targetType === "user") {
+                return jsonResponse(
+                  await pullUserMetadata({ memoryRoot: root, userId: p.targetId, api: built.client }),
+                );
               }
               return jsonResponse(
-                await pushMetadata({
+                await pullGroupMetadata({
                   memoryRoot: root,
-                  targetType: p.targetType,
-                  targetId: p.targetId,
-                  fields: p.fields,
-                  agentId: account.agentId,
-                  accountUserId: account.userId,
+                  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");
             }
-            if (p.targetType === "owner") {
-              if (!account.agentId) return configError("clawchat-plugin-openclaw: agentId is required");
+            const built = buildClient(accountId);
+            if (!built.ok) return built.error;
+            try {
+              const p = params as ClawchatMetadataUpdateParams;
+              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 pullOwnerMetadata({
+                await updateMetadata({
                   memoryRoot: root,
+                  targetType: p.targetType,
+                  targetId: p.targetId,
                   agentId: account.agentId,
                   accountUserId: account.userId,
-                  accountOwnerUserId: account.ownerUserId || undefined,
+                  patch: p.patch,
                   api: built.client,
+                  persistOwnerProfile: makeOwnerProfilePersister(getClawChatStore(), {
+                    accountId: account.accountId,
+                  }),
                 }),
               );
+            } catch (err) {
+              return memoryToolError(err);
             }
-            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) => ({
-        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();
-          if (!built.ok) return built.error;
-          try {
-            const p = params as ClawchatMetadataUpdateParams;
-            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);
-          }
-        },
-      }),
+          },
+        };
+      },
       { name: "clawchat_metadata_update" },
     );
   }
@@ -799,800 +841,886 @@ export function registerOpenclawClawlingTools(
   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()),
-        );
-      },
+    (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_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 as ClawchatGetUserProfileParams;
-          return await withClient((c) => c.getUserInfo(p.userId));
-        });
-      },
+    (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) {
+          return await recordClawchatToolCall(accountId, "clawchat_get_user_profile", params, async () => {
+            const p = params as ClawchatGetUserProfileParams;
+            return await withClient(accountId, (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()),
-        );
-      },
+    (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 as ClawchatSendFriendRequestParams;
-          return await withGatedClient((c) => c.sendFriendRequest(p));
-        });
-      },
+    (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 as ClawchatSendFriendRequestParams;
+            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 ?? {}) as ClawchatListFriendRequestsParams;
-          return await withClient((c) => c.listFriendRequests({ direction: p.direction ?? "incoming" }));
-        });
-      },
+    (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 ?? {}) as ClawchatListFriendRequestsParams;
+            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 as ClawchatAcceptFriendRequestParams;
-          return await withGatedClient((c) => c.acceptFriendRequest(p.requestId));
-        });
-      },
+    (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 as ClawchatAcceptFriendRequestParams;
+            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 as ClawchatRejectFriendRequestParams;
-          return await withGatedClient((c) => c.rejectFriendRequest(p.requestId));
-        });
-      },
+    (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 as ClawchatRejectFriendRequestParams;
+            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 as ClawchatRemoveFriendParams;
-          return await withGatedClient((c) => c.removeFriend(p.friendUserId));
-        });
-      },
+    (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 as ClawchatRemoveFriendParams;
+            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 ?? {}) as ClawchatSearchUsersParams;
-          return await withClient((c) =>
-            c.searchUsers({
-              ...(typeof p.q === "string" ? { q: p.q } : {}),
-              ...(typeof p.limit === "number" ? { limit: p.limit } : {}),
-            }),
-          );
-        });
-      },
+    (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 ?? {}) as ClawchatSearchUsersParams;
+            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 as ClawchatGetConversationParams;
-          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);
+    (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 as ClawchatGetConversationParams;
+            const built = buildClient(accountId);
+            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);
+              }
+              return genericError(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 as ClawchatLeaveGroupParams;
-          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);
+    (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 as ClawchatLeaveGroupParams;
+            const built = buildClient(accountId);
+            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);
+              }
+              return genericError(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 as ClawchatAddGroupMemberParams;
-          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);
+    (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 as ClawchatAddGroupMemberParams;
+            const built = buildClient(accountId);
+            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);
+              }
+              return genericError(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;
-            const client = getOpenclawClawlingClient(account.accountId);
-            if (!client) {
-              return configError("ClawChat websocket client is not ready");
+    (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");
             }
-            const result = await sendOpenclawClawlingMentionMessage({
-              client,
-              account,
-              to: {
+            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(),
-                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);
-          }
-        });
-      },
+                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 as ClawchatReactMessageParams;
-          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);
-          }
-        });
-      },
+    (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 as ClawchatReactMessageParams;
+            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 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 ?? {}) as ClawchatListMomentsParams;
-          return await withClient((c) =>
-            c.listMoments({
-              ...(typeof p.before === "number" ? { before: p.before } : {}),
-              ...(typeof p.limit === "number" ? { limit: p.limit } : {}),
-            }),
-          );
-        });
-      },
+    (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 ?? {}) as ClawchatListMomentsParams;
+            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 ?? {}) as ClawchatGetMomentParams;
-          return await withClient((c) => c.getMoment(p.momentId));
-        });
-      },
+    (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 ?? {}) as ClawchatGetMomentParams;
+            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 ?? {}) as ClawchatCreateMomentParams;
-          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 } : {}),
-            }),
-          );
-        });
-      },
+    (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 ?? {}) as ClawchatCreateMomentParams;
+            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 as ClawchatDeleteMomentParams;
-          return await withGatedClient((c) => c.deleteMoment(p.momentId));
-        });
-      },
+    (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 as ClawchatDeleteMomentParams;
+            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 as ClawchatToggleMomentReactionParams;
-          if (!p.emoji?.trim()) {
-            return validationError("clawchat-plugin-openclaw: emoji is required");
-          }
-          return await withGatedClient((c) =>
-            c.toggleMomentReaction({ momentId: p.momentId, emoji: p.emoji }),
-          );
-        });
-      },
+    (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 as ClawchatToggleMomentReactionParams;
+            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 as ClawchatCreateMomentCommentParams;
-          if (!p.text?.trim()) {
-            return validationError("clawchat-plugin-openclaw: text is required");
-          }
-          return await withGatedClient((c) =>
-            c.createMomentComment({ momentId: p.momentId, text: p.text }),
-          );
-        });
-      },
+    (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 as ClawchatCreateMomentCommentParams;
+            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 as ClawchatReplyMomentCommentParams;
-          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,
-            }),
-          );
-        });
-      },
+    (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 as ClawchatReplyMomentCommentParams;
+            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 as ClawchatDeleteMomentCommentParams;
-          return await withGatedClient((c) =>
-            c.deleteMomentComment({ momentId: p.momentId, commentId: p.commentId }),
-          );
-        });
-      },
+    (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 as ClawchatDeleteMomentCommentParams;
+            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 ?? {}) as ClawchatUpdateAccountProfileParams;
-          const patch: { nickname?: string; avatar_url?: string; bio?: string } = {};
-          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): Promise<Profile> => c.updateMyProfile(patch));
-        });
-      },
+    (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 ?? {}) as ClawchatUpdateAccountProfileParams;
+            const patch: { nickname?: string; avatar_url?: string; bio?: string } = {};
+            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): Promise<Profile> => 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 as ClawchatUploadAvatarImageParams;
-          if (!p.filePath || !path.isAbsolute(p.filePath)) {
-            return validationError("clawchat-plugin-openclaw: filePath must be an absolute local path");
-          }
-          let stat: fs.Stats;
-          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 }));
-        });
-      },
+    (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 as ClawchatUploadAvatarImageParams;
+            if (!p.filePath || !path.isAbsolute(p.filePath)) {
+              return validationError("clawchat-plugin-openclaw: filePath must be an absolute local path");
+            }
+            let stat: fs.Stats;
+            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 as ClawchatRegisterAppParams;
-          return await withClient((c) => c.registerApp({ name: p.name, appId: p.appId, url: p.url }));
-        });
-      },
+    (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 as ClawchatRegisterAppParams;
+            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()));
-      },
+    (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 as ClawchatUnregisterAppParams;
-          return await withClient((c) => c.unregisterApp(p.appId));
-        });
-      },
+    (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 as ClawchatUnregisterAppParams;
+            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 as ClawchatLivewareLoginParams, async () => {
-          const acct = resolveCurrent();
-          const token = acct.token;
-          if (!token) {
-            return configError("clawchat-plugin-openclaw: token is required");
-          }
-
-          return await new Promise<ReturnType<typeof jsonResponse>>((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;
+    (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 as ClawchatLivewareLoginParams, 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: string) => (token ? s.split(token).join("***") : s);
-                const safeStdout = scrub(stdout ?? "").trim();
-                const safeStderr = scrub(stderr ?? "").trim();
-
-                if (err) {
-                  if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+
+            return await new Promise<ReturnType<typeof jsonResponse>>((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;
+              }
+              // 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: string) => (token ? s.split(token).join("***") : s);
+                  const safeStdout = scrub(stdout ?? "").trim();
+                  const safeStderr = scrub(stderr ?? "").trim();
+
+                  if (err) {
+                    if ((err as NodeJS.ErrnoException).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: "config",
-                      message: "liveware CLI not found in PATH; install liveware before calling this tool",
+                      error: "liveware_login_failed",
+                      message: "liveware login failed" + (detail ? `: ${detail}` : ""),
                     }));
                     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 }));
-              },
-            );
+                  resolve(jsonResponse({ ok: true }));
+                },
+              );
+            });
           });
-        });
-      },
+        },
+      };
     },
     { name: "clawchat_liveware_login" },
   );