gopherhole_openclaw_a2a 0.4.6 → 0.4.8

package/dist/src/channel.js

@@ -261,7 +261,20 @@ export const a2aPlugin = {
                         a2aLog.messageProcessing(message.taskId, sessionKey);
                         // Add A2A context so the agent knows to relay its full response
                         const a2aContext = `[A2A Request from agent "${message.from}"]\n\n${text}\n\n[Note: Your complete response will be sent back to the requesting agent. Include all relevant information in your reply.]`;
-                        const response = await sendChatMessage(sessionKey, a2aContext);
+                        // A2A status updates are task-level keepalives. Publish one now and
+                        // periodically while OpenClaw is working so callers do not mistake
+                        // a long tool run for a dead connection.
+                        connectionManager?.sendTaskStatusViaGopherHole(message.taskId, 'OpenClaw is working');
+                        const keepalive = setInterval(() => {
+                            connectionManager?.sendTaskStatusViaGopherHole(message.taskId, 'OpenClaw is still working');
+                        }, 30_000);
+                        let response;
+                        try {
+                            response = await sendChatMessage(sessionKey, a2aContext);
+                        }
+                        finally {
+                            clearInterval(keepalive);
+                        }
                         // Log captured response
                         if (response?.text) {
                             a2aLog.responseCaptured(message.taskId, response.text);

package/dist/src/connection.d.ts

@@ -44,6 +44,7 @@ export declare class A2AConnectionManager {
      * Uses SDK's respond() method to complete the original task
      */
     sendResponseViaGopherHole(_targetAgentId: string, taskId: string, text: string, _contextId?: string): void;
+    sendTaskStatusViaGopherHole(taskId: string, message?: string): void;
     /**
      * Legacy alias for sendPartsViaGopherHole with text-only
      */

package/dist/src/connection.js

@@ -271,6 +271,17 @@ export class A2AConnectionManager {
             console.error('[a2a] Error details:', err);
         }
     }
+    sendTaskStatusViaGopherHole(taskId, message) {
+        if (!this.gopherhole || !this.connected || !taskId || taskId.startsWith('gph-')) {
+            return;
+        }
+        try {
+            this.gopherhole.updateTaskStatus(taskId, 'working', message);
+        }
+        catch (err) {
+            console.error('[a2a] Failed to publish task status:', err.message);
+        }
+    }
     /**
      * Legacy alias for sendPartsViaGopherHole with text-only
      */

package/dist/src/gateway-client.d.ts

@@ -1,11 +1,13 @@
 /**
  * Gateway WebSocket Client
- * Sends messages to the Clawdbot gateway via its WebSocket protocol
+ * Sends messages to the OpenClaw gateway via its WebSocket protocol
  *
  * chat.send is non-blocking - it returns a runId immediately and
  * streams the response via chat events. We accumulate deltas and
  * resolve when we get state: "final".
  */
+export declare const GATEWAY_PROTOCOL_VERSION = 4;
+export declare const CHAT_INACTIVITY_TIMEOUT_MS: number;
 export declare function connectToGateway(port?: number): Promise<void>;
 export declare function callGateway(method: string, params: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;
 /**

package/dist/src/gateway-client.js

@@ -1,6 +1,6 @@
 /**
  * Gateway WebSocket Client
- * Sends messages to the Clawdbot gateway via its WebSocket protocol
+ * Sends messages to the OpenClaw gateway via its WebSocket protocol
  *
  * chat.send is non-blocking - it returns a runId immediately and
  * streams the response via chat events. We accumulate deltas and
@@ -16,6 +16,18 @@ let pendingRequests = new Map();
 let pendingChats = new Map(); // keyed by runId
 let connected = false;
 let handshakeComplete = false;
+// OpenClaw 2026.7+ requires gateway protocol v4. Keep this explicit so a
+// protocol bump fails a focused compatibility test instead of silently
+// breaking inbound A2A replies at runtime.
+export const GATEWAY_PROTOCOL_VERSION = 4;
+export const CHAT_INACTIVITY_TIMEOUT_MS = 30 * 60 * 1000;
+function refreshChatTimeout(runId, pending) {
+    clearTimeout(pending.timeout);
+    pending.timeout = setTimeout(() => {
+        pendingChats.delete(runId);
+        pending.reject(new Error('Chat response inactivity timeout'));
+    }, pending.timeoutMs);
+}
 function getGatewayToken() {
     // Try the current OpenClaw config location first, then the legacy
     // Clawdbot path as a fallback for users still on older installs.
@@ -56,12 +68,12 @@ export async function connectToGateway(port = 18789) {
                 id: connectId,
                 method: 'connect',
                 params: {
-                    minProtocol: 3,
-                    maxProtocol: 3,
+                    minProtocol: GATEWAY_PROTOCOL_VERSION,
+                    maxProtocol: GATEWAY_PROTOCOL_VERSION,
                     client: {
                         id: 'gateway-client',
                         displayName: 'A2A Channel Plugin',
-                        version: '0.3.4',
+                        version: '0.4.8',
                         platform: process.platform,
                         mode: 'backend',
                     },
@@ -170,6 +182,9 @@ function handleChatEvent(payload) {
         // Not a chat we're tracking
         return;
     }
+    // Any chat event proves the OpenClaw run is alive. Treat the timeout as an
+    // inactivity deadline rather than a fixed whole-task deadline.
+    refreshChatTimeout(payload.runId, pending);
     // Detailed logging for debugging relay issues
     console.log(`[a2a] Chat event: runId=${payload.runId}, state=${payload.state}, seq=${payload.seq}, role=${payload.message?.role}`);
     if (payload.state === 'delta' || payload.state === 'final') {
@@ -234,7 +249,7 @@ export async function callGateway(method, params, timeoutMs = 300000) {
  * Send a chat message and wait for the full response.
  * chat.send is non-blocking - returns runId immediately, response streams via events.
  */
-export async function sendChatMessage(sessionKey, message, timeoutMs = 300000) {
+export async function sendChatMessage(sessionKey, message, timeoutMs = CHAT_INACTIVITY_TIMEOUT_MS) {
     if (!ws || !connected || !handshakeComplete) {
         await connectToGateway();
     }
@@ -252,16 +267,15 @@ export async function sendChatMessage(sessionKey, message, timeoutMs = 300000) {
     }
     // Now wait for chat events to complete
     return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            pendingChats.delete(result.runId);
-            reject(new Error('Chat response timeout'));
-        }, timeoutMs);
-        pendingChats.set(result.runId, {
+        const pending = {
             resolve,
             reject,
-            timeout,
+            timeout: undefined,
             latestText: '',
-        });
+            timeoutMs,
+        };
+        pendingChats.set(result.runId, pending);
+        refreshChatTimeout(result.runId, pending);
     });
 }
 export function disconnectFromGateway() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gopherhole_openclaw_a2a",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "GopherHole A2A plugin for OpenClaw - connect your AI agent to the GopherHole network",
   "type": "module",
   "main": "dist/index.js",
@@ -35,7 +35,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@gopherhole/sdk": "^0.7.5",
+    "@gopherhole/sdk": "^0.9.1",
     "uuid": "^10.0.0"
   },
   "devDependencies": {
@@ -53,4 +53,4 @@
     "README.md",
     "SKILL.md"
   ]
-}
+}