@clawling/clawchat-plugin-openclaw 2026.9.13-3 → 2026.9.14-2

package/dist/src/client.js

@@ -3,6 +3,7 @@ import os from "node:os";
 import { createClawChatClient } from "./ws-client.js";
 import { CHANNEL_ID } from "./config.js";
 import { resolveStateDirFromEnv } from "./state-paths.js";
+import { resolvePluginVersion } from "./plugin-report.js";
 /**
  * Derive this instance's `device_id` from stable, per-instance material.
  *
@@ -35,6 +36,7 @@ export function createOpenclawClawlingClient(account, overrides = {}) {
         url: account.websocketUrl,
         token: account.token,
         deviceId,
+        clientVersion: resolvePluginVersion(),
         ...(overrides.transport ? { transport: overrides.transport } : {}),
         reconnect: {
             enabled: true,

package/dist/src/runtime.js

@@ -2373,7 +2373,22 @@ export async function startOpenclawClawlingGateway(params) {
                 log?.info?.(`[${accountId}] clawchat-plugin-openclaw skip duplicate stored msg=${turn.messageId}`);
                 return "skipped";
             }
+            if (claimed !== true) {
+                // Fail closed: a claim that could not be decided (store disabled, SQLite
+                // error, a throw converted to undefined by recordConnection) must not
+                // dispatch. Live delivery and device replay can carry the same message,
+                // and the outbound reply path (outbound.ts / reply-dispatcher.ts) already
+                // refuses to send without a claim — so dispatching here only re-ran the
+                // LLM/tools without delivering, or double-replied. Logged at error level
+                // with reason=claim_unavailable so a store outage is visible and is not
+                // mistaken for dedup. Accepted cost: a one-off transient claim failure
+                // drops that message.
+                log?.error?.(`[${accountId}] clawchat-plugin-openclaw inbound skipped msg=${turn.messageId} chat_id=${turn.peer.id} event=${String(env.event)} reason=claim_unavailable result=${String(claimed)}`);
+                return "skipped";
+            }
         }
+        // No store wired at all (injected test transport, or store construction
+        // threw at startup — which is itself logged) keeps the store-less pass-through.
         return "claimed";
     };
     const dispatchTurnToAgent = async (turn) => {
@@ -2730,7 +2745,10 @@ export async function startOpenclawClawlingGateway(params) {
             // replayed — permanently lost. Claiming first makes it durable; the abort
             // check below then returns without dispatching, but the frame is kept.
             // `claimInboundTurn` is INSERT OR IGNORE, so a genuine duplicate (same
-            // message_id) is still deduped here exactly once.
+            // message_id) is still deduped here exactly once. The claim fails CLOSED:
+            // only a successful claim proceeds; an undecided claim (store unavailable)
+            // skips with reason=claim_unavailable, because outbound replies also refuse
+            // to send without a claim, so dispatching would only waste the turn.
             const claimed = claimInboundTurn(turn);
             if (claimed === "skipped")
                 return "skipped";

package/dist/src/ws-client.js

@@ -664,6 +664,7 @@ export class ClawChatClient extends EventEmitter {
             token: this.opts.token,
             nonce,
             ...(this.opts.deviceId ? { device_id: this.opts.deviceId } : {}),
+            ...(this.opts.clientVersion ? { client_version: this.opts.clientVersion } : {}),
             // Agent runtime is single-device: multi_device stays off so the server
             // never self-fans-out this connection's own messages. notify_signals is
             // advertised because we now handle the notify.signal frame (§9.4).

package/package.json

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

package/src/client.ts

@@ -4,6 +4,7 @@ import type { Envelope, Transport } from "./protocol-types.ts";
 import { createClawChatClient, type ClawlingChatClient } from "./ws-client.ts";
 import { CHANNEL_ID, type ResolvedOpenclawClawlingAccount } from "./config.ts";
 import { resolveStateDirFromEnv } from "./state-paths.ts";
+import { resolvePluginVersion } from "./plugin-report.ts";
 
 export type { ChatType } from "./protocol-types.ts";
 
@@ -69,6 +70,7 @@ export function createOpenclawClawlingClient(
     url: account.websocketUrl,
     token: account.token,
     deviceId,
+    clientVersion: resolvePluginVersion(),
     ...(overrides.transport ? { transport: overrides.transport } : {}),
     reconnect: {
       enabled: true,

package/src/protocol-types.ts

@@ -102,6 +102,8 @@ export interface ConnectPayload {
   token: string;
   nonce: string;
   device_id?: string;
+  /** Telemetry only (msghub logs it on "handshake accepted"). */
+  client_version?: string;
   capabilities?: ConnectCapabilities;
 }
 

