@newbase-clawchat/openclaw-clawchat 2026.4.29 → 2026.4.30

package/src/runtime.ts

@@ -262,6 +262,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
             ...(replyCtx ? { replyCtx } : {}),
             inboundMessageId: turn.messageId,
             inboundForFinalReply: {
+              chatId: turn.peer.id,
               senderId: turn.senderId,
               senderNickName: turn.senderNickName || turn.senderId,
               bodyText: turn.rawBody,

package/src/streaming.test.ts

@@ -37,12 +37,12 @@ describe("openclaw-clawchat streaming", () => {
       "message.done",
     ]);
     expect((client.typing as ReturnType<typeof vi.fn>).mock.calls).toEqual([
-      ["u1", true, "direct"],
-      ["u1", false, "direct"],
+      ["u1", true],
+      ["u1", false],
     ]);
   });
 
-  it("message.created payload is minimal (just message_id); adds carry monotonic sequences", async () => {
+  it("message.created payload is minimal (just message_id); adds carry zero-based monotonic sequences", async () => {
     const { client, sent } = mockClient();
     await sendStreamingText({
       client,
@@ -54,10 +54,10 @@ describe("openclaw-clawchat streaming", () => {
 
     // created payload is { message_id } only — no embedded message / streaming.
     expect(sent[0]!.payload).toEqual({ message_id: "m1" });
-    expect(sent[1]!.payload.sequence).toBe(1);
-    expect(sent[2]!.payload.sequence).toBe(2);
-    expect(sent[3]!.payload.sequence).toBe(3);
-    expect((sent[4]!.payload.streaming as { sequence: number }).sequence).toBe(3);
+    expect(sent[1]!.payload.sequence).toBe(0);
+    expect(sent[2]!.payload.sequence).toBe(1);
+    expect(sent[3]!.payload.sequence).toBe(2);
+    expect((sent[4]!.payload.streaming as { sequence: number }).sequence).toBe(2);
   });
 
   it("each message.add carries fragments: [{ text: cumulative, delta: new }]", async () => {
@@ -107,10 +107,13 @@ describe("openclaw-clawchat streaming", () => {
       reason: "boom",
     });
     expect(sent[0]!.event).toBe("message.failed");
-    expect(sent[0]!.payload.sequence).toBe(3);
+    expect(sent[0]!.payload.sequence).toBe(2);
     expect(sent[0]!.payload.reason).toBe("boom");
+    expect(sent[0]!.payload).toHaveProperty("completed_at");
+    expect(sent[0]!.payload).not.toHaveProperty("failed_at");
+    expect(sent[0]!.payload.fragments).toEqual([{ kind: "text", text: "boom" }]);
     expect((client.typing as ReturnType<typeof vi.fn>).mock.calls).toEqual([
-      ["u1", false, "direct"],
+      ["u1", false],
     ]);
   });
 });

package/src/streaming.ts

@@ -45,13 +45,13 @@ export async function sendStreamingText(params: StreamingSendParams): Promise<vo
   const routing = resolveRouting(params);
   const emitTyping = params.emitTyping !== false;
   if (emitTyping) {
-    params.client.typing(routing.chatId, true, routing.chatType);
+    params.client.typing(routing.chatId, true);
   }
   emitStreamCreated(params.client, {
     messageId: params.messageId,
     routing,
   });
-  let sequence = 0;
+  let sequence = -1;
   let fullText = "";
   for (const chunk of params.chunks) {
     sequence += 1;
@@ -67,11 +67,11 @@ export async function sendStreamingText(params: StreamingSendParams): Promise<vo
   emitStreamDone(params.client, {
     messageId: params.messageId,
     routing,
-    finalSequence: sequence,
+    finalSequence: Math.max(sequence, 0),
     finalText: fullText,
   });
   if (emitTyping) {
-    params.client.typing(routing.chatId, false, routing.chatType);
+    params.client.typing(routing.chatId, false);
   }
 }
 
@@ -90,10 +90,10 @@ export async function sendStreamingFailure(params: StreamingFailureParams): Prom
   emitStreamFailed(params.client, {
     messageId: params.messageId,
     routing,
-    sequence: params.currentSequence + 1,
+    sequence: params.currentSequence,
     reason: params.reason,
   });
   if (params.emitTyping !== false) {
-    params.client.typing(routing.chatId, false, routing.chatType);
+    params.client.typing(routing.chatId, false);
   }
 }

package/src/tools.test.ts

@@ -1,4 +1,5 @@
-import { describe, expect, it, vi } from "vitest";
+import fs from "node:fs";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { registerOpenclawClawlingTools } from "./tools.ts";
 
 const loginRuntime = vi.hoisted(() => ({
@@ -12,6 +13,16 @@ interface RegisteredTool {
   execute: (callId: string, params: unknown) => Promise<unknown>;
 }
 
+const ALWAYS_VISIBLE_TOOL_NAMES = [
+  "clawchat_activate",
+  "clawchat_get_account_profile",
+  "clawchat_get_user_profile",
+  "clawchat_list_account_friends",
+  "clawchat_update_account_profile",
+  "clawchat_upload_avatar_image",
+  "clawchat_upload_media_file",
+];
+
 function buildApi(opts: {
   configChannel?: Record<string, unknown> | null;
   configTools?: Record<string, unknown>;
@@ -32,6 +43,11 @@ function buildApi(opts: {
       warn: vi.fn(),
       error: vi.fn(),
     },
+    runtime: {
+      config: {
+        mutateConfigFile: vi.fn(),
+      },
+    },
     registerTool: (tool: RegisteredTool, _options?: { name: string }) => {
       registered.push(tool);
     },
@@ -49,12 +65,22 @@ function configuredChannel(extra: Record<string, unknown> = {}) {
 }
 
 describe("registerOpenclawClawlingTools", () => {
-  it("registers no tools when account.configured is false", () => {
+  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/);
+    expect(source).toMatch(/openclaw\/plugin-sdk\/agent-harness-runtime/);
+  });
+
+  it("registers all ClawChat tools even when account.configured is false", () => {
     const { api, registered } = buildApi({
       configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
     });
     registerOpenclawClawlingTools(api);
-    expect(registered.map((t) => t.name)).toEqual([]);
+    expect(registered.map((t) => t.name).sort()).toEqual(ALWAYS_VISIBLE_TOOL_NAMES);
   });
 
   it("does not mutate tool policy during registration before account activation", () => {
@@ -65,22 +91,51 @@ describe("registerOpenclawClawlingTools", () => {
 
     registerOpenclawClawlingTools(api);
 
-    expect(registered.map((t) => t.name)).toEqual([]);
+    expect(registered.map((t) => t.name).sort()).toEqual(ALWAYS_VISIBLE_TOOL_NAMES);
     expect(api.config?.tools).toEqual({
       profile: "coding",
       allow: [],
     });
   });
 
-  it("does not register clawchat_activate for invite-code onboarding", async () => {
+  it("registers clawchat_activate for invite-code onboarding", async () => {
+    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);
+  });
+
+  it("clawchat_activate rejects empty invite codes", async () => {
     const { api, registered } = buildApi({
       configChannel: { websocketUrl: "wss://w" /* token / userId missing */ },
     });
 
     registerOpenclawClawlingTools(api);
+    const tool = registered.find((t) => t.name === "clawchat_activate")!;
+    const result = await tool.execute("call-1", { code: "   " });
 
-    expect(registered.some((t) => t.name === "clawchat_activate")).toBe(false);
     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);
   });
 
   it("skips registration when api.config is undefined", () => {
@@ -89,20 +144,13 @@ describe("registerOpenclawClawlingTools", () => {
     expect(registered).toHaveLength(0);
   });
 
-  it("registers all six account tools when configured (regardless of baseUrl)", () => {
+  it("registers all seven ClawChat tools when configured (regardless of baseUrl)", () => {
     const { api, registered } = buildApi({
       configChannel: configuredChannel(/* no baseUrl */),
     });
     registerOpenclawClawlingTools(api);
     const names = registered.map((t) => t.name).sort();
-    expect(names).toEqual([
-      "clawchat_get_account_profile",
-      "clawchat_get_user_profile",
-      "clawchat_list_account_friends",
-      "clawchat_update_account_profile",
-      "clawchat_upload_avatar_image",
-      "clawchat_upload_media_file",
-    ]);
+    expect(names).toEqual(ALWAYS_VISIBLE_TOOL_NAMES);
   });
 
   it("logs configured tool registration at debug level only", () => {
@@ -118,16 +166,31 @@ describe("registerOpenclawClawlingTools", () => {
 
     expect(logger.info).not.toHaveBeenCalled();
     expect(logger.debug).toHaveBeenCalledWith(
-      "openclaw-clawchat: registered 6 clawchat_* tools (get_account_profile, get_user_profile, list_account_friends, update_account_profile, upload_avatar_image, upload_media_file)",
+      "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)",
     );
   });
 
-  it("does not register clawchat_activate when configured", () => {
+  it("registers clawchat_activate when configured", () => {
     const { api, registered } = buildApi({
       configChannel: configuredChannel(),
     });
     registerOpenclawClawlingTools(api);
-    expect(registered.some((t) => t.name === "clawchat_activate")).toBe(false);
+    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 */ },
+    });
+
+    registerOpenclawClawlingTools(api);
+    const tool = registered.find((t) => t.name === "clawchat_get_account_profile")!;
+    const result = await tool.execute("call-1", {});
+
+    const text = (result as { content: { text: string }[] }).content[0]!.text;
+    const parsed = JSON.parse(text) as { error?: string; message?: string };
+    expect(parsed.error).toBe("config");
+    expect(parsed.message).toMatch(/token is required/i);
   });
 
   it("clawchat_update_account_profile description names account profile triggers (EN + ZH)", () => {

package/src/tools.ts

@@ -1,19 +1,20 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { OpenClawAgentToolResult } from "openclaw/plugin-sdk/agent-harness-runtime";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/feishu";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import type { OpenclawClawchatMutateConfigFile } from "./login.runtime.ts";
 import { createOpenclawClawlingApiClient } from "./api-client.ts";
 import { ClawlingApiError, type Profile } from "./api-types.ts";
 import { resolveOpenclawClawlingAccount } from "./config.ts";
 import {
-  // ClawchatActivateSchema,
+  ClawchatActivateSchema,
   ClawchatGetAccountProfileSchema,
   ClawchatGetUserProfileSchema,
   ClawchatListAccountFriendsSchema,
   ClawchatUpdateAccountProfileSchema,
   ClawchatUploadAvatarImageSchema,
   ClawchatUploadMediaFileSchema,
-  // type ClawchatActivateParams,
+  type ClawchatActivateParams,
   type ClawchatGetUserProfileParams,
   type ClawchatListAccountFriendsParams,
   type ClawchatUpdateAccountProfileParams,
@@ -46,12 +47,12 @@ function validationError(message: string) {
   return jsonResponse({ error: "validation", message });
 }
 
-// function resolveActivateCode(params: ClawchatActivateParams & { command?: unknown }): string {
-//   const explicit = typeof params.code === "string" ? params.code.trim() : "";
-//   if (explicit) return explicit;
-//   const command = typeof params.command === "string" ? params.command.trim() : "";
-//   return command.match(/\b[A-Z0-9]{6}\b/u)?.[0] ?? "";
-// }
+function resolveActivateCode(params: ClawchatActivateParams & { command?: unknown }): string {
+  const explicit = typeof params.code === "string" ? params.code.trim() : "";
+  if (explicit) return explicit;
+  const command = typeof params.command === "string" ? params.command.trim() : "";
+  return command.match(/\b[A-Z0-9]{6}\b/u)?.[0] ?? "";
+}
 
 function genericError(err: unknown) {
   return jsonResponse({
@@ -94,64 +95,53 @@ export function registerOpenclawClawlingTools(api: OpenClawPluginApi): void {
     return;
   }
 
-  // -----------------------------------------------------------------------
-  // `clawchat_activate` tool disabled: activation now goes through OpenClaw
-  // channel login.
-  // -----------------------------------------------------------------------
-  // api.registerTool(
-  //   {
-  //     name: "clawchat_activate",
-  //     label: "Clawling: Activate (Login with Invite Code)",
-  //     description:
-  //       "Activate this OpenClaw plugin on ClawChat by exchanging an invite code for a token. " +
-  //       "Invite codes use six uppercase letters/digits, e.g. A1B2C3. " +
-  //       "TRIGGER — invoke this tool whenever the user's message matches ANY of: " +
-  //       "(1) activation intent with an embedded invite code, such as 'activate ClawChat with invite code A1B2C3', " +
-  //       "'login to ClawChat with invite code A1B2C3', 'connect ClawChat using invite code A1B2C3', " +
-  //       "or '绑定 ClawChat，邀请码 A1B2C3' — call this tool with `code = \"A1B2C3\"`; " +
-  //       "(2) generic activation intent without an embedded code, such as 'activate ClawChat' or " +
-  //       "'login to ClawChat' — ask for invite code before calling the tool; " +
-  //       "(3) activation intent with an embedded code, such as 'use invite code A1B2C3', " +
-  //       "or the user pasting an invite code in the context of ClawChat activation. " +
-  //       "Do not ask the user to enter a bare ClawChat command; if an invite code is present, call this tool directly. " +
-  //       "Extract the code verbatim — do NOT normalize / lowercase / add prefixes. " +
-  //       "On success the tool persists the resulting token + userId to the config, so " +
-  //       "subsequent `clawchat_*` calls work without any other setup.",
-  //     parameters: ClawchatActivateSchema,
-  //     async execute(_callId, params) {
-  //       const code = resolveActivateCode(params as ClawchatActivateParams & { command?: unknown });
-  //       if (!code) {
-  //         return validationError("openclaw-clawchat: code is required");
-  //       }
-  //       try {
-  //         const { runOpenclawClawlingLogin } = await import("./login.runtime.ts");
-  //         await runOpenclawClawlingLogin({
-  //           cfg: api.config!,
-  //           accountId: null,
-  //           runtime: { log: (message: string) => api.logger.info?.(message) },
-  //           readInviteCode: async () => code,
-  //         });
-  //         return jsonResponse({
-  //           ok: true,
-  //           message: "✅ ClawChat activated successfully.",
-  //         });
-  //       } catch (err) {
-  //         if (err instanceof ClawlingApiError) return apiError(err);
-  //         return genericError(err);
-  //       }
-  //     },
-  //   },
-  //   { name: "clawchat_activate" },
-  // );
-
-  const account = resolveOpenclawClawlingAccount(api.config);
-  if (!account.configured) {
-    api.logger.debug?.(
-      "openclaw-clawchat: account not yet configured; account tools will register " +
-        "on the next config reload after channel login.",
-    );
-    return;
-  }
+  api.registerTool(
+    {
+      name: "clawchat_activate",
+      label: "Clawling: Activate (Login with Invite Code)",
+      description:
+        "Activate this OpenClaw plugin on ClawChat by exchanging an invite code for a token. " +
+        "Invite codes use six uppercase letters/digits, e.g. A1B2C3. " +
+        "TRIGGER — invoke this tool whenever the user's message matches ANY of: " +
+        "(1) activation intent with an embedded invite code, such as 'activate ClawChat with invite code A1B2C3', " +
+        "'login to ClawChat with invite code A1B2C3', 'connect ClawChat using invite code A1B2C3', " +
+        "or '绑定 ClawChat，邀请码 A1B2C3' — call this tool with `code = \"A1B2C3\"`; " +
+        "(2) generic activation intent without an embedded code, such as 'activate ClawChat' or " +
+        "'login to ClawChat' — ask for invite code before calling the tool; " +
+        "(3) activation intent with an embedded code, such as 'use invite code A1B2C3', " +
+        "or the user pasting an invite code in the context of ClawChat activation. " +
+        "Extract the code verbatim — do NOT normalize / lowercase / add prefixes. " +
+        "On success the tool persists the resulting token + userId to the config, so " +
+        "subsequent `clawchat_*` calls work without another plugin registration pass.",
+      parameters: ClawchatActivateSchema,
+      async execute(_callId, params) {
+        const code = resolveActivateCode(params as ClawchatActivateParams & { command?: unknown });
+        if (!code) {
+          return validationError("openclaw-clawchat: code is required");
+        }
+        try {
+          const { runOpenclawClawlingLogin } = await import("./login.runtime.ts");
+          await runOpenclawClawlingLogin({
+            cfg: api.config!,
+            accountId: null,
+            runtime: { log: (message: string) => api.logger.info?.(message) },
+            readInviteCode: async () => code,
+            mutateConfigFile: (api.runtime.config as unknown as {
+              mutateConfigFile: OpenclawClawchatMutateConfigFile;
+            }).mutateConfigFile,
+          });
+          return jsonResponse({
+            ok: true,
+            message: "ClawChat activated successfully.",
+          });
+        } catch (err) {
+          if (err instanceof ClawlingApiError) return apiError(err);
+          return genericError(err);
+        }
+      },
+    },
+    { name: "clawchat_activate" },
+  );
 
   // Re-resolve at call time so config reloads pick up new tokens / baseUrl.
   function resolveCurrent() {
@@ -159,8 +149,8 @@ export function registerOpenclawClawlingTools(api: OpenClawPluginApi): void {
   }
 
   type ClientResult =
-    | { error: OpenClawAgentToolResult<unknown>; client?: never }
-    | { client: ReturnType<typeof createOpenclawClawlingApiClient>; error?: never };
+    | { ok: false; error: OpenClawAgentToolResult<unknown> }
+    | { ok: true; client: ReturnType<typeof createOpenclawClawlingApiClient> };
 
   function buildClient(): ClientResult {
     const acct = resolveCurrent();
@@ -168,9 +158,10 @@ export function registerOpenclawClawlingTools(api: OpenClawPluginApi): void {
     // only need to gate on `token` here (which is populated by `openclaw
     // channel login`).
     if (!acct.token) {
-      return { error: configError("openclaw-clawchat: token is required") };
+      return { ok: false, error: configError("openclaw-clawchat: token is required") };
     }
     return {
+      ok: true,
       client: createOpenclawClawlingApiClient({
         baseUrl: acct.baseUrl,
         token: acct.token,
@@ -184,7 +175,7 @@ export function registerOpenclawClawlingTools(api: OpenClawPluginApi): void {
   ): Promise<OpenClawAgentToolResult<unknown>> {
     return (async (): Promise<OpenClawAgentToolResult<unknown>> => {
       const built = buildClient();
-      if (built.error !== undefined) return built.error;
+      if (!built.ok) return built.error;
       try {
         const data = await fn(built.client);
         return jsonResponse(data);
@@ -368,6 +359,6 @@ export function registerOpenclawClawlingTools(api: OpenClawPluginApi): void {
   );
 
   api.logger.debug?.(
-    "openclaw-clawchat: registered 6 clawchat_* tools (get_account_profile, get_user_profile, list_account_friends, update_account_profile, upload_avatar_image, upload_media_file)",
+    "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)",
   );
 }