gopherhole_openclaw_a2a 0.1.2

package/dist/src/gateway-client.js

@@ -0,0 +1,256 @@
+/**
+ * Gateway WebSocket Client
+ * Sends messages to the Clawdbot 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".
+ */
+import WebSocket from 'ws';
+import { v4 as uuidv4 } from 'uuid';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+let ws = null;
+let pendingRequests = new Map();
+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;
+    }
+}
+export async function connectToGateway(port = 18789) {
+    if (ws && connected && handshakeComplete)
+        return;
+    const token = getGatewayToken();
+    return new Promise((resolve, reject) => {
+        ws = new WebSocket(`ws://127.0.0.1:${port}`);
+        const timeout = setTimeout(() => {
+            ws?.terminate();
+            reject(new Error('Gateway connection timeout'));
+        }, 10000);
+        ws.on('open', () => {
+            console.log('[a2a] Connected to gateway WebSocket, sending handshake...');
+            connected = true;
+            // Send connect handshake
+            const connectId = uuidv4();
+            const connectFrame = {
+                type: 'req',
+                id: connectId,
+                method: 'connect',
+                params: {
+                    minProtocol: 3,
+                    maxProtocol: 3,
+                    client: {
+                        id: 'gateway-client',
+                        displayName: 'A2A Channel Plugin',
+                        version: '0.1.0',
+                        platform: process.platform,
+                        mode: 'backend',
+                    },
+                    caps: [],
+                    auth: token ? { token } : undefined,
+                    role: 'operator',
+                    scopes: ['operator.admin'],
+                },
+            };
+            pendingRequests.set(connectId, {
+                resolve: () => {
+                    clearTimeout(timeout);
+                    handshakeComplete = true;
+                    console.log('[a2a] Gateway handshake complete');
+                    resolve();
+                },
+                reject: (err) => {
+                    clearTimeout(timeout);
+                    reject(err);
+                },
+                timeout: setTimeout(() => {
+                    pendingRequests.delete(connectId);
+                    reject(new Error('Gateway handshake timeout'));
+                }, 5000),
+            });
+            ws.send(JSON.stringify(connectFrame));
+        });
+        ws.on('message', (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                // Log all non-tick messages for debugging
+                if (msg.type !== 'tick') {
+                    console.log(`[a2a] Gateway msg: type=${msg.type}, event=${msg.event ?? 'n/a'}, id=${msg.id ?? 'n/a'}`);
+                }
+                // Handle response frames (for RPC calls)
+                if (msg.type === 'res' && msg.id && pendingRequests.has(msg.id)) {
+                    const pending = pendingRequests.get(msg.id);
+                    clearTimeout(pending.timeout);
+                    pendingRequests.delete(msg.id);
+                    if (msg.error) {
+                        pending.reject(new Error(msg.error.message || 'RPC error'));
+                    }
+                    else {
+                        // Protocol uses 'payload' not 'result'
+                        pending.resolve(msg.payload);
+                    }
+                    return;
+                }
+                // Handle chat events (streaming responses)
+                if (msg.type === 'event' && msg.event === 'chat') {
+                    handleChatEvent(msg.payload);
+                    return;
+                }
+                // Handle tick frames (keepalive)
+                if (msg.type === 'tick') {
+                    // Could respond with tick ack if needed
+                }
+            }
+            catch (err) {
+                console.error('[a2a] Failed to parse gateway message:', err);
+            }
+        });
+        ws.on('close', () => {
+            connected = false;
+            handshakeComplete = false;
+            ws = null;
+            console.log('[a2a] Disconnected from gateway WebSocket');
+            // Reject all pending chats
+            for (const [runId, pending] of pendingChats) {
+                clearTimeout(pending.timeout);
+                pending.reject(new Error('Gateway connection closed'));
+            }
+            pendingChats.clear();
+        });
+        ws.on('error', (err) => {
+            clearTimeout(timeout);
+            console.error('[a2a] Gateway WebSocket error:', err.message);
+            reject(err);
+        });
+    });
+}
+function extractTextContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        // Content blocks array: [{ type: 'text', text: '...' }, ...]
+        return content
+            .filter((block) => typeof block === 'object' && block !== null &&
+            block.type === 'text')
+            .map((block) => block.text ?? '')
+            .join('');
+    }
+    if (typeof content === 'object' && content !== null) {
+        // Single content block or unknown structure
+        const obj = content;
+        if (obj.text && typeof obj.text === 'string') {
+            return obj.text;
+        }
+    }
+    return '';
+}
+function handleChatEvent(payload) {
+    const pending = pendingChats.get(payload.runId);
+    if (!pending) {
+        // Not a chat we're tracking
+        return;
+    }
+    console.log(`[a2a] Chat event: runId=${payload.runId}, state=${payload.state}, seq=${payload.seq}, content=${JSON.stringify(payload.message?.content)?.slice(0, 200)}`);
+    if (payload.state === 'delta') {
+        // Each delta contains the full message so far, not incremental
+        if (payload.message?.role === 'assistant' && payload.message?.content) {
+            const text = extractTextContent(payload.message.content);
+            if (text) {
+                pending.latestText = text;
+            }
+        }
+    }
+    else if (payload.state === 'final') {
+        // Final message - resolve with latest text
+        clearTimeout(pending.timeout);
+        pendingChats.delete(payload.runId);
+        // Use final content if available, otherwise use latest delta
+        if (payload.message?.role === 'assistant' && payload.message?.content) {
+            const text = extractTextContent(payload.message.content);
+            if (text) {
+                pending.latestText = text;
+            }
+        }
+        console.log(`[a2a] Chat complete: ${pending.latestText.slice(0, 100)}...`);
+        pending.resolve({ text: pending.latestText });
+    }
+    else if (payload.state === 'error' || payload.state === 'aborted') {
+        clearTimeout(pending.timeout);
+        pendingChats.delete(payload.runId);
+        pending.reject(new Error(payload.errorMessage || `Chat ${payload.state}`));
+    }
+}
+export async function callGateway(method, params, timeoutMs = 300000) {
+    if (!ws || !connected || !handshakeComplete) {
+        await connectToGateway();
+    }
+    const id = uuidv4();
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            pendingRequests.delete(id);
+            reject(new Error('Gateway request timeout'));
+        }, timeoutMs);
+        pendingRequests.set(id, { resolve, reject, timeout });
+        const frame = {
+            type: 'req',
+            id,
+            method,
+            params,
+        };
+        ws.send(JSON.stringify(frame));
+    });
+}
+/**
+ * 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) {
+    if (!ws || !connected || !handshakeComplete) {
+        await connectToGateway();
+    }
+    const idempotencyKey = uuidv4();
+    // First, send the chat.send request
+    console.log(`[a2a] Sending chat.send: sessionKey=${sessionKey}, idempotencyKey=${idempotencyKey}`);
+    const result = await callGateway('chat.send', {
+        sessionKey,
+        message,
+        idempotencyKey,
+    });
+    console.log(`[a2a] chat.send raw result:`, JSON.stringify(result));
+    if (!result.runId) {
+        throw new Error('chat.send did not return a runId');
+    }
+    // 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, {
+            resolve,
+            reject,
+            timeout,
+            latestText: '',
+        });
+    });
+}
+export function disconnectFromGateway() {
+    if (ws) {
+        ws.close();
+        ws = null;
+        connected = false;
+        handshakeComplete = false;
+    }
+    pendingChats.clear();
+    pendingRequests.clear();
+}

package/dist/src/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * A2A Protocol Types
+ * Compatible with MarketClaw's A2A implementation
+ */
+export interface A2AMessage {
+    type: 'message' | 'response' | 'chunk' | 'status';
+    taskId: string;
+    contextId?: string;
+    from?: string;
+    content?: {
+        parts: Array<{
+            kind: string;
+            text?: string;
+            data?: unknown;
+        }>;
+    };
+    status?: 'working' | 'completed' | 'failed' | 'canceled';
+    error?: string;
+}
+export interface A2AAgentCard {
+    id: string;
+    name: string;
+    description?: string;
+    skills?: string[];
+    url?: string;
+}
+export interface A2APendingRequest {
+    taskId: string;
+    resolve: (response: A2AResponse) => void;
+    reject: (error: Error) => void;
+    timeout: NodeJS.Timeout;
+    startedAt: number;
+}
+export interface A2AResponse {
+    text: string;
+    status: string;
+    from?: string;
+}
+export interface A2AChannelConfig {
+    enabled?: boolean;
+    agentId?: string;
+    agentName?: string;
+    bridgeUrl?: string;
+    agents?: Array<{
+        id: string;
+        url: string;
+        name?: string;
+    }>;
+    gopherhole?: {
+        enabled?: boolean;
+        apiKey: string;
+        hubUrl?: string;
+    };
+    auth?: {
+        token?: string;
+    };
+    reconnectIntervalMs?: number;
+    requestTimeoutMs?: number;
+}
+export interface ResolvedA2AAccount {
+    accountId: string;
+    name: string;
+    enabled: boolean;
+    configured: boolean;
+    agentId: string;
+    bridgeUrl: string | null;
+    agents: Array<{
+        id: string;
+        url: string;
+        name?: string;
+    }>;
+    config: A2AChannelConfig;
+}

