gopherhole_openclaw_a2a 0.3.9 → 0.3.11

package/dist/src/connection.d.ts

@@ -16,6 +16,11 @@ export declare class A2AConnectionManager {
     start(): Promise<void>;
     private connectToGopherHole;
     private handleIncomingMessage;
+    /**
+     * Handle system messages from GopherHole Hub
+     * These include spending alerts, account alerts, notices, maintenance, etc.
+     */
+    private handleSystemMessage;
     stop(): Promise<void>;
     /**
      * Send a message to another agent via GopherHole and wait for response
@@ -49,15 +54,38 @@ export declare class A2AConnectionManager {
      */
     isGopherHoleConnected(): boolean;
     /**
-     * List available agents from GopherHole
-     * Fetches same-tenant agents + agents with approved access + public agents
+     * Make an A2A JSON-RPC call
      */
-    listAvailableAgents(): Promise<Array<{
+    private a2aRpc;
+    /**
+     * List available agents from GopherHole (agents you have access to)
+     */
+    listAvailableAgents(options?: {
+        query?: string;
+        public?: boolean;
+    }): Promise<Array<{
         id: string;
         name: string;
         description?: string;
+        verified?: boolean;
         accessType: 'same-tenant' | 'public' | 'granted';
     }>>;
+    /**
+     * Discover public agents in the marketplace
+     */
+    discoverAgents(options?: {
+        query?: string;
+        category?: string;
+        verified?: boolean;
+        limit?: number;
+    }): Promise<Array<{
+        id: string;
+        name: string;
+        description?: string;
+        verified?: boolean;
+        tenantName?: string;
+        avgRating?: number;
+    }>>;
     /**
      * List connection status (for backward compatibility)
      */

package/dist/src/connection.js

@@ -92,6 +92,10 @@ export class A2AConnectionManager {
         this.gopherhole.on('message', (message) => {
             this.handleIncomingMessage(message);
         });
+        // Handle system messages (rate limits, budget alerts, announcements)
+        this.gopherhole.on('system', (message) => {
+            this.handleSystemMessage(message);
+        });
         // Connect
         try {
             await this.gopherhole.connect();
@@ -131,6 +135,40 @@ export class A2AConnectionManager {
             console.error('[a2a] Error handling incoming message:', err);
         });
     }
+    /**
+     * Handle system messages from GopherHole Hub
+     * These include spending alerts, account alerts, notices, maintenance, etc.
+     */
+    handleSystemMessage(message) {
+        const kind = message.metadata?.kind;
+        const text = message.payload.parts.find(p => p.kind === 'text')?.text || '';
+        const data = message.metadata?.data;
+        // Log all system messages
+        console.log(`[a2a] System message (${kind || 'unknown'}): ${text}`);
+        // Handle specific message kinds
+        switch (kind) {
+            case 'spending_alert':
+                console.warn(`[a2a] 💰 Spending alert: ${text}`);
+                if (data) {
+                    console.warn(`[a2a] Spending data:`, JSON.stringify(data));
+                }
+                break;
+            case 'account_alert':
+                console.warn(`[a2a] ⚠️ Account alert: ${text}`);
+                break;
+            case 'system_notice':
+                console.log(`[a2a] 📢 System notice: ${text}`);
+                break;
+            case 'maintenance':
+                console.warn(`[a2a] 🔧 Maintenance notice: ${text}`);
+                break;
+            default:
+                // Log but don't warn for unknown types
+                if (kind) {
+                    console.log(`[a2a] System message "${kind}": ${text}`);
+                }
+        }
+    }
     async stop() {
         if (this.gopherhole) {
             this.gopherhole.disconnect();
@@ -234,39 +272,66 @@ export class A2AConnectionManager {
         return this.connected && this.gopherhole?.connected === true;
     }
     /**
-     * List available agents from GopherHole
-     * Fetches same-tenant agents + agents with approved access + public agents
+     * Make an A2A JSON-RPC call
      */
-    async listAvailableAgents() {
+    async a2aRpc(method, params) {
         if (!this.config.apiKey) {
-            return [];
+            return null;
         }
         const hubUrl = this.config.bridgeUrl || 'wss://hub.gopherhole.ai/ws';
-        // Convert wss:// to https:// for API calls
         const apiBase = hubUrl.replace('wss://', 'https://').replace('/ws', '');
         try {
-            const response = await fetch(`${apiBase}/api/agents/available`, {
+            const response = await fetch(`${apiBase}/a2a`, {
+                method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${this.config.apiKey}`,
                     'Content-Type': 'application/json',
                 },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    method,
+                    params: params || {},
+                    id: Date.now(),
+                }),
             });
             if (!response.ok) {
-                console.error(`[a2a] Failed to fetch agents: ${response.status}`);
-                return [];
+                console.error(`[a2a] RPC failed: ${response.status}`);
+                return null;
             }
             const data = await response.json();
-            return data.agents.map(a => ({
-                id: a.id,
-                name: a.name,
-                description: a.description,
-                accessType: a.access_type,
-            }));
+            if (data.error) {
+                console.error(`[a2a] RPC error: ${data.error.message}`);
+                return null;
+            }
+            return data.result || null;
         }
         catch (err) {
-            console.error('[a2a] Error fetching available agents:', err.message);
+            console.error('[a2a] RPC error:', err.message);
+            return null;
+        }
+    }
+    /**
+     * List available agents from GopherHole (agents you have access to)
+     */
+    async listAvailableAgents(options) {
+        const result = await this.a2aRpc('x-gopherhole/agents.available', options);
+        if (!result?.agents) {
             return [];
         }
+        return result.agents.map(a => ({
+            id: a.id,
+            name: a.name,
+            description: a.description,
+            verified: a.verified,
+            accessType: a.accessType,
+        }));
+    }
+    /**
+     * Discover public agents in the marketplace
+     */
+    async discoverAgents(options) {
+        const result = await this.a2aRpc('x-gopherhole/agents.discover', options);
+        return result?.agents || [];
     }
     /**
      * List connection status (for backward compatibility)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gopherhole_openclaw_a2a",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "GopherHole A2A plugin for OpenClaw - connect your AI agent to the GopherHole network",
   "type": "module",
   "main": "dist/index.js",
@@ -35,6 +35,7 @@
     "uuid": "^10.0.0"
   },
   "devDependencies": {
+    "@types/node": "^25.5.0",
     "@types/uuid": "^10.0.0",
     "typescript": "^5.9.3"
   },

package/src/connection.ts

@@ -113,6 +113,11 @@ export class A2AConnectionManager {
       this.handleIncomingMessage(message);
     });
 
+    // Handle system messages (rate limits, budget alerts, announcements)
+    this.gopherhole.on('system', (message) => {
+      this.handleSystemMessage(message);
+    });
+
     // Connect
     try {
       await this.gopherhole.connect();
@@ -157,6 +162,47 @@ export class A2AConnectionManager {
     });
   }
 
+  /**
+   * Handle system messages from GopherHole Hub
+   * These include spending alerts, account alerts, notices, maintenance, etc.
+   */
+  private handleSystemMessage(message: Message): void {
+    const kind = message.metadata?.kind;
+    const text = message.payload.parts.find(p => p.kind === 'text')?.text || '';
+    const data = message.metadata?.data;
+
+    // Log all system messages
+    console.log(`[a2a] System message (${kind || 'unknown'}): ${text}`);
+
+    // Handle specific message kinds
+    switch (kind) {
+      case 'spending_alert':
+        console.warn(`[a2a] 💰 Spending alert: ${text}`);
+        if (data) {
+          console.warn(`[a2a] Spending data:`, JSON.stringify(data));
+        }
+        break;
+
+      case 'account_alert':
+        console.warn(`[a2a] ⚠️ Account alert: ${text}`);
+        break;
+
+      case 'system_notice':
+        console.log(`[a2a] 📢 System notice: ${text}`);
+        break;
+
+      case 'maintenance':
+        console.warn(`[a2a] 🔧 Maintenance notice: ${text}`);
+        break;
+
+      default:
+        // Log but don't warn for unknown types
+        if (kind) {
+          console.log(`[a2a] System message "${kind}": ${text}`);
+        }
+    }
+  }
+
   async stop(): Promise<void> {
     if (this.gopherhole) {
       this.gopherhole.disconnect();
@@ -297,53 +343,106 @@ export class A2AConnectionManager {
   }
 
   /**
-   * List available agents from GopherHole
-   * Fetches same-tenant agents + agents with approved access + public agents
+   * Make an A2A JSON-RPC call
    */
-  async listAvailableAgents(): Promise<Array<{
-    id: string;
-    name: string;
-    description?: string;
-    accessType: 'same-tenant' | 'public' | 'granted';
-  }>> {
+  private async a2aRpc<T>(method: string, params?: Record<string, unknown>): Promise<T | null> {
     if (!this.config.apiKey) {
-      return [];
+      return null;
     }
 
     const hubUrl = this.config.bridgeUrl || 'wss://hub.gopherhole.ai/ws';
-    // Convert wss:// to https:// for API calls
     const apiBase = hubUrl.replace('wss://', 'https://').replace('/ws', '');
 
     try {
-      const response = await fetch(`${apiBase}/api/agents/available`, {
+      const response = await fetch(`${apiBase}/a2a`, {
+        method: 'POST',
         headers: {
           'Authorization': `Bearer ${this.config.apiKey}`,
           'Content-Type': 'application/json',
         },
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          method,
+          params: params || {},
+          id: Date.now(),
+        }),
       });
 
       if (!response.ok) {
-        console.error(`[a2a] Failed to fetch agents: ${response.status}`);
-        return [];
+        console.error(`[a2a] RPC failed: ${response.status}`);
+        return null;
       }
 
-      const data = await response.json() as { agents: Array<{
-        id: string;
-        name: string;
-        description?: string;
-        access_type: string;
-      }> };
-
-      return data.agents.map(a => ({
-        id: a.id,
-        name: a.name,
-        description: a.description,
-        accessType: a.access_type as 'same-tenant' | 'public' | 'granted',
-      }));
+      const data = await response.json() as { result?: T; error?: { message: string } };
+      if (data.error) {
+        console.error(`[a2a] RPC error: ${data.error.message}`);
+        return null;
+      }
+
+      return data.result || null;
     } catch (err) {
-      console.error('[a2a] Error fetching available agents:', (err as Error).message);
+      console.error('[a2a] RPC error:', (err as Error).message);
+      return null;
+    }
+  }
+
+  /**
+   * List available agents from GopherHole (agents you have access to)
+   */
+  async listAvailableAgents(options?: { query?: string; public?: boolean }): Promise<Array<{
+    id: string;
+    name: string;
+    description?: string;
+    verified?: boolean;
+    accessType: 'same-tenant' | 'public' | 'granted';
+  }>> {
+    const result = await this.a2aRpc<{ agents: Array<{
+      id: string;
+      name: string;
+      description?: string;
+      verified?: boolean;
+      accessType: string;
+    }> }>('x-gopherhole/agents.available', options);
+
+    if (!result?.agents) {
       return [];
     }
+
+    return result.agents.map(a => ({
+      id: a.id,
+      name: a.name,
+      description: a.description,
+      verified: a.verified,
+      accessType: a.accessType as 'same-tenant' | 'public' | 'granted',
+    }));
+  }
+
+  /**
+   * Discover public agents in the marketplace
+   */
+  async discoverAgents(options?: { 
+    query?: string; 
+    category?: string;
+    verified?: boolean;
+    limit?: number;
+  }): Promise<Array<{
+    id: string;
+    name: string;
+    description?: string;
+    verified?: boolean;
+    tenantName?: string;
+    avgRating?: number;
+  }>> {
+    const result = await this.a2aRpc<{ agents: Array<{
+      id: string;
+      name: string;
+      description?: string;
+      verified?: boolean;
+      tenantName?: string;
+      avgRating?: number;
+    }> }>('x-gopherhole/agents.discover', options);
+
+    return result?.agents || [];
   }
 
   /**