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

package/dist/src/protocol-types.js

@@ -8,6 +8,7 @@ export const EVENT = {
     MESSAGE_ERROR: "message.error",
     MESSAGE_REPLY: "message.reply",
     MESSAGE_REACTION: "message.reaction",
+    MESSAGE_RECALL: "message.recall",
     MESSAGE_CREATED: "message.created",
     MESSAGE_ADD: "message.add",
     MESSAGE_DONE: "message.done",
@@ -90,3 +91,20 @@ export class StateError extends Error {
 export function isBusinessDispatchEvent(event) {
     return event === EVENT.MESSAGE_SEND || event === EVENT.MESSAGE_REPLY;
 }
+/**
+ * Pull the id to delete out of a `message.recall` payload.
+ *
+ * Exists as a pure function, apart from the socket, for the same reason the
+ * mistake it guards is worth guarding: `payload.message_id` is right there and
+ * looks like the answer, but it is the `rcl:` slot. Deleting by it removes
+ * nothing and reads exactly like working code.
+ *
+ * Answers `null` for anything unusable, so a recall we cannot resolve deletes
+ * nothing rather than something adjacent.
+ */
+export function recallTargetMessageId(payload) {
+    if (!payload || typeof payload !== "object")
+        return null;
+    const target = payload.target_message_id;
+    return typeof target === "string" && target.length > 0 ? target : null;
+}

package/dist/src/runtime.js

@@ -1,4 +1,4 @@
-import { AckTimeoutError, AuthError, ProtocolError, StateError, TransportError, EVENT, } from "./protocol-types.js";
+import { AckTimeoutError, AuthError, ProtocolError, StateError, TransportError, EVENT, recallTargetMessageId, } from "./protocol-types.js";
 import { waitUntilAbort } from "openclaw/plugin-sdk/channel-lifecycle";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
@@ -2907,6 +2907,33 @@ export async function startOpenclawClawlingGateway(params) {
             await handleInboundEnvelope(env);
         })();
     });
+    // `message.recall` — the sender withdrew a message. Erase our own ledger row
+    // so the "Prior group context" block above (MENTION_CONTEXT_N rows, no time
+    // predicate, no retention) can never read it back into a turn.
+    //
+    // 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.
+    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?.({
+            platform: "openclaw",
+            accountId,
+            messageId: target,
+        });
+        const rowsLabel = typeof removed === "number" ? String(removed) : "unavailable";
+        const logFn = typeof removed === "number" ? log?.info : log?.error;
+        logFn?.(`[${accountId}] clawchat-plugin-openclaw recall purged chat_id=${String(env.chat_id ?? "")} msg=${target} rows=${rowsLabel}`);
+    });
     // Initial pull of per-group agent settings at startup (best-effort; errors are
     // logged). `bypassRefresh: true` (Finding 4) keeps this pre-connect pull from
     // rotating `account.token` out from under the already-constructed WS client.

package/dist/src/storage.js

@@ -443,6 +443,38 @@ export class ClawChatStore {
                 .run(input.eventType, input.traceId ?? null, input.chatId ?? null, input.text ?? null, toJson(input.raw), input.accountId, input.kind, input.direction, input.messageId);
         });
     }
