@clawling/clawchat-plugin-openclaw 2026.8.22-1 → 2026.8.26-1

package/dist/src/runtime.js

@@ -1534,7 +1534,6 @@ export async function startOpenclawClawlingGateway(params) {
     const protocolControlLogger = createProtocolControlHandler({
         accountId,
         log: (msg) => log?.info?.(msg),
-        send: () => { },
         context: wsLogContext,
     });
     const notifySignalObserver = createNotifySignalObserver({
@@ -2914,18 +2913,23 @@ export async function startOpenclawClawlingGateway(params) {
     // Ids only: the frame carries no content, and `payload.message_id` is the
     // server's `rcl:<target>` slot — the id to delete is `target_message_id`.
     //
-    // Synchronous and fire-and-forget on purpose. There is no ack to send (the
-    // frame is BestEffort and non-ackable), and no tombstone to write: a Kafka
-    // redelivery of the original can resurrect the row, which is an accepted
-    // known limitation rather than a fourth reimplementation of the mobile
-    // client's tombstone table.
+    // Synchronous and fire-and-forget on purpose: there is no ack to send (the
+    // frame is BestEffort and non-ackable).
+    //
+    // §9.8 requires a permanent tombstone consulted on every ingest path, and
+    // `store.recallMessage` writes one in the same transaction as the delete.
+    // That is what makes this handler's timing irrelevant: the inbound ledger
+    // write sits behind an await, so on a replay carrying the original and its
+    // recall back-to-back the DELETE runs first — and the tombstone then refuses
+    // the INSERT. It also closes the Kafka-redelivery resurrection this comment
+    // previously accepted as a known limitation.
     client.on("message:recall", (env) => {
         const target = recallTargetMessageId(env.payload);
         if (!target) {
             log?.info?.(`[${accountId}] clawchat-plugin-openclaw recall ignored (no target_message_id) chat_id=${String(env.chat_id ?? "")}`);
             return;
         }
-        const removed = store?.deleteMessagesByMessageId?.({
+        const removed = store?.recallMessage?.({
             platform: "openclaw",
             accountId,
             messageId: target,

package/dist/src/storage.js

@@ -171,6 +171,19 @@ CREATE TABLE IF NOT EXISTS owner_profile (
   updated_at INTEGER NOT NULL,
   PRIMARY KEY (platform, account_id)
 );
+`,
+    },
+    {
+        version: 10,
+        name: "recalled_messages",
+        sql: `
+CREATE TABLE IF NOT EXISTS recalled_messages (
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  recalled_at INTEGER NOT NULL,
+  PRIMARY KEY (platform, account_id, message_id)
+);
 `,
     },
 ];
@@ -412,6 +425,14 @@ export class ClawChatStore {
     }
     claimMessageOnce(input) {
         return this.write(() => {
+            // Protocol v2 §9.8: consult the recall tombstone on every ingest path.
+            // Doing it inside this same write transaction is what makes the delete
+            // and the insert order-independent: whichever frame the server delivers
+            // first, a recalled message_id can never end up in the ledger. Without
+            // it, a replay carrying the original and its recall back-to-back ran the
+            // DELETE before the INSERT and the row survived.
+            if (input.messageId && this.isMessageRecalled(input))
+                return false;
             const result = this.requireDb()
                 .prepare(`INSERT OR IGNORE INTO clawchat_messages(
             platform, account_id, kind, direction, event_type, trace_id, chat_id,
@@ -462,6 +483,43 @@ export class ClawChatStore {
      * account was paired, or one dropped by the inbound filter). `null` means the
      * store is unavailable.
      */
+    /** True when `message_id` was recalled for this (platform, account). */
+    isMessageRecalled(input) {
+        if (!input.messageId)
+            return false;
+        const row = this.requireDb()
+            .prepare(`SELECT 1 FROM recalled_messages
+          WHERE platform = ? AND account_id = ? AND message_id = ?`)
+            .get(input.platform, input.accountId, input.messageId);
+        return row !== undefined;
+    }
+    /**
+     * Record the permanent recall tombstone and purge any row already stored,
+     * atomically. Returns the number of ledger rows deleted (0 when the recall
+     * arrived before the message did — the tombstone still stands and the later
+     * ingest is refused by {@link claimMessageOnce}).
+     */
+    recallMessage(input) {
+        // An empty id would tombstone and delete rows keyed by '' — every row the
+        // store never managed to key. Refuse rather than guess.
+        if (!input.messageId)
+            return 0;
+        return this.write(() => {
+            const db = this.requireDb();
+            db.prepare(`INSERT OR IGNORE INTO recalled_messages(platform, account_id, message_id, recalled_at)
+          VALUES (?, ?, ?, ?)`).run(input.platform, input.accountId, input.messageId, input.recalledAt ?? Date.now());
+            const result = db
+                .prepare(`DELETE FROM clawchat_messages
+            WHERE platform = ? AND account_id = ? AND message_id = ?`)
+                .run(input.platform, input.accountId, input.messageId);
+            return Number(result.changes);
+        });
+    }
+    /**
+     * Low-level purge by message id. NOT the recall path: it writes no tombstone,
+     * so a recall routed through here loses to a redelivery or to an ingest that
+     * is still behind an await. Use {@link recallMessage} for `message.recall`.
+     */
     deleteMessagesByMessageId(input) {
         // An empty id would match every row whose message_id is '' — deleting
         // everything the store never managed to key. Refuse rather than guess.

package/dist/src/ws-alignment.js

@@ -171,15 +171,12 @@ export function createProtocolControlHandler(options) {
     return {
         handleInbound(env) {
             if (env.event === "ping") {
-                logControl("protocol_ping_received", "send_pong", [["trace_id", env.trace_id]]);
-                options.send(JSON.stringify({
-                    version: "2",
-                    event: "pong",
-                    trace_id: env.trace_id ?? "-",
-                    // §12: echo the sender's emitted_at verbatim (do not restamp).
-                    emitted_at: env.emitted_at ?? Date.now(),
-                    payload: {},
-                }));
+                // §12: the server never emits a JSON-level `ping`, so this is an
+                // anomaly worth seeing — but answering it would send exactly the
+                // unsolicited `pong` the spec bans, which the server drops as an
+                // unknown uplink event. Log it and drop it; this handler has no send
+                // capability, so the banned frame cannot be produced here at all.
+                logControl("protocol_ping_received", "drop", [["trace_id", env.trace_id]]);
                 return true;
             }
             if (env.event === "pong") {

package/dist/src/ws-client.js

@@ -548,8 +548,10 @@ export class ClawChatClient extends EventEmitter {
             return this.onHelloOk(env);
         if (env.event === EVENT.HELLO_FAIL)
             return this.onHelloFail(env);
-        if (env.event === EVENT.PING)
-            return this.onPing(env);
+        // §12: the server never emits a JSON-level `ping`, and an unsolicited
+        // `pong` is an unknown uplink event the server drops. We therefore do NOT
+        // answer a downlink ping. `pong` below is still handled: it is the reply
+        // to the client-initiated heartbeat probe §12 does allow.
         if (env.event === EVENT.PONG)
             return this.onPong();
         if (env.event === EVENT.MESSAGE_ACK)
@@ -704,15 +706,6 @@ export class ClawChatClient extends EventEmitter {
             this.opts.transport.close(4001, "auth failed");
         }
     }
-    onPing(env) {
-        this.sendRawEnvelope({
-            version: "2",
-            event: EVENT.PONG,
-            trace_id: env.trace_id,
-            emitted_at: env.emitted_at,
-            payload: {},
-        });
-    }
     onPong() {
         if (this.pongTimer)
             clearTimeout(this.pongTimer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.8.22-1",
+  "version": "2026.8.26-1",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",

package/src/runtime.ts

@@ -124,7 +124,7 @@ type RuntimeConnectionStore = Pick<
       | "getActivationConversation"
       | "getLastResolvedDeviceId"
       | "listRecentGroupMessages"
-      | "deleteMessagesByMessageId"
+      | "recallMessage"
       | "upsertOwnerProfile"
     >
   >;
@@ -1922,7 +1922,6 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   const protocolControlLogger = createProtocolControlHandler({
     accountId,
     log: (msg) => log?.info?.(msg),
-    send: () => {},
     context: wsLogContext,
   });
   const notifySignalObserver = createNotifySignalObserver({
@@ -3456,11 +3455,16 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
   // Ids only: the frame carries no content, and `payload.message_id` is the
   // server's `rcl:<target>` slot — the id to delete is `target_message_id`.
   //
-  // Synchronous and fire-and-forget on purpose. There is no ack to send (the
-  // frame is BestEffort and non-ackable), and no tombstone to write: a Kafka
-  // redelivery of the original can resurrect the row, which is an accepted
-  // known limitation rather than a fourth reimplementation of the mobile
-  // client's tombstone table.
+  // Synchronous and fire-and-forget on purpose: there is no ack to send (the
+  // frame is BestEffort and non-ackable).
+  //
+  // §9.8 requires a permanent tombstone consulted on every ingest path, and
+  // `store.recallMessage` writes one in the same transaction as the delete.
+  // That is what makes this handler's timing irrelevant: the inbound ledger
+  // write sits behind an await, so on a replay carrying the original and its
+  // recall back-to-back the DELETE runs first — and the tombstone then refuses
+  // the INSERT. It also closes the Kafka-redelivery resurrection this comment
+  // previously accepted as a known limitation.
   client.on("message:recall", (env: Envelope) => {
     const target = recallTargetMessageId(env.payload);
     if (!target) {
@@ -3469,7 +3473,7 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       );
       return;
     }
-    const removed = store?.deleteMessagesByMessageId?.({
+    const removed = store?.recallMessage?.({
       platform: "openclaw",
       accountId,
       messageId: target,

package/src/storage.ts

@@ -389,6 +389,19 @@ CREATE TABLE IF NOT EXISTS owner_profile (
   updated_at INTEGER NOT NULL,
   PRIMARY KEY (platform, account_id)
 );
+`,
+  },
+  {
+    version: 10,
+    name: "recalled_messages",
+    sql: `
+CREATE TABLE IF NOT EXISTS recalled_messages (
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  recalled_at INTEGER NOT NULL,
+  PRIMARY KEY (platform, account_id, message_id)
+);
 `,
   },
 ];
@@ -722,6 +735,13 @@ export class ClawChatStore {
 
   claimMessageOnce(input: MessageInput): true | false | null {
     return this.write(() => {
+      // Protocol v2 §9.8: consult the recall tombstone on every ingest path.
+      // Doing it inside this same write transaction is what makes the delete
+      // and the insert order-independent: whichever frame the server delivers
+      // first, a recalled message_id can never end up in the ledger. Without
+      // it, a replay carrying the original and its recall back-to-back ran the
+      // DELETE before the INSERT and the row survived.
+      if (input.messageId && this.isMessageRecalled(input)) return false;
       const result = this.requireDb()
         .prepare(
           `INSERT OR IGNORE INTO clawchat_messages(
@@ -821,6 +841,54 @@ export class ClawChatStore {
    * account was paired, or one dropped by the inbound filter). `null` means the
    * store is unavailable.
    */
+  /** True when `message_id` was recalled for this (platform, account). */
+  isMessageRecalled(input: { platform: string; accountId: string; messageId?: string | null }): boolean {
+    if (!input.messageId) return false;
+    const row = this.requireDb()
+      .prepare(
+        `SELECT 1 FROM recalled_messages
+          WHERE platform = ? AND account_id = ? AND message_id = ?`,
+      )
+      .get(input.platform, input.accountId, input.messageId);
+    return row !== undefined;
+  }
+
+  /**
+   * Record the permanent recall tombstone and purge any row already stored,
+   * atomically. Returns the number of ledger rows deleted (0 when the recall
+   * arrived before the message did — the tombstone still stands and the later
+   * ingest is refused by {@link claimMessageOnce}).
+   */
+  recallMessage(input: {
+    platform: string;
+    accountId: string;
+    messageId: string;
+    recalledAt?: number;
+  }): number | null {
+    // An empty id would tombstone and delete rows keyed by '' — every row the
+    // store never managed to key. Refuse rather than guess.
+    if (!input.messageId) return 0;
+    return this.write(() => {
+      const db = this.requireDb();
+      db.prepare(
+        `INSERT OR IGNORE INTO recalled_messages(platform, account_id, message_id, recalled_at)
+          VALUES (?, ?, ?, ?)`,
+      ).run(input.platform, input.accountId, input.messageId, input.recalledAt ?? Date.now());
+      const result = db
+        .prepare(
+          `DELETE FROM clawchat_messages
+            WHERE platform = ? AND account_id = ? AND message_id = ?`,
+        )
+        .run(input.platform, input.accountId, input.messageId);
+      return Number(result.changes);
+    });
+  }
+
+  /**
+   * Low-level purge by message id. NOT the recall path: it writes no tombstone,
+   * so a recall routed through here loses to a redelivery or to an ingest that
+   * is still behind an await. Use {@link recallMessage} for `message.recall`.
+   */
   deleteMessagesByMessageId(input: {
     platform: string;
     accountId: string;

package/src/ws-alignment.ts

@@ -238,7 +238,6 @@ export interface ProtocolControlEnvelope {
 export interface CreateProtocolControlHandlerOptions {
   accountId: string;
   log: (msg: string) => void;
-  send: (wire: string) => void;
   scheduleReconnect?: (reason: string) => void;
   attempt?: number;
   reconnectCount?: number;
@@ -275,17 +274,12 @@ export function createProtocolControlHandler(options: CreateProtocolControlHandl
   return {
     handleInbound(env: ProtocolControlEnvelope): boolean {
       if (env.event === "ping") {
-        logControl("protocol_ping_received", "send_pong", [["trace_id", env.trace_id]]);
-        options.send(
-          JSON.stringify({
-            version: "2",
-            event: "pong",
-            trace_id: env.trace_id ?? "-",
-            // §12: echo the sender's emitted_at verbatim (do not restamp).
-            emitted_at: env.emitted_at ?? Date.now(),
-            payload: {},
-          }),
-        );
+        // §12: the server never emits a JSON-level `ping`, so this is an
+        // anomaly worth seeing — but answering it would send exactly the
+        // unsolicited `pong` the spec bans, which the server drops as an
+        // unknown uplink event. Log it and drop it; this handler has no send
+        // capability, so the banned frame cannot be produced here at all.
+        logControl("protocol_ping_received", "drop", [["trace_id", env.trace_id]]);
         return true;
       }
       if (env.event === "pong") {

package/src/ws-client.ts

@@ -646,7 +646,10 @@ export class ClawChatClient extends EventEmitter {
     if (env.event === EVENT.CONNECT_CHALLENGE) return this.onChallenge(env);
     if (env.event === EVENT.HELLO_OK) return this.onHelloOk(env);
     if (env.event === EVENT.HELLO_FAIL) return this.onHelloFail(env);
-    if (env.event === EVENT.PING) return this.onPing(env);
+    // §12: the server never emits a JSON-level `ping`, and an unsolicited
+    // `pong` is an unknown uplink event the server drops. We therefore do NOT
+    // answer a downlink ping. `pong` below is still handled: it is the reply
+    // to the client-initiated heartbeat probe §12 does allow.
     if (env.event === EVENT.PONG) return this.onPong();
     if (env.event === EVENT.MESSAGE_ACK) return this.onAck(env as Envelope<MessageAckPayload>);
     if (env.event === EVENT.MESSAGE_ERROR) return this.onMessageError(env as Envelope<MessageErrorPayload>);
@@ -785,16 +788,6 @@ export class ClawChatClient extends EventEmitter {
     }
   }
 
-  private onPing(env: Envelope): void {
-    this.sendRawEnvelope({
-      version: "2",
-      event: EVENT.PONG,
-      trace_id: env.trace_id,
-      emitted_at: env.emitted_at,
-      payload: {} satisfies EmptyPayload,
-    });
-  }
-
   private onPong(): void {
     if (this.pongTimer) clearTimeout(this.pongTimer);
     this.pongTimer = undefined;