package/src/runtime.ts

@@ -2859,7 +2859,24 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
         );
         return "skipped";
       }
+      if (claimed !== true) {
+        // Fail closed: a claim that could not be decided (store disabled, SQLite
+        // error, a throw converted to undefined by recordConnection) must not
+        // dispatch. Live delivery and device replay can carry the same message,
+        // and the outbound reply path (outbound.ts / reply-dispatcher.ts) already
+        // refuses to send without a claim — so dispatching here only re-ran the
+        // LLM/tools without delivering, or double-replied. Logged at error level
+        // with reason=claim_unavailable so a store outage is visible and is not
+        // mistaken for dedup. Accepted cost: a one-off transient claim failure
+        // drops that message.
+        log?.error?.(
+          `[${accountId}] clawchat-plugin-openclaw inbound skipped msg=${turn.messageId} chat_id=${turn.peer.id} event=${String(env.event)} reason=claim_unavailable result=${String(claimed)}`,
+        );
+        return "skipped";
+      }
     }
+    // No store wired at all (injected test transport, or store construction
+    // threw at startup — which is itself logged) keeps the store-less pass-through.
     return "claimed";
   };
 
@@ -3265,7 +3282,10 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       // replayed — permanently lost. Claiming first makes it durable; the abort
       // check below then returns without dispatching, but the frame is kept.
       // `claimInboundTurn` is INSERT OR IGNORE, so a genuine duplicate (same
-      // message_id) is still deduped here exactly once.
+      // message_id) is still deduped here exactly once. The claim fails CLOSED:
+      // only a successful claim proceeds; an undecided claim (store unavailable)
+      // skips with reason=claim_unavailable, because outbound replies also refuse
+      // to send without a claim, so dispatching would only waste the turn.
       const claimed = claimInboundTurn(turn);
       if (claimed === "skipped") return "skipped";
       // Findings 2 & 3 — hold ALL group traffic until the in-flight settings pull

package/src/ws-client.ts

@@ -118,6 +118,8 @@ export interface ClawChatClientOptions {
   url: string;
   token: string;
   deviceId?: string;
+  /** Sent as connect `client_version` (telemetry only); omitted when empty. */
+  clientVersion?: string;
   transport?: Transport;
   traceIdFactory?: () => string;
   reconnect?: {
@@ -137,6 +139,7 @@ export interface NormalizedClawChatClientOptions {
   url: string;
   token: string;
   deviceId?: string;
+  clientVersion?: string;
   transport: Transport;
   traceIdFactory: () => string;
   reconnect: Required<NonNullable<ClawChatClientOptions["reconnect"]>>;
@@ -750,6 +753,7 @@ export class ClawChatClient extends EventEmitter {
       token: this.opts.token,
       nonce,
       ...(this.opts.deviceId ? { device_id: this.opts.deviceId } : {}),
+      ...(this.opts.clientVersion ? { client_version: this.opts.clientVersion } : {}),
       // Agent runtime is single-device: multi_device stays off so the server
       // never self-fans-out this connection's own messages. notify_signals is
       // advertised because we now handle the notify.signal frame (§9.4).