+    /**
+     * Erase every ledger row for one `message_id` — the local half of a
+     * server-authorised recall (`message.recall`, docs/client-integration.md §9.8).
+     *
+     * **The only DELETE in this store, and deliberately so.** There is no prune
+     * and no retention on `clawchat_messages`: without this, a message recalled
+     * ninety seconds after it was sent stays one @-mention away from being read
+     * back aloud under "Prior group context" for as long as the group is quiet.
+     *
+     * Scoped to `(platform, account_id)` so one account's recall cannot reach
+     * another's rows, and matched on `message_id`, which seeks via the
+     * single-column `idx_clawchat_messages_message_id` before the `platform` /
+     * `account_id` filter is applied — so this is a lookup, not a table scan.
+     *
+     * Answers the number of rows removed. `0` is a normal outcome, not a failure:
+     * the row may never have been stored (a message that arrived before this
+     * account was paired, or one dropped by the inbound filter). `null` means the
+     * store is unavailable.
+     */
+    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.
+        if (!input.messageId)
+            return 0;
+        return this.write(() => {
+            const result = this.requireDb()
+                .prepare(`DELETE FROM clawchat_messages
+            WHERE platform = ? AND account_id = ? AND message_id = ?`)
+                .run(input.platform, input.accountId, input.messageId);
+            return Number(result.changes);
+        });
+    }
     startConnection(input) {
         return this.write(() => {
             const now = input.connectStartedAt ?? Date.now();

package/dist/src/ws-client.js

@@ -558,6 +558,11 @@ export class ClawChatClient extends EventEmitter {
             return this.onMessageError(env);
         if (isBusinessDispatchEvent(env.event))
             this.emit("message", env);
+        // Deliberately NOT a business dispatch event: `message` feeds the turn
+        // pipeline, and a recall has no body to turn into a prompt. It is an
+        // instruction to delete, so it gets its own emitter and its own consumer.
+        if (env.event === EVENT.MESSAGE_RECALL)
+            this.emit("message:recall", env);
         if (env.event === EVENT.MESSAGE_CREATED)
             this.emit("message:created", env);
         if (env.event === EVENT.MESSAGE_ADD)

package/package.json

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

package/src/protocol-types.ts

@@ -8,6 +8,7 @@ export const EVENT = {
   MESSAGE_ERROR: "message.error",
   MESSAGE_REPLY: "message.reply",
   MESSAGE_REACTION: "message.reaction",
+  MESSAGE_RECALL: "message.recall",
   MESSAGE_CREATED: "message.created",
   MESSAGE_ADD: "message.add",
   MESSAGE_DONE: "message.done",
@@ -361,3 +362,39 @@ export class StateError extends Error {
 export function isBusinessDispatchEvent(event: string): boolean {
   return event === EVENT.MESSAGE_SEND || event === EVENT.MESSAGE_REPLY;
 }
+
+/**
+ * `message.recall` downlink payload (docs/client-integration.md §9.8).
+ *
+ * **Ids only, never content.** The frame relays an instruction to delete, not
+ * a copy of what is being deleted — which is what makes it compatible with the
+ * feature's "no trace anywhere" requirement.
+ */
+export interface MessageRecallPayload {
+  /**
+   * The server's deterministic slot id, `rcl:<target_message_id>`. Present so
+   * the marker can occupy one durable inbox row per recalled message. It is
+   * NOT the id to delete.
+   */
+  message_id: string;
+
+  /** The id of the message being erased. This is the one to delete by. */
+  target_message_id: string;
+}
+
+/**
+ * Pull the id to delete out of a `message.recall` payload.
+ *
+ * Exists as a pure function, apart from the socket, for the same reason the
+ * mistake it guards is worth guarding: `payload.message_id` is right there and
+ * looks like the answer, but it is the `rcl:` slot. Deleting by it removes
+ * nothing and reads exactly like working code.
+ *
+ * Answers `null` for anything unusable, so a recall we cannot resolve deletes
+ * nothing rather than something adjacent.
+ */
+export function recallTargetMessageId(payload: unknown): string | null {
+  if (!payload || typeof payload !== "object") return null;
+  const target = (payload as { target_message_id?: unknown }).target_message_id;
+  return typeof target === "string" && target.length > 0 ? target : null;
+}

package/src/runtime.ts

@@ -5,6 +5,7 @@ import {
   StateError,
   TransportError,
   EVENT,
+  recallTargetMessageId,
   type Envelope,
   type Transport,
 } from "./protocol-types.ts";
@@ -123,6 +124,7 @@ type RuntimeConnectionStore = Pick<
       | "getActivationConversation"
       | "getLastResolvedDeviceId"
       | "listRecentGroupMessages"
+      | "deleteMessagesByMessageId"
       | "upsertOwnerProfile"
     >
   >;
@@ -3447,6 +3449,38 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     })();
   });
 
+  // `message.recall` — the sender withdrew a message. Erase our own ledger row
+  // so the "Prior group context" block above (MENTION_CONTEXT_N rows, no time
+  // predicate, no retention) can never read it back into a turn.
+  //
+  // 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.
+  client.on("message:recall", (env: Envelope) => {
+    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?.({
+      platform: "openclaw",
+      accountId,
+      messageId: target,
+    });
+    const rowsLabel = typeof removed === "number" ? String(removed) : "unavailable";
+    const logFn = typeof removed === "number" ? log?.info : log?.error;
+    logFn?.(
+      `[${accountId}] clawchat-plugin-openclaw recall purged chat_id=${String(env.chat_id ?? "")} msg=${target} rows=${rowsLabel}`,
+    );
+  });
+
   // Initial pull of per-group agent settings at startup (best-effort; errors are
   // logged). `bypassRefresh: true` (Finding 4) keeps this pre-connect pull from
   // rotating `account.token` out from under the already-constructed WS client.

package/src/storage.ts

@@ -802,6 +802,44 @@ export class ClawChatStore {
     });
   }
 
