@newbase-clawchat/openclaw-clawchat 2026.5.4 → 2026.5.12-13

package/src/tools.test.ts

@@ -1,34 +1,49 @@
 import fs from "node:fs";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { registerOpenclawClawlingTools } from "./tools.ts";
 
-const loginRuntime = vi.hoisted(() => ({
-  runOpenclawClawlingLogin: vi.fn(),
-}));
-
-vi.mock("./login.runtime.ts", () => loginRuntime);
-
 interface RegisteredTool {
   name: string;
   execute: (callId: string, params: unknown) => Promise<unknown>;
 }
 
 const ALWAYS_VISIBLE_TOOL_NAMES = [
-  "clawchat_activate",
+  "clawchat_create_moment",
+  "clawchat_create_moment_comment",
+  "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_reply_moment_comment",
+  "clawchat_search_users",
+  "clawchat_toggle_moment_reaction",
   "clawchat_update_account_profile",
   "clawchat_upload_avatar_image",
   "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>;
   registerTool?: (tool: { name: string }, options?: { name: string }) => void;
 }) {
   const registered: RegisteredTool[] = [];
+  const stateDir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-clawchat-tools-"));
+  tempRoots.push(stateDir);
   const api = {
     config:
       opts.configChannel === null
@@ -44,6 +59,9 @@ function buildApi(opts: {
       error: vi.fn(),
     },
     runtime: {
+      state: {
+        resolveStateDir: () => stateDir,
+      },
       config: {
         mutateConfigFile: vi.fn(),
       },
@@ -65,10 +83,6 @@ function configuredChannel(extra: Record<string, unknown> = {}) {
 }
 
 describe("registerOpenclawClawlingTools", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
   it("uses OpenClaw SDK tool result types instead of direct pi-agent-core imports", () => {
     const source = fs.readFileSync(new URL("./tools.ts", import.meta.url), "utf8");
     expect(source).not.toMatch(/@mariozechner\/pi-agent-core/);
@@ -98,44 +112,33 @@ describe("registerOpenclawClawlingTools", () => {
     });
   });
 
-  it("registers clawchat_activate for invite-code onboarding", async () => {
+  it("does not register invite-code activation as an agent tool", () => {
     const { api, registered } = buildApi({
       configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
     });
 
     registerOpenclawClawlingTools(api);
 
-    const tool = registered.find((t) => t.name === "clawchat_activate");
-    expect(tool).toBeDefined();
-    loginRuntime.runOpenclawClawlingLogin.mockResolvedValueOnce(undefined);
-
-    const result = await tool!.execute("call-1", { code: "A1B2C3" });
-
-    expect(loginRuntime.runOpenclawClawlingLogin).toHaveBeenCalledTimes(1);
-    const params = loginRuntime.runOpenclawClawlingLogin.mock.calls[0]?.[0];
-    expect(params.cfg).toBe(api.config);
-    expect(params.mutateConfigFile).toBe(api.runtime.config.mutateConfigFile);
-    await expect(params.readInviteCode()).resolves.toBe("A1B2C3");
-    const text = (result as { content: { text: string }[] }).content[0]!.text;
-    const parsed = JSON.parse(text) as { ok?: boolean; message?: string };
-    expect(parsed.ok).toBe(true);
-    expect(parsed.message).toMatch(/activated successfully/i);
+    expect(registered.some((t) => t.name === "clawchat_activate")).toBe(false);
   });
 
-  it("clawchat_activate rejects empty invite codes", async () => {
+  it("registers only read-only conversation tools", () => {
     const { api, registered } = buildApi({
-      configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
+      configChannel: configuredChannel(),
     });
 
     registerOpenclawClawlingTools(api);
-    const tool = registered.find((t) => t.name === "clawchat_activate")!;
-    const result = await tool.execute("call-1", { code: "   " });
 
-    expect(loginRuntime.runOpenclawClawlingLogin).not.toHaveBeenCalled();
-    const text = (result as { content: { text: string }[] }).content[0]!.text;
-    const parsed = JSON.parse(text) as { error?: string; message?: string };
-    expect(parsed.error).toBe("validation");
-    expect(parsed.message).toMatch(/code is required/i);
+    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", () => {
@@ -144,7 +147,7 @@ describe("registerOpenclawClawlingTools", () => {
     expect(registered).toHaveLength(0);
   });
 
-  it("registers all seven ClawChat tools when configured (regardless of baseUrl)", () => {
+  it("registers all account/media/search/moment ClawChat tools when configured (regardless of baseUrl)", () => {
     const { api, registered } = buildApi({
       configChannel: configuredChannel(/* no baseUrl */),
     });
@@ -166,18 +169,10 @@ describe("registerOpenclawClawlingTools", () => {
 
     expect(logger.info).not.toHaveBeenCalled();
     expect(logger.debug).toHaveBeenCalledWith(
-      "openclaw-clawchat: registered 7 clawchat_* tools (activate, get_account_profile, get_user_profile, list_account_friends, update_account_profile, upload_avatar_image, upload_media_file)",
+      "openclaw-clawchat: registered 16 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)",
     );
   });
 
-  it("registers clawchat_activate when configured", () => {
-    const { api, registered } = buildApi({
-      configChannel: configuredChannel(),
-    });
-    registerOpenclawClawlingTools(api);
-    expect(registered.some((t) => t.name === "clawchat_activate")).toBe(true);
-  });
-
   it("account tools return a config error before activation instead of disappearing", async () => {
     const { api, registered } = buildApi({
       configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
@@ -193,6 +188,283 @@ 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" }),
+          groupProfile: expect.objectContaining({ title: "Project Group" }),
+          members: [expect.objectContaining({ userId: "owner", role: "owner" })],
+          membersComplete: true,
+        }),
+      );
+    } 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 }> = [];
@@ -217,8 +489,16 @@ 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 }) => {
+    const fullTools: Array<{
+      name: string;
+      description?: string;
+      parameters?: { properties?: Record<string, unknown> };
+    }> = [];
+    api.registerTool = (tool: {
+      name: string;
+      description?: string;
+      parameters?: { properties?: Record<string, unknown> };
+    }) => {
       fullTools.push(tool);
     };
     registerOpenclawClawlingTools(api);
@@ -239,7 +519,8 @@ describe("registerOpenclawClawlingTools", () => {
 
     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);
@@ -251,6 +532,52 @@ describe("registerOpenclawClawlingTools", () => {
     expect(media.description).toMatch(/not.*avatar|do not use.*avatar/i);
   });
 
+  it("search and moment tool descriptions match reviewed trigger semantics", () => {
+    const { api } = buildApi({ configChannel: configuredChannel() });
+    const fullTools: Array<{ name: string; description?: string }> = [];
+    api.registerTool = (tool: { name: string; description?: string }) => {
+      fullTools.push(tool);
+    };
+    registerOpenclawClawlingTools(api);
+
+    const search = fullTools.find((t) => t.name === "clawchat_search_users")!;
+    const listMoments = fullTools.find((t) => t.name === "clawchat_list_moments")!;
+    const createMoment = fullTools.find((t) => t.name === "clawchat_create_moment")!;
+    const deleteMoment = fullTools.find((t) => t.name === "clawchat_delete_moment")!;
+    const reaction = fullTools.find((t) => t.name === "clawchat_toggle_moment_reaction")!;
+    const comment = fullTools.find((t) => t.name === "clawchat_create_moment_comment")!;
+    const reply = fullTools.find((t) => t.name === "clawchat_reply_moment_comment")!;
+    const deleteComment = fullTools.find((t) => t.name === "clawchat_delete_moment_comment")!;
+
+    for (const tool of [
+      search,
+      listMoments,
+      createMoment,
+      deleteMoment,
+      reaction,
+      comment,
+      reply,
+      deleteComment,
+    ]) {
+      expect(tool.description).toMatch(/Do not use execute/);
+      expect(tool.description).toMatch(/direct ClawChat HTTP calls/);
+    }
+
+    expect(search.description).toMatch(/Search ClawChat users by username or nickname/);
+    expect(search.description).toMatch(/do not guess a userId/);
+    expect(listMoments.description).toMatch(/moments\/dynamics\/feed/);
+    expect(listMoments.description).toMatch(/friends-only feed endpoint/);
+    expect(createMoment.description).toMatch(/At least one of text or images/);
+    expect(createMoment.description).toMatch(/do not pass local file paths as images/);
+    expect(deleteMoment.description).toMatch(/Do not guess the id/);
+    expect(reaction.description).toMatch(/adds the reaction if missing and removes it/);
+    expect(comment.description).toMatch(/top-level comment/);
+    expect(comment.description).toMatch(/Use clawchat_reply_moment_comment/);
+    expect(reply.description).toMatch(/single-level reply/);
+    expect(reply.description).toMatch(/do not use this for top-level comments/);
+    expect(deleteComment.description).toMatch(/moment and comment ids/);
+  });
+
   it("clawchat_upload_avatar_image rejects oversized files before upload", async () => {
     const fs = await import("node:fs/promises");
     const path = await import("node:path");