package/dist/src/types.js

@@ -0,0 +1,5 @@
+/**
+ * A2A Protocol Types
+ * Compatible with MarketClaw's A2A implementation
+ */
+export {};

package/index.ts

@@ -0,0 +1,100 @@
+/**
+ * A2A Channel Plugin Entry Point
+ * Enables Clawdbot to communicate with other AI agents via A2A protocol
+ */
+
+import { a2aPlugin, setA2ARuntime, getA2AConnectionManager } from './src/channel.js';
+
+// 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: 'Message to send (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 manager = getA2AConnectionManager();
+        if (!manager) {
+          return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'A2A channel not running' }) }] };
+        }
+
+        if (action === 'list') {
+          const agents = manager.listAgents();
+          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' }) }] };
+          }
+          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';
+            
+            let response;
+            if (isDirectConnection) {
+              // Direct WebSocket connection to the agent
+              response = await manager.sendMessage(agentId, message);
+            } else if (isGopherHoleConnected) {
+              // Route through GopherHole hub
+              response = await manager.sendViaGopherHole(agentId, message);
+            } 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}` }) }] };
+      },
+    });
+  },
+};
+
+export default plugin;
+export { getA2AConnectionManager };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "gopherhole_openclaw_a2a",
+  "version": "0.1.2",
+  "description": "GopherHole A2A plugin for OpenClaw - connect your AI agent to the GopherHole network",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build"
+  },
+  "clawdbot": {
+    "id": "gopherhole_openclaw_a2a",
+    "extensions": [
+      "./dist/index.js"
+    ]
+  },
+  "keywords": [
+    "openclaw",
+    "clawdbot",
+    "a2a",
+    "gopherhole",
+    "agent",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/helixdata/gopherhole.git",
+    "directory": "clawdbot-plugin"
+  },
+  "homepage": "https://gopherhole.ai",
+  "license": "MIT",
+  "dependencies": {
+    "uuid": "^10.0.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "clawdbot": "*"
+  }
+}