+  /**
+   * Erase every ledger row for one `message_id` — the local half of a
+   * server-authorised recall (`message.recall`, docs/client-integration.md §9.8).
+   *
+   * **The only DELETE in this store, and deliberately so.** There is no prune
+   * and no retention on `clawchat_messages`: without this, a message recalled
+   * ninety seconds after it was sent stays one @-mention away from being read
+   * back aloud under "Prior group context" for as long as the group is quiet.
+   *
+   * Scoped to `(platform, account_id)` so one account's recall cannot reach
+   * another's rows, and matched on `message_id`, which seeks via the
+   * single-column `idx_clawchat_messages_message_id` before the `platform` /
+   * `account_id` filter is applied — so this is a lookup, not a table scan.
+   *
+   * Answers the number of rows removed. `0` is a normal outcome, not a failure:
+   * the row may never have been stored (a message that arrived before this
+   * account was paired, or one dropped by the inbound filter). `null` means the
+   * store is unavailable.
+   */
+  deleteMessagesByMessageId(input: {
+    platform: string;
+    accountId: string;
+    messageId: string;
+  }): number | null {
+    // An empty id would match every row whose message_id is '' — deleting
+    // everything the store never managed to key. Refuse rather than guess.
+    if (!input.messageId) return 0;
+    return this.write(() => {
+      const result = this.requireDb()
+        .prepare(
+          `DELETE FROM clawchat_messages
+            WHERE platform = ? AND account_id = ? AND message_id = ?`,
+        )
+        .run(input.platform, input.accountId, input.messageId);
+      return Number(result.changes);
+    });
+  }
+
   startConnection(input: StartConnectionInput): number | null {
     return this.write(() => {
       const now = input.connectStartedAt ?? Date.now();

package/src/ws-client.ts

@@ -651,6 +651,10 @@ export class ClawChatClient extends EventEmitter {
     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>);
     if (isBusinessDispatchEvent(env.event)) this.emit("message", env);
+    // Deliberately NOT a business dispatch event: `message` feeds the turn
+    // pipeline, and a recall has no body to turn into a prompt. It is an
+    // instruction to delete, so it gets its own emitter and its own consumer.
+    if (env.event === EVENT.MESSAGE_RECALL) this.emit("message:recall", env);
     if (env.event === EVENT.MESSAGE_CREATED) this.emit("message:created", env);
     if (env.event === EVENT.MESSAGE_ADD) this.emit("message:add", env);
     if (env.event === EVENT.MESSAGE_DONE) this.emit("message:done", env);