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

package/src/client.test.ts

@@ -1,6 +1,7 @@
-import { MockTransport, type ClawlingChatClient } from "@newbase-clawchat/sdk";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 import { describe, expect, it, vi } from "vitest";
+import { MockTransport } from "./mock-transport.ts";
+import type { ClawlingChatClient } from "./ws-client.ts";
 import {
   createOpenclawClawlingClient,
   emitStreamCreated,
@@ -21,6 +22,7 @@ function baseAccount(): ResolvedOpenclawClawlingAccount {
     baseUrl: "",
     token: "t",
     userId: "agent-1",
+    ownerUserId: "owner-1",
     replyMode: "static",
     forwardThinking: true,
     forwardToolCalls: false,
@@ -38,11 +40,7 @@ function baseAccount(): ResolvedOpenclawClawlingAccount {
 }
 
 async function authenticate(transport: MockTransport) {
-  // Yield to allow MockTransport.connect's internal Promise.resolve() to fire
-  // onOpen (which transitions state: connecting -> challenging) before we send
-  // the challenge envelope.
   await Promise.resolve();
-  // Challenge from server
   transport.emitInbound(
     JSON.stringify({
       version: "2",
@@ -52,12 +50,14 @@ async function authenticate(transport: MockTransport) {
       payload: { nonce: "nonce-1" },
     }),
   );
-  // hello-ok
+  const connectFrame = transport.sent
+    .map((raw) => JSON.parse(raw))
+    .find((env) => env.event === "connect");
   transport.emitInbound(
     JSON.stringify({
       version: "2",
       event: "hello-ok",
-      trace_id: "t-hello",
+      trace_id: connectFrame.trace_id,
       emitted_at: Date.now(),
       payload: {},
     }),
@@ -116,51 +116,60 @@ describe("openclaw-clawchat client", () => {
     client.close();
   });
 
-  it("wraps the production default transport so connect frames cannot include signature fields", () => {
-    const client = createOpenclawClawlingClient(baseAccount());
-    const transport = (client as unknown as {
-      opts?: {
-        transport?: {
-          send: (wire: string) => void;
-          __openclawInnerTransport?: { send: (wire: string) => void };
-        };
-      };
-    }).opts?.transport;
-    const inner = transport?.__openclawInnerTransport;
-    expect(inner).toBeTruthy();
-
-    const sent: unknown[] = [];
-    inner!.send = (wire: string) => {
-      sent.push(JSON.parse(wire));
-    };
-
-    transport!.send(
+  it("reports connect frames after the transport records them", async () => {
+    const transport = new MockTransport();
+    const onConnectFrameSent = vi.fn((env: { trace_id?: unknown }) => {
+      const sentConnect = transport.sent
+        .map((raw) => JSON.parse(raw))
+        .find((frame) => frame.event === "connect");
+      expect(sentConnect?.trace_id).toBe(env.trace_id);
+    });
+    const client = createOpenclawClawlingClient(baseAccount(), {
+      transport,
+      wsLifecycle: { onConnectFrameSent },
+    });
+
+    const connected = client.connect();
+    await authenticate(transport);
+    await connected;
+
+    expect(onConnectFrameSent).toHaveBeenCalledTimes(1);
+    client.close();
+  });
+
+  it("reports connect frames only after they are sent", async () => {
+    const transport = new MockTransport();
+    const onConnectFrameSent = vi.fn();
+    const originalSend = transport.send.bind(transport);
+    transport.send = vi.fn((wire: string) => {
+      const env = JSON.parse(wire);
+      if (env.event === "connect") throw new Error("send failed");
+      originalSend(wire);
+    });
+    const client = createOpenclawClawlingClient(baseAccount(), {
+      transport,
+      wsLifecycle: { onConnectFrameSent },
+    });
+
+    const connected = client.connect();
+    await Promise.resolve();
+    transport.emitInbound(
       JSON.stringify({
         version: "2",
-        event: "connect",
-        trace_id: "trace-connect",
+        event: "connect.challenge",
+        trace_id: "challenge-1",
         emitted_at: Date.now(),
-        payload: {
-          token: "old-token",
-          nonce: "nonce-1",
-          signature: "legacy-signature",
-          client_id: "legacy-client",
-          client_version: "legacy-version",
-        },
+        payload: { nonce: "nonce-1" },
       }),
     );
 
-    expect(sent).toHaveLength(1);
-    const connectFrame = sent[0] as { payload: Record<string, unknown> };
-    expect(connectFrame.payload).toEqual({
-      token: "t",
-      nonce: "nonce-1",
-      device_id: "agent-1",
-      capabilities: {
-        multi_device: true,
-        device_replay: true,
-      },
-    });
+    await expect(connected).rejects.toThrow(/send failed/);
+    expect(onConnectFrameSent).not.toHaveBeenCalled();
+  });
+
+  it("creates a local production transport when no override is supplied", () => {
+    const client = createOpenclawClawlingClient(baseAccount());
+    expect(client.transportState).toBe("closed");
   });
 
   it("emitStreamCreated emits a minimal message.created envelope with just message_id", async () => {
@@ -189,7 +198,7 @@ describe("openclaw-clawchat client", () => {
     client.close();
   });
 
-  it("uses SDK emitRaw with chat_id routing for stream lifecycle frames", () => {
+  it("uses local emitRaw with chat_id routing for stream lifecycle frames", () => {
     const transportSend = vi.fn();
     const emitRaw = vi.fn();
     const client = {
@@ -213,7 +222,7 @@ describe("openclaw-clawchat client", () => {
     expect(transportSend).not.toHaveBeenCalled();
   });
 
-  it("falls back to SDK emitRaw with chat_id routing when raw transport is unavailable", () => {
+  it("uses local emitRaw with chat_id routing when raw transport is unavailable", () => {
     const emitRaw = vi.fn();
     const client = { emitRaw } as unknown as ClawlingChatClient;
 

package/src/client.ts

@@ -1,16 +1,12 @@
-import {
-  createWSClient,
-  type ClawlingChatClient,
-  type CreateWSClientOptions,
-  type Fragment,
-  type Transport,
-} from "@newbase-clawchat/sdk";
+import type { ChatType, Envelope, Fragment, Transport } from "./protocol-types.ts";
+import { createClawChatClient, type ClawlingChatClient } from "./ws-client.ts";
 import type { ResolvedOpenclawClawlingAccount } from "./config.ts";
 
+export type { ChatType } from "./protocol-types.ts";
+
 export interface CreateClientOverrides {
   /** Transport override — only intended for tests (e.g. MockTransport). */
   transport?: Transport;
-  logger?: CreateWSClientOptions["logger"];
   wsLifecycle?: {
     onConnectFrameSent?: (env: {
       trace_id?: unknown;
@@ -19,99 +15,22 @@ export interface CreateClientOverrides {
   };
 }
 
-export interface MsghubConnectTransport extends Transport {
-  __openclawInnerTransport: Transport;
-}
-
-function createMsghubConnectTransport(
-  account: ResolvedOpenclawClawlingAccount,
-  transport: Transport,
-  lifecycle?: CreateClientOverrides["wsLifecycle"],
-): MsghubConnectTransport {
-  const maybeWrapped = transport as Partial<MsghubConnectTransport>;
-  if (maybeWrapped.__openclawInnerTransport) return transport as MsghubConnectTransport;
-
-  const wrapped: MsghubConnectTransport = {
-    __openclawInnerTransport: transport,
-    get state() {
-      return transport.state;
-    },
-    connect(url, handlers) {
-      return transport.connect(url, handlers);
-    },
-    send(data) {
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(data);
-      } catch {
-        transport.send(data);
-        return;
-      }
-
-      if (
-        !parsed ||
-        typeof parsed !== "object" ||
-        (parsed as { event?: unknown }).event !== "connect"
-      ) {
-        transport.send(data);
-        return;
-      }
-
-      const env = parsed as {
-        payload?: { nonce?: unknown };
-        [key: string]: unknown;
-      };
-      const nonce = typeof env.payload?.nonce === "string" ? env.payload.nonce : "";
-      const payload = {
-        token: account.token,
-        nonce,
-        ...(account.userId ? { device_id: account.userId } : {}),
-        capabilities: {
-          multi_device: true,
-          device_replay: true,
-        },
-      };
-      const connectEnv = { ...env, payload };
-      transport.send(JSON.stringify(connectEnv));
-      lifecycle?.onConnectFrameSent?.(connectEnv);
-    },
-    close(code, reason) {
-      transport.close(code, reason);
-    },
-  };
-  return wrapped;
-}
-
-function installMsghubConnectTransport(
-  account: ResolvedOpenclawClawlingAccount,
-  client: ClawlingChatClient,
-  lifecycle?: CreateClientOverrides["wsLifecycle"],
-): void {
-  const inner = client as unknown as { opts?: { transport?: Transport } };
-  if (!inner.opts?.transport) return;
-  inner.opts.transport = createMsghubConnectTransport(account, inner.opts.transport, lifecycle);
-}
-
 export function createOpenclawClawlingClient(
   account: ResolvedOpenclawClawlingAccount,
   overrides: CreateClientOverrides = {},
 ): ClawlingChatClient {
-  // Only forward a finite `maxRetries` to the SDK — the SDK's own default
-  // is already unbounded, so omitting the field keeps that behavior. This
-  // avoids forcing the SDK to special-case `Infinity`.
-  const maxRetries = account.reconnect.maxRetries;
-  const reconnect: CreateWSClientOptions["reconnect"] = {
-    enabled: true,
-    initialDelay: account.reconnect.initialDelay,
-    maxDelay: account.reconnect.maxDelay,
-    jitterRatio: account.reconnect.jitterRatio,
-    ...(Number.isFinite(maxRetries) ? { maxRetries } : {}),
-  };
-
-  const options: CreateWSClientOptions = {
+  const client = createClawChatClient({
     url: account.websocketUrl,
     token: account.token,
-    reconnect,
+    deviceId: account.userId,
+    ...(overrides.transport ? { transport: overrides.transport } : {}),
+    reconnect: {
+      enabled: true,
+      initialDelay: account.reconnect.initialDelay,
+      maxDelay: account.reconnect.maxDelay,
+      jitterRatio: account.reconnect.jitterRatio,
+      maxRetries: account.reconnect.maxRetries,
+    },
     heartbeat: {
       enabled: true,
       interval: account.heartbeat.interval,
@@ -121,19 +40,21 @@ export function createOpenclawClawlingClient(
       timeout: account.ack.timeout,
       autoResendOnTimeout: account.ack.autoResendOnTimeout,
     },
-    // Buffer outbound sends during the tiny reconnect window so an inbound
-    // message isn't silently dropped while the socket is flapping.
-    queueWhileReconnecting: true,
-    ...(overrides.transport ? { transport: overrides.transport } : {}),
-    ...(overrides.logger ? { logger: overrides.logger } : {}),
-  };
-  const client = createWSClient(options);
-  installMsghubConnectTransport(account, client, overrides.wsLifecycle);
+  });
+  if (overrides.wsLifecycle?.onConnectFrameSent) {
+    const sendRawEnvelope = client.sendRawEnvelope.bind(client);
+    client.sendRawEnvelope = (env: Envelope) => {
+      sendRawEnvelope(env);
+      if (env.event === "connect") {
+        overrides.wsLifecycle?.onConnectFrameSent?.(
+          env as { trace_id?: unknown; payload?: { device_id?: unknown } },
+        );
+      }
+    };
+  }
   return client;
 }
 
-export type ChatType = "direct" | "group";
-
 export interface StreamSender {
   id: string;
   type: "direct";
@@ -157,8 +78,8 @@ function normalizeRouting(params: {
 }
 
 /**
- * Emit a raw v2 envelope directly over the transport so we can carry top-level
- * `chat_id` routing without SDK-injected `to` metadata.
+ * Emit a raw v2 envelope through the local client so stream helpers carry
+ * top-level `chat_id` routing without legacy `to` metadata.
  */
 function emitEnvelope(
   client: ClawlingChatClient,
@@ -167,33 +88,22 @@ function emitEnvelope(
   routing: EnvelopeRouting,
   options: { forceRawTransport?: boolean } = {},
 ): void {
-  const inner = client as unknown as {
-    opts?: {
-      transport: { send: (data: string) => void };
-      traceIdFactory: () => string;
-    };
-    emitRaw?: (event: string, payload: object, routing?: { chat_id?: string; chat_type?: ChatType }) => void;
-  };
-  if (!options.forceRawTransport && inner.emitRaw) {
-    inner.emitRaw(event, payload, { chat_id: routing.chatId });
+  if (!options.forceRawTransport) {
+    client.emitRaw(event, payload, { chat_id: routing.chatId });
     return;
   }
-  if (!inner.opts?.transport) {
-    if (!options.forceRawTransport && inner.emitRaw) {
-      inner.emitRaw(event, payload, { chat_id: routing.chatId });
-      return;
-    }
-    throw new Error("openclaw-clawchat streaming emit requires SDK raw transport");
+  if (typeof client.nextTraceId !== "function" || typeof client.sendRawEnvelope !== "function") {
+    throw new Error("openclaw-clawchat streaming emit requires local raw transport");
   }
-  const env = {
+  const env: Envelope = {
     version: "2" as const,
     event,
-    trace_id: inner.opts.traceIdFactory(),
+    trace_id: client.nextTraceId(),
     emitted_at: Date.now(),
     chat_id: routing.chatId,
     payload,
   };
-  inner.opts.transport.send(JSON.stringify(env));
+  client.sendRawEnvelope(env);
 }
 
 /**
@@ -308,10 +218,8 @@ export function emitStreamDone(
  * the same `payload.message_id` as the preceding `message.created` /
  * `message.add` / `message.done` frames.
  *
- * The SDK's high-level `client.replyMessage()` disallows `payload.message_id`
- * on outbound replies (the server normally assigns one via ack); for the
- * streaming-finalize use case the backend expects the correlated id, so we
- * bypass the SDK validator and write directly to the transport.
+ * Final stream replies include the correlated `payload.message_id`, so they
+ * use the local raw-envelope API instead of any higher-level ackable send.
  */
 export function emitFinalStreamReply(
   client: ClawlingChatClient,

package/src/commands.test.ts

@@ -8,7 +8,7 @@ const loginRuntime = vi.hoisted(() => ({
 vi.mock("./login.runtime.ts", () => loginRuntime);
 
 describe("registerOpenclawClawlingCommands", () => {
-  it("registers a distinct slash login command that passes the invite code to login", async () => {
+  it("registers a distinct slash activate command that passes the invite code to login", async () => {
     loginRuntime.runOpenclawClawlingLogin.mockResolvedValue(undefined);
     const commands: Array<{ name: string; acceptsArgs?: boolean; handler: (ctx: unknown) => Promise<{ text: string }> }> = [];
     const api = {
@@ -22,7 +22,7 @@ describe("registerOpenclawClawlingCommands", () => {
 
     registerOpenclawClawlingCommands(api);
 
-    expect(commands.map((command) => command.name)).toEqual(["clawchat-login"]);
+    expect(commands.map((command) => command.name)).toEqual(["clawchat-activate"]);
     expect(commands[0]?.acceptsArgs).toBe(true);
 
     const result = await commands[0]!.handler({

package/src/commands.ts

@@ -12,14 +12,14 @@ function errorMessage(err: unknown): string {
 
 export function registerOpenclawClawlingCommands(api: Pick<OpenClawPluginApi, "registerCommand" | "logger" | "runtime">): void {
   api.registerCommand({
-    name: "clawchat-login",
-    description: "Activate ClawChat with an invite code, e.g. /clawchat-login A1B2C3.",
+    name: "clawchat-activate",
+    description: "Activate ClawChat with an invite code, e.g. /clawchat-activate A1B2C3.",
     acceptsArgs: true,
     requireAuth: true,
     async handler(ctx) {
       const code = extractInviteCode(ctx.args ?? ctx.commandBody);
       if (!code) {
-        return { text: "ClawChat invite code is required. Usage: /clawchat-login A1B2C3" };
+        return { text: "ClawChat invite code is required. Usage: /clawchat-activate A1B2C3" };
       }
       try {
         const { runOpenclawClawlingLogin } = await import("./login.runtime.ts");