@agentrux/agentrux-openclaw-plugin 0.3.4 → 0.3.6

package/README.md

@@ -2,7 +2,7 @@
 
 Connect your OpenClaw agent to other agents via AgenTrux — authenticated Pub/Sub for autonomous agents.
 
-**v0.3.3**: Ingress mode with image attachments, auto topic resolution for uploads, SSE/webhook dual support.
+**v0.3.4**: Ingress mode with image attachments, auto topic resolution for uploads, SSE/webhook dual support.
 
 ## Install
 
@@ -10,7 +10,7 @@ Connect your OpenClaw agent to other agents via AgenTrux — authenticated Pub/S
 > config 未設定だと OpenClaw CLI がロードエラーで停止します。
 
 ```bash
-openclaw plugins install @agentrux/agentrux-openclaw-plugin@0.3.3
+openclaw plugins install @agentrux/agentrux-openclaw-plugin@0.3.4
 ```
 
 ## Quick Start

package/dist/__tests__/dispatcher.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Dispatcher transient error handling tests.
+ *
+ * Verifies:
+ * 1. Transport retry: callDispatchEndpoint retries on transient errors
+ * 2. Transient drop: transport failure after retries does NOT write to outbox
+ * 3. Application failure: non-transport errors still write to outbox (existing behavior)
+ * 4. isTransientError classification
+ */
+export {};

