@newbase-clawchat/openclaw-clawchat 2026.5.12-2 → 2026.5.12-21

package/src/tools.test.ts

@@ -1,9 +1,17 @@
 import fs from "node:fs";
-import { describe, expect, it, vi } from "vitest";
+import os from "node:os";
+import path from "node:path";
+import { Value } from "@sinclair/typebox/value";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { registerOpenclawClawlingTools } from "./tools.ts";
+import * as toolSchemas from "./tools-schema.ts";
+
+const schemas = toolSchemas as Record<string, unknown>;
 
 interface RegisteredTool {
   name: string;
+  description?: string;
+  parameters?: unknown;
   execute: (callId: string, params: unknown) => Promise<unknown>;
 }
 
@@ -13,9 +21,16 @@ const ALWAYS_VISIBLE_TOOL_NAMES = [
   "clawchat_delete_moment",
   "clawchat_delete_moment_comment",
   "clawchat_get_account_profile",
+  "clawchat_get_conversation",
   "clawchat_get_user_profile",
   "clawchat_list_account_friends",
+  "clawchat_list_conversations",
   "clawchat_list_moments",
+  "clawchat_memory_edit",
+  "clawchat_memory_read",
+  "clawchat_memory_write",
+  "clawchat_metadata_sync",
+  "clawchat_metadata_update",
   "clawchat_reply_moment_comment",
   "clawchat_search_users",
   "clawchat_toggle_moment_reaction",
@@ -24,12 +39,26 @@ const ALWAYS_VISIBLE_TOOL_NAMES = [
   "clawchat_upload_media_file",
 ];
 
+const tempRoots: string[] = [];
+
+afterEach(() => {
+  for (const dir of tempRoots.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 function buildApi(opts: {
   configChannel?: Record<string, unknown> | null;
   configTools?: Record<string, unknown>;
+  workspaceDir?: string;
   registerTool?: (tool: { name: string }, options?: { name: string }) => void;
 }) {
   const registered: RegisteredTool[] = [];
+  const stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-clawchat-tools-"));
+  const workspaceDir =
+    opts.workspaceDir ?? fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-clawchat-workspace-"));
+  tempRoots.push(stateDir);
+  tempRoots.push(workspaceDir);
   const api = {
     config:
       opts.configChannel === null
@@ -45,12 +74,32 @@ function buildApi(opts: {
       error: vi.fn(),
     },
     runtime: {
+      state: {
+        resolveStateDir: () => stateDir,
+      },
       config: {
         mutateConfigFile: vi.fn(),
       },
     },
-    registerTool: (tool: RegisteredTool, _options?: { name: string }) => {
-      registered.push(tool);
+    registerTool: (tool: RegisteredTool | ((ctx: unknown) => RegisteredTool | RegisteredTool[] | null | undefined), _options?: { name: string }) => {
+      const resolved =
+        typeof tool === "function"
+          ? tool({
+              workspaceDir,
+              agentId: "agent-default",
+              runtimeConfig: {
+                channels: { "openclaw-clawchat": opts.configChannel ?? {} },
+              },
+              getRuntimeConfig: () => ({
+                channels: { "openclaw-clawchat": opts.configChannel ?? {} },
+              }),
+            })
+          : tool;
+      if (Array.isArray(resolved)) {
+        registered.push(...resolved);
+      } else if (resolved) {
+        registered.push(resolved);
+      }
     },
   } as unknown as Parameters<typeof registerOpenclawClawlingTools>[0];
   return { api, registered };
@@ -60,6 +109,7 @@ function configuredChannel(extra: Record<string, unknown> = {}) {
   return {
     websocketUrl: "wss://w",
     token: "tk",
+    agentId: "agt-1",
     userId: "u",
     ...extra,
   };
@@ -105,6 +155,25 @@ describe("registerOpenclawClawlingTools", () => {
     expect(registered.some((t) => t.name === "clawchat_activate")).toBe(false);
   });
 
+  it("registers only read-only conversation tools", () => {
+    const { api, registered } = buildApi({
+      configChannel: configuredChannel(),
+    });
+
+    registerOpenclawClawlingTools(api);
+
+    const names = registered.map((t) => t.name);
+    expect(names).toContain("clawchat_list_conversations");
+    expect(names).toContain("clawchat_get_conversation");
+    expect(names).not.toContain("clawchat_create_group_conversation");
+    expect(names).not.toContain("clawchat_update_conversation");
+    expect(names).not.toContain("clawchat_leave_conversation");
+    expect(names).not.toContain("clawchat_dissolve_conversation");
+    expect(names).not.toContain("clawchat_add_conversation_member");
+    expect(names).not.toContain("clawchat_remove_conversation_member");
+    expect(names).not.toContain("clawchat_list_conversation_users");
+  });
+
   it("skips registration when api.config is undefined", () => {
     const { api, registered } = buildApi({ configChannel: null });
     registerOpenclawClawlingTools(api);
@@ -133,10 +202,143 @@ describe("registerOpenclawClawlingTools", () => {
 
     expect(logger.info).not.toHaveBeenCalled();
     expect(logger.debug).toHaveBeenCalledWith(
-      "openclaw-clawchat: registered 14 clawchat_* tools (get_account_profile, get_user_profile, list_account_friends, search_users, list_moments, create_moment, delete_moment, toggle_moment_reaction, create_moment_comment, reply_moment_comment, delete_moment_comment, update_account_profile, upload_avatar_image, upload_media_file)",
+      "openclaw-clawchat: registered 21 clawchat_* tools (get_account_profile, get_user_profile, list_account_friends, search_users, list_conversations, get_conversation, list_moments, create_moment, delete_moment, toggle_moment_reaction, create_moment_comment, reply_moment_comment, delete_moment_comment, update_account_profile, upload_avatar_image, upload_media_file, memory_read, memory_write, memory_edit, metadata_sync, metadata_update)",
     );
   });
 
+  it("registers exactly the five ClawChat memory and metadata tools without old-prefix aliases", () => {
+    const { api, registered } = buildApi({
+      configChannel: configuredChannel({ ownerUserId: "owner" }),
+    });
+
+    registerOpenclawClawlingTools(api);
+
+    const names = registered.map((t) => t.name).sort();
+    expect(names.filter((name) => /memory|metadata/.test(name))).toEqual([
+      "clawchat_memory_edit",
+      "clawchat_memory_read",
+      "clawchat_memory_write",
+      "clawchat_metadata_sync",
+      "clawchat_metadata_update",
+    ]);
+    expect(names).not.toContain("cc_memory_read");
+    expect(names).not.toContain("cc_metadata_sync");
+  });
+
+  it("keeps old ClawChat tools registered and guarded against direct HTTP or shell fallbacks", () => {
+    const { api, registered } = buildApi({
+      configChannel: configuredChannel({ ownerUserId: "owner" }),
+    });
+
+    registerOpenclawClawlingTools(api);
+
+    const oldTools = registered.filter((tool) => !/memory|metadata/.test(tool.name));
+    expect(oldTools.map((tool) => tool.name).sort()).toEqual(
+      ALWAYS_VISIBLE_TOOL_NAMES.filter((name) => !/memory|metadata/.test(name)),
+    );
+    for (const tool of oldTools) {
+      expect(tool.description).toMatch(/Do not use execute/);
+      expect(tool.description).toMatch(/shell commands/);
+      expect(tool.description).toMatch(/curl/);
+      expect(tool.description).toMatch(/direct ClawChat HTTP calls/);
+      expect(tool.description).toMatch(/generic fallback tools/);
+    }
+  });
+
+  it("memory and metadata schemas require explicit targets and bounded modes", () => {
+    const readSchema = schemas.ClawchatMemoryReadSchema;
+    const writeSchema = schemas.ClawchatMemoryWriteSchema;
+    const editSchema = schemas.ClawchatMemoryEditSchema;
+    const syncSchema = schemas.ClawchatMetadataSyncSchema;
+    const updateSchema = schemas.ClawchatMetadataUpdateSchema;
+    expect(readSchema).toBeDefined();
+    expect(writeSchema).toBeDefined();
+    expect(editSchema).toBeDefined();
+    expect(syncSchema).toBeDefined();
+    expect(updateSchema).toBeDefined();
+
+    for (const schema of [readSchema, writeSchema, editSchema, syncSchema, updateSchema]) {
+      expect((schema as { type?: unknown }).type).toBe("object");
+      expect(schema).not.toHaveProperty("anyOf");
+      expect(schema).not.toHaveProperty("oneOf");
+    }
+
+    for (const targetType of ["owner", "user", "group"] as const) {
+      expect(Value.Check(readSchema, { targetType, targetId: targetType === "owner" ? "owner" : "id_1" })).toBe(true);
+    }
+    expect(Value.Check(readSchema, { targetType: "profile", targetId: "id_1" })).toBe(false);
+    expect(Value.Check(readSchema, { targetType: "user" })).toBe(false);
+    expect(Value.Check(readSchema, { targetType: "user", targetId: "id_1", filePath: "users/id_1.md" })).toBe(false);
+
+    expect(Value.Check(writeSchema, { targetType: "user", targetId: "usr_1", mode: "append", content: "note" })).toBe(true);
+    expect(Value.Check(writeSchema, { targetType: "user", targetId: "usr_1", mode: "replace", content: "" })).toBe(true);
+    expect(Value.Check(writeSchema, { targetType: "user", targetId: "usr_1", mode: "merge", content: "note" })).toBe(false);
+
+    expect(Value.Check(syncSchema, { targetType: "owner", targetId: "owner", direction: "pull" })).toBe(true);
+    expect(Value.Check(syncSchema, { targetType: "group", targetId: "grp_1", direction: "push" })).toBe(true);
+    expect(Value.Check(syncSchema, { targetType: "group", targetId: "grp_1", direction: "refresh" })).toBe(false);
+  });
+
+  it("metadata update schema requires a non-empty whitelisted patch", () => {
+    const schema = schemas.ClawchatMetadataUpdateSchema;
+    expect(schema).toBeDefined();
+
+    expect(Value.Check(schema, {
+      targetType: "owner",
+      targetId: "owner",
+      patch: { nickname: "Bot" },
+    })).toBe(true);
+    expect(Value.Check(schema, {
+      targetType: "user",
+      targetId: "usr_1",
+      patch: { avatar_url: "https://cdn/avatar.png", bio: "" },
+    })).toBe(true);
+    expect(Value.Check(schema, {
+      targetType: "group",
+      targetId: "grp_1",
+      patch: { title: "Team", description: "Planning" },
+    })).toBe(true);
+    expect(Value.Check(schema, { targetType: "owner", targetId: "owner" })).toBe(false);
+    expect(Value.Check(schema, { targetType: "owner", targetId: "owner", patch: {} })).toBe(false);
+    for (const key of ["visibility", "status", "platform", "raw", "kind"]) {
+      expect(Value.Check(schema, {
+        targetType: "owner",
+        targetId: "owner",
+        patch: { [key]: "not allowed" },
+      })).toBe(false);
+      expect(Value.Check(schema, {
+        targetType: "group",
+        targetId: "grp_1",
+        patch: { [key]: "not allowed" },
+      })).toBe(false);
+    }
+  });
+
+  it("memory tool safety errors do not expose workspace paths", async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-clawchat-workspace-"));
+    tempRoots.push(workspaceDir);
+    fs.symlinkSync(os.tmpdir(), path.join(workspaceDir, "users"));
+    const { api, registered } = buildApi({
+      configChannel: configuredChannel({ ownerUserId: "owner" }),
+      workspaceDir,
+    });
+
+    registerOpenclawClawlingTools(api);
+    const tool = registered.find((t) => t.name === "clawchat_memory_read")!;
+    const result = await tool.execute("call-1", { targetType: "user", targetId: "usr_1" });
+
+    const parsed = JSON.parse((result as { content: { text: string }[] }).content[0]!.text) as {
+      error?: string;
+      message?: string;
+    };
+    expect(parsed).toMatchObject({
+      error: "validation",
+      message: "openclaw-clawchat: unsafe ClawChat memory target",
+    });
+    expect(parsed.message).not.toContain(workspaceDir);
+    expect(parsed.message).not.toContain(os.tmpdir());
+  });
+
   it("account tools return a config error before activation instead of disappearing", async () => {
     const { api, registered } = buildApi({
       configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
@@ -152,6 +354,285 @@ describe("registerOpenclawClawlingTools", () => {
     expect(parsed.message).toMatch(/token is required/i);
   });
 
+  it("records successful clawchat tool calls without changing the returned result", async () => {
+    const store = { recordToolCall: vi.fn() };
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          code: 0,
+          msg: "ok",
+          data: { user_id: "u", nickname: "Bot", avatar_url: "", bio: "" },
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      ),
+    );
+    try {
+      const { api, registered } = buildApi({
+        configChannel: configuredChannel({ baseUrl: "https://api.example.com" }),
+      });
+      registerOpenclawClawlingTools(api, { store });
+      const tool = registered.find((t) => t.name === "clawchat_get_account_profile")!;
+
+      const result = await tool.execute("call-1", {});
+
+      expect((result as { details: unknown }).details).toEqual({
+        user_id: "u",
+        nickname: "Bot",
+        avatar_url: "",
+        bio: "",
+      });
+      expect(store.recordToolCall).toHaveBeenCalledTimes(1);
+      expect(store.recordToolCall).toHaveBeenCalledWith(
+        expect.objectContaining({
+          platform: "openclaw",
+          accountId: "default",
+          toolName: "clawchat_get_account_profile",
+          args: {},
+          result: { user_id: "u", nickname: "Bot", avatar_url: "", bio: "" },
+          error: null,
+          startedAt: expect.any(Number),
+          endedAt: expect.any(Number),
+        }),
+      );
+    } finally {
+      fetchMock.mockRestore();
+    }
+  });
+
+  it("lists conversations, upserts returned summaries, and does not fetch or delete extra cache entries", async () => {
+    const store = {
+      recordToolCall: vi.fn(),
+      upsertConversationSummary: vi.fn(),
+      upsertConversationDetails: vi.fn(),
+      deleteConversationCache: vi.fn(),
+    };
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          code: 0,
+          msg: "ok",
+          data: {
+            conversations: [
+              {
+                id: "cnv_1",
+                type: "direct",
+                title: "Alice",
+                created_at: "2026-05-01T00:00:00Z",
+                updated_at: "2026-05-02T00:00:00Z",
+                peer: { id: "alice", type: "user", nickname: "Alice", avatar_url: "" },
+              },
+            ],
+            next_before: "cursor-2",
+          },
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      ),
+    );
+    try {
+      const { api, registered } = buildApi({
+        configChannel: configuredChannel({ baseUrl: "https://api.example.com" }),
+      });
+      registerOpenclawClawlingTools(api, { store });
+      const tool = registered.find((t) => t.name === "clawchat_list_conversations")!;
+
+      const result = await tool.execute("call-1", { before: "cursor-1", limit: 10 });
+
+      expect((result as { details: unknown }).details).toEqual({
+        conversations: [
+          {
+            id: "cnv_1",
+            type: "direct",
+            title: "Alice",
+            created_at: "2026-05-01T00:00:00Z",
+            updated_at: "2026-05-02T00:00:00Z",
+            peer: { id: "alice", type: "user", nickname: "Alice", avatar_url: "" },
+          },
+        ],
+        next_before: "cursor-2",
+      });
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.example.com/v1/conversations?before=cursor-1&limit=10");
+      expect(store.upsertConversationSummary).toHaveBeenCalledWith(
+        expect.objectContaining({
+          platform: "openclaw",
+          accountId: "default",
+          conversationId: "cnv_1",
+          conversationType: "direct",
+          raw: expect.objectContaining({ id: "cnv_1" }),
+        }),
+      );
+      expect(store.upsertConversationDetails).not.toHaveBeenCalled();
+      expect(store.deleteConversationCache).not.toHaveBeenCalled();
+    } finally {
+      fetchMock.mockRestore();
+    }
+  });
+
+  it("gets a conversation and upserts full details", async () => {
+    const store = {
+      recordToolCall: vi.fn(),
+      upsertConversationSummary: vi.fn(),
+      upsertConversationDetails: vi.fn(),
+      deleteConversationCache: vi.fn(),
+    };
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          code: 0,
+          msg: "ok",
+          data: {
+            conversation: {
+              id: "group_1",
+              type: "group",
+              title: "Project Group",
+              creator_id: "owner",
+              created_at: "2026-05-01T00:00:00Z",
+              updated_at: "2026-05-02T00:00:00Z",
+              participants: [
+                { conversation_id: "group_1", user_id: "owner", role: "owner", joined_at: "2026-05-01T00:00:00Z" },
+              ],
+            },
+          },
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      ),
+    );
+    try {
+      const { api, registered } = buildApi({
+        configChannel: configuredChannel({ baseUrl: "https://api.example.com" }),
+      });
+      registerOpenclawClawlingTools(api, { store });
+      const tool = registered.find((t) => t.name === "clawchat_get_conversation")!;
+
+      await tool.execute("call-1", { conversationId: "group_1" });
+
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(fetchMock.mock.calls[0]?.[0]).toBe("https://api.example.com/v1/conversations/group_1");
+      expect(store.upsertConversationDetails).toHaveBeenCalledWith(
+        expect.objectContaining({
+          platform: "openclaw",
+          accountId: "default",
+          conversationId: "group_1",
+          conversationType: "group",
+          raw: expect.objectContaining({ id: "group_1" }),
+          members: [expect.objectContaining({ userId: "owner", role: "owner" })],
+          membersComplete: true,
+        }),
+      );
+      const details = store.upsertConversationDetails.mock.calls[0]?.[0] as Record<string, unknown>;
+      expect(Object.prototype.hasOwnProperty.call(details, "groupProfile")).toBe(false);
+      expect(Object.prototype.hasOwnProperty.call(details, "userProfiles")).toBe(false);
+    } finally {
+      fetchMock.mockRestore();
+    }
+  });
+
+  it("deletes conversation-scoped cache and returns the standard error result when get conversation is not found", async () => {
+    const store = {
+      recordToolCall: vi.fn(),
+      upsertConversationSummary: vi.fn(),
+      upsertConversationDetails: vi.fn(),
+      deleteConversationCache: vi.fn(),
+    };
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ code: 40401, msg: "conversation not found", data: null }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }),
+    );
+    try {
+      const { api, registered } = buildApi({
+        configChannel: configuredChannel({ baseUrl: "https://api.example.com" }),
+      });
+      registerOpenclawClawlingTools(api, { store });
+      const tool = registered.find((t) => t.name === "clawchat_get_conversation")!;
+
+      const result = await tool.execute("call-1", { conversationId: "missing" });
+
+      const parsed = JSON.parse((result as { content: { text: string }[] }).content[0]!.text) as {
+        error?: string;
+        message?: string;
+        meta?: { code?: number };
+      };
+      expect(parsed).toMatchObject({
+        error: "api",
+        message: "conversation not found",
+        meta: { code: 40401 },
+      });
+      expect(store.deleteConversationCache).toHaveBeenCalledWith({
+        platform: "openclaw",
+        accountId: "default",
+        conversationId: "missing",
+      });
+      expect(store.upsertConversationSummary).not.toHaveBeenCalled();
+      expect(store.upsertConversationDetails).not.toHaveBeenCalled();
+    } finally {
+      fetchMock.mockRestore();
+    }
+  });
+
+  it("does not write conversation cache from account, user, friend, search, avatar, or media tools", async () => {
+    const store = {
+      recordToolCall: vi.fn(),
+      upsertConversationSummary: vi.fn(),
+      upsertConversationDetails: vi.fn(),
+      deleteConversationCache: vi.fn(),
+    };
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          code: 0,
+          msg: "ok",
+          data: { id: "u", nickname: "Bot", avatar_url: "", bio: "" },
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      ),
+    );
+    try {
+      const { api, registered } = buildApi({
+        configChannel: configuredChannel({ baseUrl: "https://api.example.com" }),
+      });
+      registerOpenclawClawlingTools(api, { store });
+      const tool = registered.find((t) => t.name === "clawchat_get_account_profile")!;
+
+      await tool.execute("call-1", {});
+
+      expect(store.upsertConversationSummary).not.toHaveBeenCalled();
+      expect(store.upsertConversationDetails).not.toHaveBeenCalled();
+      expect(store.deleteConversationCache).not.toHaveBeenCalled();
+    } finally {
+      fetchMock.mockRestore();
+    }
+  });
+
+  it("records clawchat tool failures while preserving the returned error result", async () => {
+    const store = { recordToolCall: vi.fn() };
+    const { api, registered } = buildApi({
+      configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
+    });
+    registerOpenclawClawlingTools(api, { store });
+    const tool = registered.find((t) => t.name === "clawchat_get_account_profile")!;
+
+    const result = await tool.execute("call-1", {});
+
+    const parsed = JSON.parse((result as { content: { text: string }[] }).content[0]!.text) as {
+      error?: string;
+      message?: string;
+    };
+    expect(parsed).toMatchObject({ error: "config" });
+    expect(store.recordToolCall).toHaveBeenCalledWith(
+      expect.objectContaining({
+        platform: "openclaw",
+        accountId: "default",
+        toolName: "clawchat_get_account_profile",
+        args: {},
+        result: parsed,
+        error: expect.stringContaining("config"),
+      }),
+    );
+    expect(registered.every((tool) => tool.name.startsWith("clawchat_"))).toBe(true);
+  });
+
   it("clawchat_update_account_profile description names account profile triggers (EN + ZH)", () => {
     const { api } = buildApi({ configChannel: configuredChannel() });
     const fullTools: Array<{ name: string; description?: string }> = [];
@@ -175,15 +656,13 @@ describe("registerOpenclawClawlingTools", () => {
   });
 
   it("account query and upload tool descriptions include precise trigger semantics", () => {
-    const { api } = buildApi({ configChannel: configuredChannel() });
-    const fullTools: Array<{ name: string; description?: string }> = [];
-    api.registerTool = (tool: { name: string; description?: string }) => {
-      fullTools.push(tool);
-    };
+    const { api, registered: fullTools } = buildApi({ configChannel: configuredChannel() });
     registerOpenclawClawlingTools(api);
 
     const accountProfile = fullTools.find((t) => t.name === "clawchat_get_account_profile")!;
     const userProfile = fullTools.find((t) => t.name === "clawchat_get_user_profile")!;
+    const memoryWrite = fullTools.find((t) => t.name === "clawchat_memory_write")!;
+    const metadataSync = fullTools.find((t) => t.name === "clawchat_metadata_sync")!;
     const friends = fullTools.find((t) => t.name === "clawchat_list_account_friends")!;
     const avatar = fullTools.find((t) => t.name === "clawchat_upload_avatar_image")!;
     const media = fullTools.find((t) => t.name === "clawchat_upload_media_file")!;
@@ -195,10 +674,22 @@ describe("registerOpenclawClawlingTools", () => {
     expect(userProfile.description).toMatch(/userId/);
     expect(userProfile.description).toMatch(/public profile/i);
     expect(userProfile.description).toMatch(/do not guess|do not infer/i);
+    expect(userProfile.description).toMatch(/read-only lookup/i);
+    expect(userProfile.description).toMatch(/clawchat_metadata_sync.*direction=pull/i);
+
+    expect(memoryWrite.description).toMatch(/agent-authored body/i);
+    expect(memoryWrite.description).toMatch(/never modifies the metadata block/i);
+    expect(memoryWrite.description).toMatch(/Do not use.*nickname.*avatar_url.*bio.*profile_type/i);
+    expect(memoryWrite.description).toMatch(/refresh.*local ClawChat.*profile.*clawchat_metadata_sync.*direction=pull/i);
+
+    expect(metadataSync.description).toMatch(/refresh, sync, or update local ClawChat profile information/i);
+    expect(metadataSync.description).toMatch(/rewrites only the metadata block/i);
+    expect(metadataSync.description).toMatch(/Do not combine clawchat_get_user_profile with clawchat_memory_write/i);
 
     expect(friends.description).toMatch(/configured ClawChat account|logged-in ClawChat account/i);
     expect(friends.description).toMatch(/friends|contacts/i);
-    expect(friends.description).toMatch(/page=1|pageSize=20/);
+    expect(friends.description).not.toMatch(/paginated|page=1|pageSize=20/i);
+    expect(friends.parameters?.properties ?? {}).toEqual({});
 
     expect(avatar.description).toMatch(/local image/i);
     expect(avatar.description).toMatch(/avatar URL|hosted avatar URL|public URL/i);