gopherhole_openclaw_a2a 0.1.3 → 0.2.0

package/dist/index.js

@@ -3,6 +3,8 @@
  * Enables Clawdbot to communicate with other AI agents via A2A protocol
  */
 import { a2aPlugin, setA2ARuntime, getA2AConnectionManager } from './src/channel.js';
+import { readFileSync } from 'fs';
+import { extname } from 'path';
 const plugin = {
     id: 'gopherhole_openclaw_a2a',
     name: 'A2A Protocol',
@@ -29,7 +31,11 @@ const plugin = {
                     },
                     message: {
                         type: 'string',
-                        description: 'Message to send (for send action)',
+                        description: 'Text message to send (for send action)',
+                    },
+                    image: {
+                        type: 'string',
+                        description: 'Path to image file to send (for send action)',
                     },
                 },
                 required: ['action'],
@@ -38,6 +44,7 @@ const plugin = {
                 const action = params.action;
                 const agentId = params.agentId;
                 const message = params.message;
+                const imagePath = params.image;
                 const manager = getA2AConnectionManager();
                 if (!manager) {
                     return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'A2A channel not running' }) }] };
@@ -47,22 +54,52 @@ const plugin = {
                     return { content: [{ type: 'text', text: JSON.stringify({ status: 'ok', agents }) }] };
                 }
                 if (action === 'send') {
-                    if (!agentId || !message) {
-                        return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'agentId and message required for send action' }) }] };
+                    if (!agentId || (!message && !imagePath)) {
+                        return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'agentId and (message or image) required for send action' }) }] };
                     }
                     try {
-                        // Use sendViaGopherHole for remote agents (routes through the hub)
-                        // Use sendMessage for direct connections
                         const isGopherHoleConnected = manager.isGopherHoleConnected();
                         const isDirectConnection = manager.isConnected(agentId) && agentId !== 'gopherhole';
+                        // Build parts array
+                        const parts = [];
+                        // Add text part if message provided
+                        if (message) {
+                            parts.push({ kind: 'text', text: message });
+                        }
+                        // Add image part if image path provided
+                        if (imagePath) {
+                            try {
+                                const imageData = readFileSync(imagePath);
+                                const base64Data = imageData.toString('base64');
+                                const ext = extname(imagePath).toLowerCase();
+                                const mimeTypes = {
+                                    '.png': 'image/png',
+                                    '.jpg': 'image/jpeg',
+                                    '.jpeg': 'image/jpeg',
+                                    '.gif': 'image/gif',
+                                    '.webp': 'image/webp',
+                                    '.svg': 'image/svg+xml',
+                                };
+                                const mimeType = mimeTypes[ext] || 'application/octet-stream';
+                                parts.push({ kind: 'image', data: base64Data, mimeType });
+                            }
+                            catch (imgErr) {
+                                return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: `Failed to read image: ${imgErr.message}` }) }] };
+                            }
+                        }
                         let response;
                         if (isDirectConnection) {
-                            // Direct WebSocket connection to the agent
-                            response = await manager.sendMessage(agentId, message);
+                            // 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
-                            response = await manager.sendViaGopherHole(agentId, message);
+                            // 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` }) }] };

package/dist/src/connection.d.ts

@@ -1,54 +1,55 @@
 /**
  * A2A Connection Manager
- * Handles WebSocket connections to other agents and the bridge
+ * Uses @gopherhole/sdk for GopherHole hub connectivity
  */
+import { GopherHole } from '@gopherhole/sdk';
 import type { A2AMessage, A2AResponse, A2AChannelConfig } from './types.js';
 export type MessageHandler = (agentId: string, message: A2AMessage) => Promise<void>;
 export declare class A2AConnectionManager {
-    private connections;
-    private pendingRequests;
-    private reconnectTimers;
+    private gopherhole;
     private messageHandler;
     private config;
     private agentId;
+    private connected;
     constructor(config: A2AChannelConfig);
     setMessageHandler(handler: MessageHandler): void;
     start(): Promise<void>;
     private connectToGopherHole;
-    private establishGopherHoleConnection;
+    private handleIncomingMessage;
     stop(): Promise<void>;
-    private connectToAgent;
-    private establishConnection;
-    private sendAgentAnnounce;
-    private scheduleReconnect;
-    private handleMessage;
     /**
-     * Resolve a GopherHole task response - extract text from artifacts
+     * Send a message to another agent via GopherHole and wait for response
      */
-    private resolveGopherHoleTask;
+    sendMessage(targetAgentId: string, text: string, _contextId?: string): Promise<A2AResponse>;
     /**
-     * Send a message to another agent and wait for response
+     * Send a multi-part message via GopherHole hub
+     * Supports text, images, and other MIME types
      */
-    sendMessage(agentId: string, text: string, contextId?: string): Promise<A2AResponse>;
+    sendPartsViaGopherHole(targetAgentId: string, parts: Array<{
+        kind: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>, contextId?: string): Promise<A2AResponse>;
     /**
-     * Send a response to an incoming message
+     * Send a response to an incoming message via GopherHole
+     * Uses SDK's respond() method to complete the original task
      */
-    sendResponse(agentId: string, taskId: string, text: string, contextId?: string): void;
+    sendResponseViaGopherHole(_targetAgentId: string, taskId: string, text: string, _contextId?: string): void;
     /**
-     * Send a response to an agent via GopherHole (for replying to incoming messages)
+     * Legacy alias for sendPartsViaGopherHole with text-only
      */
-    sendResponseViaGopherHole(targetAgentId: string, taskId: string, text: string, contextId?: string): void;
+    sendViaGopherHole(targetAgentId: string, text: string, contextId?: string): Promise<A2AResponse>;
     /**
-     * Send a message to a remote agent via GopherHole
-     * Note: targetAgentId must be the actual agent ID (e.g., "agent-70153299")
+     * Legacy sendResponse (routes to GopherHole)
      */
-    sendViaGopherHole(targetAgentId: string, text: string, contextId?: string): Promise<A2AResponse>;
+    sendResponse(agentId: string, taskId: string, text: string, contextId?: string): void;
     /**
      * Check if GopherHole is connected
      */
     isGopherHoleConnected(): boolean;
     /**
-     * List connected agents
+     * List connected agents (just GopherHole for now)
      */
     listAgents(): Array<{
         id: string;
@@ -59,4 +60,8 @@ export declare class A2AConnectionManager {
      * Check if an agent is connected
      */
     isConnected(agentId: string): boolean;
+    /**
+     * Get the underlying GopherHole SDK instance (for advanced usage)
+     */
+    getSDK(): GopherHole | null;
 }