package/dist/__tests__/dispatcher.test.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Dispatcher transient error handling tests.
+ *
+ * Verifies:
+ * 1. Transport retry: callDispatchEndpoint retries on transient errors
+ * 2. Transient drop: transport failure after retries does NOT write to outbox
+ * 3. Application failure: non-transport errors still write to outbox (existing behavior)
+ * 4. isTransientError classification
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = __importStar(require("http"));
+// --- isTransientError (extracted for testing) ---
+function isTransientError(e) {
+    const code = e?.code;
+    if (code && ["ECONNREFUSED", "ETIMEDOUT", "ECONNRESET", "EHOSTUNREACH"].includes(code)) {
+        return true;
+    }
+    const msg = e?.message || "";
+    return msg.includes("socket hang up") || msg.includes("Dispatch timeout");
+}
+describe("isTransientError", () => {
+    test("ECONNREFUSED → transient", () => {
+        const e = new Error("connect ECONNREFUSED 127.0.0.1:18789");
+        e.code = "ECONNREFUSED";
+        expect(isTransientError(e)).toBe(true);
+    });
+    test("ETIMEDOUT → transient", () => {
+        const e = new Error("connect ETIMEDOUT");
+        e.code = "ETIMEDOUT";
+        expect(isTransientError(e)).toBe(true);
+    });
+    test("ECONNRESET → transient", () => {
+        const e = new Error("read ECONNRESET");
+        e.code = "ECONNRESET";
+        expect(isTransientError(e)).toBe(true);
+    });
+    test("EHOSTUNREACH → transient", () => {
+        const e = new Error("connect EHOSTUNREACH");
+        e.code = "EHOSTUNREACH";
+        expect(isTransientError(e)).toBe(true);
+    });
+    test("socket hang up → transient", () => {
+        expect(isTransientError(new Error("socket hang up"))).toBe(true);
+    });
+    test("Dispatch timeout → transient", () => {
+        expect(isTransientError(new Error("Dispatch timeout"))).toBe(true);
+    });
+    test("JSON parse error → NOT transient", () => {
+        expect(isTransientError(new Error("Dispatch response parse error: <html>"))).toBe(false);
+    });
+    test("generic Error → NOT transient", () => {
+        expect(isTransientError(new Error("something unexpected"))).toBe(false);
+    });
+    test("null/undefined → NOT transient", () => {
+        expect(isTransientError(null)).toBe(false);
+        expect(isTransientError(undefined)).toBe(false);
+    });
+});
+// --- Transport retry integration test ---
+describe("callDispatchEndpoint transport retry", () => {
+    test("retries on ECONNREFUSED then succeeds", async () => {
+        let requestCount = 0;
+        const PORT = 19876;
+        let server;
+        // _doDispatchRequest equivalent
+        function doRequest() {
+            return new Promise((resolve, reject) => {
+                const body = JSON.stringify({ sessionKey: "test", message: "hi", idempotencyKey: "k1", timeoutMs: 5000 });
+                const req = http.request({ hostname: "127.0.0.1", port: PORT, path: "/agentrux/dispatch", method: "POST",
+                    headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) }, timeout: 5000 }, (res) => {
+                    let raw = "";
+                    res.on("data", (c) => (raw += c.toString()));
+                    res.on("end", () => { try {
+                        resolve(JSON.parse(raw));
+                    }
+                    catch {
+                        reject(new Error("parse error"));
+                    } });
+                });
+                req.on("error", reject);
+                req.on("timeout", () => { req.destroy(); reject(new Error("Dispatch timeout")); });
+                req.write(body);
+                req.end();
+            });
+        }
+        // Retry wrapper (mirrors callDispatchEndpoint)
+        async function callWithRetry() {
+            const MAX = 3;
+            const BASE = 200; // shorter for test
+            for (let attempt = 0; attempt < MAX; attempt++) {
+                try {
+                    return await doRequest();
+                }
+                catch (e) {
+                    if (isTransientError(e) && attempt < MAX - 1) {
+                        await new Promise((r) => setTimeout(r, BASE * Math.pow(2, attempt)));
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+            throw new Error("max retries");
+        }
+        // Start server after 300ms (1st attempt fails, 2nd succeeds)
+        setTimeout(() => {
+            server = http.createServer((req, res) => {
+                requestCount++;
+                let body = "";
+                req.on("data", (c) => (body += c));
+                req.on("end", () => {
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ responseText: "ok", status: "ok" }));
+                });
+            });
+            server.listen(PORT);
+        }, 300);
+        const result = await callWithRetry();
+        expect(result.status).toBe("ok");
+        expect(requestCount).toBe(1);
+        await new Promise((resolve) => server.close(() => resolve()));
+    }, 15000);
+    test("all retries fail → throws transient error", async () => {
+        // Simulate 3 ECONNREFUSED failures without real sockets
+        let attempts = 0;
+        async function fakeRequest() {
+            attempts++;
+            const e = new Error("connect ECONNREFUSED 127.0.0.1:19877");
+            e.code = "ECONNREFUSED";
+            throw e;
+        }
+        async function callWithRetry() {
+            const MAX = 3;
+            const BASE = 50; // short for test
+            for (let attempt = 0; attempt < MAX; attempt++) {
+                try {
+                    return await fakeRequest();
+                }
+                catch (e) {
+                    if (isTransientError(e) && attempt < MAX - 1) {
+                        await new Promise((r) => setTimeout(r, BASE));
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+        }
+        let threw = false;
+        try {
+            await callWithRetry();
+        }
+        catch (e) {
+            threw = true;
+            expect(isTransientError(e)).toBe(true);
+        }
+        expect(threw).toBe(true);
+        expect(attempts).toBe(3); // all 3 attempts made
+    }, 10000);
+});
+// --- Transient vs Application error routing ---
+describe("processEvent error routing", () => {
+    test("transient error should NOT produce outbox entry", () => {
+        // Simulate the decision logic from processEvent catch block
+        const e = new Error("connect ECONNREFUSED 127.0.0.1:18789");
+        e.code = "ECONNREFUSED";
+        let outboxWritten = false;
+        let eventRecorded = false;
+        let completed = false;
+        if (isTransientError(e)) {
+            // Transport failure path: drop event
+            completed = true;
+            // outboxWritten stays false
+            // eventRecorded stays false
+        }
+        else {
+            outboxWritten = true;
+            eventRecorded = true;
+        }
+        expect(outboxWritten).toBe(false);
+        expect(eventRecorded).toBe(false);
+        expect(completed).toBe(true);
+    });
+    test("application error SHOULD produce outbox entry", () => {
+        const e = new Error("Subagent execution failed");
+        let outboxWritten = false;
+        let eventRecorded = false;
+        let completed = false;
+        if (isTransientError(e)) {
+            completed = true;
+        }
+        else {
+            outboxWritten = true;
+            eventRecorded = true;
+        }
+        expect(outboxWritten).toBe(true);
+        expect(eventRecorded).toBe(true);
+        expect(completed).toBe(false);
+    });
+});

package/dist/dispatcher.d.ts

@@ -12,6 +12,8 @@ export interface DispatcherConfig {
     maxConcurrency: number;
     subagentTimeoutMs: number;
     gatewayPort: number;
+    /** Publish "processing" status to result topic before dispatch. Debug/dev only. */
+    publishProcessingStatus?: boolean;
 }
 export declare class Dispatcher {
     private config;
@@ -23,7 +25,6 @@ export declare class Dispatcher {
     private stopped;
     private processedRequestIds;
     private processingSeqs;
-    private statusPublished;
     constructor(config: DispatcherConfig, creds: Credentials, cursor: CursorState, queue: BoundedQueue, logger: {
         info: (...a: any[]) => void;
         error: (...a: any[]) => void;
@@ -35,4 +36,5 @@ export declare class Dispatcher {
     private tick;
     private processEvent;
     private callDispatchEndpoint;
+    private _doDispatchRequest;
 }

package/dist/dispatcher.js

@@ -57,36 +57,24 @@ class Dispatcher {
         // In-memory dedup: prevents same seq/request from being processed twice
         this.processedRequestIds = new Set();
         this.processingSeqs = new Set();
-        // Status publish tracking: only publish "processing" once per request
-        this.statusPublished = new Set();
     }
     async start() {
         if (this.running)
             throw new Error("Dispatcher already running");
         this.running = true;
         this.stopped = false;
-        // Crash recovery: re-enqueue inFlight seqs from previous run
-        // NOTE: do NOT clear inFlight here — they stay in-flight until processEvent
-        // completes and the outbox flush finalizes them via markCompleted.
+        // Crash recovery: clear ALL inFlight seqs by marking them completed.
+        // Rationale: Dispatcher is a part, not an orchestrator. If a crash interrupted
+        // processing, we drop those events rather than risk an infinite restart cycle.
+        // The alternative (re-enqueueing) can loop forever if processEvent's dedup
+        // (processedEvents/findByRequestId) blocks the re-enqueued event before
+        // markCompleted is reached, leaving inFlight permanently dirty.
         if (this.cursor.inFlight.size > 0) {
-            this.logger.info(`Crash recovery: re-enqueueing ${this.cursor.inFlight.size} in-flight seqs`);
-            const recovered = [];
-            for (const seq of this.cursor.inFlight) {
-                const ok = this.queue.enqueue({
-                    topicId: this.config.commandTopicId,
-                    latestSequenceNo: seq,
-                    timestamp: Date.now(),
-                });
-                if (ok)
-                    recovered.push(seq);
-            }
-            // Only remove from inFlight the ones we failed to enqueue (queue full)
-            // The successfully enqueued ones will be cleared by processEvent → markCompleted
-            for (const seq of this.cursor.inFlight) {
-                if (!recovered.includes(seq)) {
-                    this.logger.warn(`Crash recovery: could not re-enqueue seq=${seq} (queue full)`);
-                }
+            this.logger.warn(`Crash recovery: clearing ${this.cursor.inFlight.size} stale in-flight seqs`);
+            for (const seq of [...this.cursor.inFlight]) {
+                (0, cursor_1.markCompleted)(this.cursor, seq);
             }
+            this.logger.info("Crash recovery: all stale in-flight seqs cleared");
         }
         this.loop();
     }
@@ -112,17 +100,42 @@ class Dispatcher {
     async tick() {
         // 1. Dequeue hints
         const hints = this.queue.dequeue(this.config.maxConcurrency);
-        // 2. Pull full events for hints
-        if (hints.length > 0) {
-            const events = await (0, http_client_1.pullEvents)(this.creds, this.config.commandTopicId, this.cursor.waterline, 50);
-            for (const evt of events) {
-                await this.processEvent(evt);
+        // 2. Pull + process events (errors must NOT prevent step 3 outbox flush)
+        try {
+            if (hints.length > 0) {
+                const events = await (0, http_client_1.pullEvents)(this.creds, this.config.commandTopicId, this.cursor.waterline, 50);
+                for (const evt of events) {
+                    try {
+                        await this.processEvent(evt);
+                    }
+                    catch (e) {
+                        // Safety net: force-complete to prevent waterline stall
+                        const seq = evt.sequence_no;
+                        this.logger.error(`processEvent unexpected error, force-completing seq=${seq}: ${e.message}`);
+                        try {
+                            (0, cursor_1.markCompleted)(this.cursor, seq);
+                        }
+                        catch { }
+                        this.processingSeqs.delete(seq);
+                    }
+                }
             }
         }
-        // 3. Flush outbox (always, regardless of hints)
-        const finalized = await (0, outbox_1.flushOutbox)(this.creds, this.config.resultTopicId, this.logger);
-        for (const seq of finalized) {
-            (0, cursor_1.markCompleted)(this.cursor, seq);
+        catch (e) {
+            // pullEvents failed (network error, auth error, etc.)
+            // Log but continue to step 3 — outbox flush must always run
+            this.logger.error(`Pull failed: ${e.message}`);
+        }
+        // 3. Flush outbox — MUST always run, even if pull/processEvent failed above.
+        // This is the only path that finalizes outboxed seqs → markCompleted → waterline advance.
+        try {
+            const finalized = await (0, outbox_1.flushOutbox)(this.creds, this.config.resultTopicId, this.logger);
+            for (const seq of finalized) {
+                (0, cursor_1.markCompleted)(this.cursor, seq);
+            }
+        }
+        catch (e) {
+            this.logger.error(`Outbox flush failed: ${e.message}`);
         }
         // 4. Periodic cleanup (every ~50 ticks)
         if (Math.random() < 0.02) {
@@ -132,9 +145,6 @@ class Dispatcher {
             if (this.processedRequestIds.size > 10_000) {
                 this.processedRequestIds.clear();
             }
-            if (this.statusPublished.size > 10_000) {
-                this.statusPublished.clear();
-            }
         }
     }
     async processEvent(evt) {
@@ -151,8 +161,13 @@ class Dispatcher {
         // but allow re-processing for crash recovery (inFlight from previous run)
         if (this.cursor.inFlight.has(seq) && this.processingSeqs.has(seq))
             return;
-        if ((0, cursor_1.isEventProcessed)(this.cursor, eventId))
+        if ((0, cursor_1.isEventProcessed)(this.cursor, eventId)) {
+            // Event already processed — markCompleted to prevent waterline stall.
+            // Without this, a seq stuck at waterline+1 with processedEvents=true
+            // would block all subsequent events forever.
+            (0, cursor_1.markCompleted)(this.cursor, seq);
             return;
+        }
         const payload = evt.payload || {};
         const requestId = payload.request_id || eventId;
         // ---- DEDUP LAYER 2: Application (request_id) ----
@@ -180,9 +195,8 @@ class Dispatcher {
             const wrappedMessage = (0, sanitize_1.wrapMessage)(messageText);
             const idempotencyKey = crypto.randomUUID();
             this.logger.info(`Processing: seq=${seq} requestId=${requestId}`);
-            // Publish "processing" status ONCE per request
-            if (!this.statusPublished.has(requestId)) {
-                this.statusPublished.add(requestId);
+            // Optional: publish "processing" status (debug/dev only)
+            if (this.config.publishProcessingStatus) {
                 try {
                     await (0, http_client_1.publishEvent)(this.creds, this.config.resultTopicId, "openclaw.status", {
                         request_id: requestId,
@@ -209,7 +223,7 @@ class Dispatcher {
                 requestId,
                 sequenceNo: seq,
                 result: {
-                    message: (0, sanitize_1.sanitizeResponse)(responseText || "No response from agent"),
+                    message: (0, sanitize_1.sanitizeResponse)(responseText || dispatchResult.error || ""),
                     status: dispatchResult.status === "ok" ? "completed" : "failed",
                     conversationKey,
                     ...(attachments.length > 0 ? { attachments } : {}),
@@ -220,23 +234,61 @@ class Dispatcher {
             this.logger.info(`Outboxed: seq=${seq} requestId=${requestId}`);
         }
         catch (e) {
-            this.logger.error(`Event processing failed: seq=${seq} error=${e.message}`);
-            (0, outbox_1.addToOutbox)({
-                eventId,
-                requestId,
-                sequenceNo: seq,
-                result: {
-                    message: `Agent error: ${e.message}`,
-                    status: "failed",
-                },
-            });
-            (0, cursor_1.recordProcessedEvent)(this.cursor, eventId);
+            if (isTransientError(e)) {
+                // Transport failure: Gateway に届かなかった。
+                // outbox に書かない → findByRequestId で後続をブロックしない。
+                // recordProcessedEvent しない → event_id dedup で後続をブロックしない。
+                // markCompleted で waterline を進める → このイベントはドロップ。
+                this.logger.error(`Transport failed after retries, dropping: seq=${seq} error=${e.message}`);
+                (0, cursor_1.markCompleted)(this.cursor, seq);
+                try {
+                    await (0, http_client_1.publishEvent)(this.creds, this.config.resultTopicId, "openclaw.status", {
+                        request_id: requestId,
+                        status: "dropped",
+                        error: e.message,
+                    });
+                }
+                catch { }
+            }
+            else {
+                // Application failure: Gateway に届いた上でのエラー → 既存処理
+                this.logger.error(`Event processing failed: seq=${seq} error=${e.message}`);
+                (0, outbox_1.addToOutbox)({
+                    eventId,
+                    requestId,
+                    sequenceNo: seq,
+                    result: {
+                        message: `Agent error: ${e.message}`,
+                        status: "failed",
+                    },
+                });
+                (0, cursor_1.recordProcessedEvent)(this.cursor, eventId);
+            }
         }
         finally {
             this.processingSeqs.delete(seq);
         }
     }
-    callDispatchEndpoint(params) {
+    async callDispatchEndpoint(params) {
+        const MAX_TRANSPORT_RETRIES = 3;
+        const RETRY_BASE_MS = 2000;
+        for (let attempt = 0; attempt < MAX_TRANSPORT_RETRIES; attempt++) {
+            try {
+                return await this._doDispatchRequest(params);
+            }
+            catch (e) {
+                if (isTransientError(e) && attempt < MAX_TRANSPORT_RETRIES - 1) {
+                    const delay = RETRY_BASE_MS * Math.pow(2, attempt);
+                    this.logger.warn(`Dispatch transport retry ${attempt + 1}/${MAX_TRANSPORT_RETRIES} in ${delay}ms: ${e.message}`);
+                    await sleep(delay);
+                    continue;
+                }
+                throw e;
+            }
+        }
+        throw new Error("Dispatch: max transport retries exceeded");
+    }
+    _doDispatchRequest(params) {
         return new Promise((resolve, reject) => {
             const body = JSON.stringify(params);
             const req = http.request({
@@ -269,3 +321,12 @@ exports.Dispatcher = Dispatcher;
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
+/** Transport-layer errors: Gateway に届かなかった場合のみ true */
+function isTransientError(e) {
+    const code = e?.code;
+    if (code && ["ECONNREFUSED", "ETIMEDOUT", "ECONNRESET", "EHOSTUNREACH"].includes(code)) {
+        return true;
+    }
+    const msg = e?.message || "";
+    return msg.includes("socket hang up") || msg.includes("Dispatch timeout");
+}

package/dist/index.js

@@ -330,12 +330,37 @@ function default_1(api) {
         auth: "plugin",
         match: "exact",
         handler: async (req, res) => {
+            // Reject non-POST (e.g. HEAD from readiness probe)
+            if (req.method !== "POST") {
+                res.statusCode = 405;
+                res.setHeader("Allow", "POST");
+                res.setHeader("Content-Type", "application/json");
+                res.end('{"error":"method not allowed"}');
+                return true;
+            }
             const chunks = [];
-            await new Promise((resolve) => {
+            await new Promise((resolve, reject) => {
                 req.on("data", (c) => chunks.push(c));
                 req.on("end", resolve);
-            });
-            const params = JSON.parse(Buffer.concat(chunks).toString());
+                req.on("error", reject);
+            }).catch(() => { }); // aborted/truncated request → empty body → 400 below
+            const raw = Buffer.concat(chunks).toString();
+            if (!raw) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "application/json");
+                res.end('{"error":"empty body"}');
+                return true;
+            }
+            let params;
+            try {
+                params = JSON.parse(raw);
+            }
+            catch (e) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: "invalid JSON", detail: e.message }));
+                return true;
+            }
             try {
                 // Track active session for attachment registry
                 activeSessionKey = params.sessionKey;
@@ -365,6 +390,10 @@ function default_1(api) {
                         }
                     }
                 }
+                else {
+                    // Subagent failed (rate limit, timeout, etc.) — include reason in response
+                    responseText = waitResult.error || waitResult.message || `Agent failed: ${waitResult.status}`;
+                }
                 // Collect attachments uploaded during this run
                 const attachments = consumeAttachments(params.sessionKey);
                 activeSessionKey = null;
@@ -396,8 +425,12 @@ function default_1(api) {
         logger.warn?.("[agentrux] ingressMode=webhook but webhookSecret not set. Falling back to poll-only.");
     }
     // --- Start Dispatcher + (Webhook|SSE) + Poller ---
-    setTimeout(() => {
+    // Gateway readiness probe: wait until /health responds.
+    // Even if /health comes up before plugin routes, the transport retry
+    // in callDispatchEndpoint (3 attempts, 2s/4s backoff) covers the gap.
+    (async () => {
         try {
+            await waitForGateway(18789, 30_000, logger);
             dispatcher.start().catch((e) => logger.error("[agentrux] Dispatcher failed:", e));
             if (sseListener) {
                 sseListener.start().catch((e) => logger.error("[agentrux] SSE failed:", e));
@@ -408,5 +441,24 @@ function default_1(api) {
         catch (e) {
             logger.error("[agentrux] Ingress startup error:", e);
         }
-    }, 5000);
+    })();
+}
+async function waitForGateway(port, timeoutMs, logger) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            await new Promise((resolve, reject) => {
+                const req = require("http").request({ hostname: "127.0.0.1", port, path: "/health", method: "GET", timeout: 2000 }, (res) => { res.resume(); resolve(); });
+                req.on("error", reject);
+                req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+                req.end();
+            });
+            logger.info("[agentrux] Gateway is ready");
+            return;
+        }
+        catch {
+            await new Promise((r) => setTimeout(r, 2000));
+        }
+    }
+    logger.warn("[agentrux] Gateway readiness timeout — starting Dispatcher anyway");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentrux/agentrux-openclaw-plugin",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "OpenClaw plugin for AgenTrux — Agent-to-Agent authenticated Pub/Sub",
   "keywords": [
     "openclaw",