gopherhole_openclaw_a2a 0.3.15 → 0.4.1

package/SKILL.md

@@ -16,7 +16,7 @@ Add to your Clawdbot config:
 channels:
   a2a:
     enabled: true
-    agentId: nova              # Our identifier (default: clawdbot)
+    agentId: nova              # Our identifier (default: openclaw)
     agentName: Nova            # Display name
     bridgeUrl: ws://localhost:8080/a2a   # A2A bridge/hub (optional)
     agents:                    # Direct agent connections (optional)

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * A2A Channel Plugin Entry Point
- * Enables Clawdbot to communicate with other AI agents via A2A protocol
+ * Enables OpenClaw to communicate with other AI agents via A2A protocol
  */
 import { getA2AConnectionManager } from './src/channel.js';
-interface ClawdbotPluginApi {
+interface OpenClawPluginApi {
     runtime: unknown;
     registerChannel(opts: {
         plugin: unknown;
@@ -29,7 +29,7 @@ declare const plugin: {
         additionalProperties: boolean;
         properties: {};
     };
-    register(api: ClawdbotPluginApi): void;
+    register(api: OpenClawPluginApi): void;
 };
 export default plugin;
 export { getA2AConnectionManager };

package/dist/index.js

@@ -1,6 +1,6 @@
 /**
  * A2A Channel Plugin Entry Point
- * Enables Clawdbot to communicate with other AI agents via A2A protocol
+ * Enables OpenClaw to communicate with other AI agents via A2A protocol
  */
 import { a2aPlugin, setA2ARuntime, getA2AConnectionManager } from './src/channel.js';
 import { readFileSync } from 'fs';

package/dist/src/gateway-client.js

@@ -17,14 +17,24 @@ let pendingChats = new Map(); // keyed by runId
 let connected = false;
 let handshakeComplete = false;
 function getGatewayToken() {
-    try {
-        const configPath = join(homedir(), '.clawdbot', 'clawdbot.json');
-        const config = JSON.parse(readFileSync(configPath, 'utf8'));
-        return config?.gateway?.auth?.token ?? null;
-    }
-    catch {
-        return null;
+    // Try the current OpenClaw config location first, then the legacy
+    // Clawdbot path as a fallback for users still on older installs.
+    const candidates = [
+        join(homedir(), '.openclaw', 'openclaw.json'),
+        join(homedir(), '.clawdbot', 'clawdbot.json'),
+    ];
+    for (const configPath of candidates) {
+        try {
+            const config = JSON.parse(readFileSync(configPath, 'utf8'));
+            const token = config?.gateway?.auth?.token;
+            if (token)
+                return token;
+        }
+        catch {
+            // file missing or unparseable — try next
+        }
     }
+    return null;
 }
 export async function connectToGateway(port = 18789) {
     if (ws && connected && handshakeComplete)

package/dist/src/logger.js

@@ -5,7 +5,7 @@
 import { appendFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-const LOG_DIR = join(homedir(), '.clawdbot', 'logs');
+const LOG_DIR = join(homedir(), '.openclaw', 'logs');
 const A2A_LOG_FILE = join(LOG_DIR, 'a2a.log');
 // Ensure log directory exists
 try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gopherhole_openclaw_a2a",
-  "version": "0.3.15",
+  "version": "0.4.1",
   "description": "GopherHole A2A plugin for OpenClaw - connect your AI agent to the GopherHole network",
   "type": "module",
   "main": "dist/index.js",
@@ -12,14 +12,13 @@
     "test:watch": "vitest",
     "prepublishOnly": "npm run build"
   },
-  "clawdbot": {
+  "openclaw": {
     "extensions": [
       "./dist/index.js"
     ]
   },
   "keywords": [
     "openclaw",
-    "clawdbot",
     "a2a",
     "gopherhole",
     "agent",
@@ -27,13 +26,16 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/helixdata/gopherhole.git",
-    "directory": "clawdbot-plugin"
+    "url": "git+https://github.com/helixdata/gopherhole-clients.git",
+    "directory": "packages/plugin-openclaw"
   },
   "homepage": "https://gopherhole.ai",
+  "bugs": {
+    "url": "https://github.com/helixdata/gopherhole-clients/issues"
+  },
   "license": "MIT",
   "dependencies": {
-    "@gopherhole/sdk": "^0.5.0",
+    "@gopherhole/sdk": "^0.7.1",
     "uuid": "^10.0.0"
   },
   "devDependencies": {
@@ -44,5 +46,11 @@
   },
   "peerDependencies": {
     "openclaw": "*"
-  }
+  },
+  "files": [
+    "dist",
+    "openclaw.plugin.json",
+    "README.md",
+    "SKILL.md"
+  ]
 }

package/A2A-FIX-GUIDE.md

@@ -1,122 +0,0 @@
-# OpenClaw A2A Plugin - Response Relay Fix Guide
-
-## Problem
-When Agent A sends to Agent B via GopherHole, Agent B can receive and process the message, but the response doesn't get relayed back. Agent A sees their original message echoed instead of the actual response.
-
-## Root Cause Analysis
-
-### 1. TaskId Flow Issue
-The `taskId` is critical for routing responses back. If it's missing or invalid:
-- `connection.ts` generates a fake `gph-<timestamp>` ID
-- `respond()` sends to this fake task
-- GopherHole ignores it (task doesn't exist)
-- `waitForTask` falls back to history, returning the original request
-
-### 2. Agent ID Mismatch
-GopherHole validates that responses come from the correct agent:
-```sql
-SELECT context_id FROM tasks WHERE id = ? AND server_agent_id = ?
-```
-If the agent's connected ID doesn't match `server_agent_id`, the response is silently dropped.
-
-## Debugging Steps
-
-### Step 1: Add Logging to connection.ts
-
-In `handleIncomingMessage()`:
-```typescript
-private handleIncomingMessage(message: Message): void {
-  console.log(`[a2a] RAW incoming message:`, JSON.stringify(message, null, 2));
-  
-  if (!this.messageHandler) return;
-
-  console.log(`[a2a] Received message from ${message.from}, taskId=${message.taskId}`);
-  // ... rest of handler
-}
-```
-
-In `sendResponseViaGopherHole()`:
-```typescript
-sendResponseViaGopherHole(
-  _targetAgentId: string,
-  taskId: string,
-  text: string,
-  _contextId?: string
-): void {
-  console.log(`[a2a] Attempting respond - taskId=${taskId}, connected=${this.connected}, text=${text.slice(0, 100)}`);
-  
-  if (!taskId || taskId.startsWith('gph-')) {
-    console.error(`[a2a] WARNING: Invalid taskId "${taskId}" - response will be lost!`);
-  }
-  // ... rest of method
-}
-```
-
-### Step 2: Verify Agent ID Configuration
-
-Check your config:
-```yaml
-channels:
-  a2a:
-    enabled: true
-    agentId: "agent-XXXXXXXX"  # Must match your GopherHole agent ID
-    apiKey: "gph_..."
-```
-
-The `agentId` here should match exactly what's in your GopherHole dashboard.
-
-### Step 3: Check SDK Message Event
-
-In the SDK (`@gopherhole/sdk`), the message handler should receive taskId:
-```typescript
-this.emit('message', {
-  from: data.from,
-  taskId: data.taskId,  // Must be present!
-  payload: data.payload,
-  timestamp: data.timestamp || Date.now(),
-});
-```
-
-If `data.taskId` is undefined in the raw WebSocket message from GopherHole, that's a server-side bug.
-
-## The Fix
-
-### Option A: Ensure taskId is propagated (SDK/Server fix)
-
-The GopherHole hub's `deliverMessage` should always include taskId:
-```typescript
-conn.ws.send(JSON.stringify({
-  type: 'message',
-  from: message.from,
-  taskId: message.taskId,  // This must be present
-  payload: message.payload,
-}));
-```
-
-### Option B: Plugin resilience (Client-side workaround)
-
-If taskId isn't available, the plugin could store a mapping:
-```typescript
-// In handleIncomingMessage:
-const taskId = message.taskId || `pending-${message.from}-${Date.now()}`;
-if (!message.taskId) {
-  // Store for later - need server-side support for this
-  console.warn('[a2a] No taskId in message - response routing may fail');
-}
-```
-
-## Testing
-
-1. Send a simple message to your agent via GopherHole
-2. Check logs for:
-   - `[a2a] RAW incoming message:` - does it have taskId?
-   - `[a2a] Attempting respond - taskId=` - is taskId valid?
-3. If taskId is missing/invalid, the issue is upstream (SDK or GopherHole server)
-
-## Quick Checklist
-
-- [ ] Agent ID in config matches GopherHole dashboard
-- [ ] API key is valid and has correct permissions
-- [ ] WebSocket connection is established (check for "Connected to GopherHole Hub via SDK" log)
-- [ ] Incoming messages have valid taskId (not undefined or gph-*)
-- [ ] Agent's `respond()` is actually being called after processing

package/index.ts

@@ -1,232 +0,0 @@
-/**
- * A2A Channel Plugin Entry Point
- * Enables Clawdbot to communicate with other AI agents via A2A protocol
- */
-
-import { a2aPlugin, setA2ARuntime, getA2AConnectionManager } from './src/channel.js';
-import { readFileSync } from 'fs';
-import { basename, extname } from 'path';
-
-// Minimal plugin interface
-interface ClawdbotPluginApi {
-  runtime: unknown;
-  registerChannel(opts: { plugin: unknown }): void;
-  registerTool?(opts: {
-    name: string;
-    description: string;
-    parameters: unknown;
-    execute: (id: string, params: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
-  }): void;
-}
-
-const plugin = {
-  id: 'gopherhole_openclaw_a2a',
-  name: 'A2A Protocol',
-  description: 'Agent-to-Agent communication channel',
-  configSchema: { type: 'object', additionalProperties: false, properties: {} },
-  register(api: ClawdbotPluginApi) {
-    setA2ARuntime(api.runtime);
-    api.registerChannel({ plugin: a2aPlugin });
-
-    // Register a tool for interacting with connected agents
-    api.registerTool?.({
-      name: 'a2a_agents',
-      description: 'List connected A2A agents and send messages to them',
-      parameters: {
-        type: 'object',
-        properties: {
-          action: {
-            type: 'string',
-            enum: ['list', 'send'],
-            description: 'Action to perform',
-          },
-          agentId: {
-            type: 'string',
-            description: 'Target agent ID (for send action)',
-          },
-          message: {
-            type: 'string',
-            description: 'Text message to send (for send action)',
-          },
-          image: {
-            type: 'string',
-            description: 'Path to image file to send (for send action)',
-          },
-          file: {
-            type: 'string',
-            description: 'Path to file to send - PDF, documents, etc. (for send action)',
-          },
-        },
-        required: ['action'],
-      },
-      execute: async (_id, params) => {
-        const action = params.action as string;
-        const agentId = params.agentId as string | undefined;
-        const message = params.message as string | undefined;
-        const imagePath = params.image as string | undefined;
-        const filePath = params.file as string | undefined;
-        
-        const manager = getA2AConnectionManager();
-        if (!manager) {
-          return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'A2A channel not running' }) }] };
-        }
-
-        if (action === 'list') {
-          const hubStatus = manager.listAgents();
-          const availableAgents = await manager.listAvailableAgents();
-          return { content: [{ type: 'text', text: JSON.stringify({ 
-            status: 'ok', 
-            connected: hubStatus.some(h => h.connected),
-            agents: availableAgents 
-          }) }] };
-        }
-
-        if (action === 'send') {
-          if (!agentId || (!message && !imagePath && !filePath)) {
-            return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'agentId and (message, image, or file) required for send action' }) }] };
-          }
-          try {
-            const isGopherHoleConnected = manager.isGopherHoleConnected();
-            const isDirectConnection = manager.isConnected(agentId) && agentId !== 'gopherhole';
-            
-            // Build parts array
-            const parts: Array<{ kind: string; text?: string; data?: string; mimeType?: string }> = [];
-            
-            // Add text part if message provided
-            if (message) {
-              parts.push({ kind: 'text', text: message });
-            }
-            
-            // Add file part if image or file path provided
-            const attachmentPath = imagePath || filePath;
-            if (attachmentPath) {
-              try {
-                const fileData = readFileSync(attachmentPath);
-                const base64Data = fileData.toString('base64');
-                const ext = extname(attachmentPath).toLowerCase();
-                const mimeTypes: Record<string, string> = {
-                  // Images
-                  '.png': 'image/png',
-                  '.jpg': 'image/jpeg',
-                  '.jpeg': 'image/jpeg',
-                  '.gif': 'image/gif',
-                  '.webp': 'image/webp',
-                  '.svg': 'image/svg+xml',
-                  // Documents
-                  '.pdf': 'application/pdf',
-                  '.doc': 'application/msword',
-                  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-                  '.xls': 'application/vnd.ms-excel',
-                  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-                  '.ppt': 'application/vnd.ms-powerpoint',
-                  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-                  '.txt': 'text/plain',
-                  '.csv': 'text/csv',
-                  '.json': 'application/json',
-                  '.xml': 'application/xml',
-                  '.html': 'text/html',
-                  '.md': 'text/markdown',
-                  // Archives
-                  '.zip': 'application/zip',
-                };
-                const mimeType = mimeTypes[ext] || 'application/octet-stream';
-                parts.push({ kind: 'data', data: base64Data, mimeType });
-              } catch (fileErr) {
-                return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: `Failed to read file: ${(fileErr as Error).message}` }) }] };
-              }
-            }
-            
-            let response;
-            if (isDirectConnection) {
-              // Direct WebSocket - only supports text for now
-              if (message) {
-                response = await manager.sendMessage(agentId, message);
-              } else {
-                return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'Direct connections only support text messages' }) }] };
-              }
-            } else if (isGopherHoleConnected) {
-              // Route through GopherHole hub with multi-part support
-              response = await manager.sendPartsViaGopherHole(agentId, parts);
-            } else {
-              return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: `Cannot reach agent ${agentId} - no direct connection or GopherHole` }) }] };
-            }
-            return { content: [{ type: 'text', text: JSON.stringify({ status: 'ok', agentId, response }) }] };
-          } catch (err) {
-            return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: (err as Error).message }) }] };
-          }
-        }
-
-        return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: `Unknown action: ${action}` }) }] };
-      },
-    });
-
-    // Register a tool for location-based agent discovery
-    api.registerTool?.({
-      name: 'a2a_discover_nearby',
-      description: 'Find A2A agents near a geographic location',
-      parameters: {
-        type: 'object',
-        properties: {
-          lat: {
-            type: 'number',
-            description: 'Latitude of search center',
-          },
-          lng: {
-            type: 'number',
-            description: 'Longitude of search center',
-          },
-          radius: {
-            type: 'number',
-            description: 'Search radius in kilometers (default: 10, max: 500)',
-          },
-          tag: {
-            type: 'string',
-            description: 'Filter by tag (e.g., "retail", "food")',
-          },
-          category: {
-            type: 'string',
-            description: 'Filter by category',
-          },
-          limit: {
-            type: 'number',
-            description: 'Maximum number of results (default: 20, max: 50)',
-          },
-        },
-        required: ['lat', 'lng'],
-      },
-      execute: async (_id, params) => {
-        const lat = params.lat as number;
-        const lng = params.lng as number;
-        const radius = params.radius as number | undefined;
-        const tag = params.tag as string | undefined;
-        const category = params.category as string | undefined;
-        const limit = params.limit as number | undefined;
-        
-        const manager = getA2AConnectionManager();
-        if (!manager) {
-          return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'A2A channel not running' }) }] };
-        }
-
-        if (!manager.isGopherHoleConnected()) {
-          return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'Not connected to GopherHole' }) }] };
-        }
-
-        try {
-          const agents = await manager.discoverNearby({ lat, lng, radius, tag, category, limit });
-          return { content: [{ type: 'text', text: JSON.stringify({ 
-            status: 'ok', 
-            center: { lat, lng },
-            radius: radius || 10,
-            count: agents.length,
-            agents 
-          }) }] };
-        } catch (err) {
-          return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: (err as Error).message }) }] };
-        }
-      },
-    });
-  },
-};
-
-export default plugin;
-export { getA2AConnectionManager };