gopherhole_openclaw_a2a 0.2.8 → 0.3.1

package/dist/src/channel.d.ts

@@ -1,5 +1,5 @@
 /**
- * A2A Channel Plugin for Clawdbot
+ * A2A Channel Plugin for OpenClaw
  * Enables communication with other AI agents via A2A protocol
  */
 import { A2AConnectionManager } from './connection.js';

package/dist/src/channel.js

@@ -1,5 +1,5 @@
 /**
- * A2A Channel Plugin for Clawdbot
+ * A2A Channel Plugin for OpenClaw
  * Enables communication with other AI agents via A2A protocol
  */
 // Use minimal type imports - mostly self-contained
@@ -25,10 +25,9 @@ function resolveA2AAccount(opts) {
         accountId,
         name: config.agentName ?? 'A2A',
         enabled: config.enabled ?? false,
-        configured: !!(config.bridgeUrl || (config.agents && config.agents.length > 0) || config.gopherhole?.enabled),
-        agentId: config.agentId ?? 'clawdbot',
+        configured: !!(config.bridgeUrl && config.apiKey),
+        agentId: config.agentId ?? 'openclaw',
         bridgeUrl: config.bridgeUrl ?? null,
-        agents: config.agents ?? [],
         config,
     };
 }
@@ -39,9 +38,9 @@ const meta = {
     detailLabel: 'A2A Protocol',
     docsPath: '/channels/a2a',
     docsLabel: 'a2a',
-    blurb: 'Communicate with other AI agents via A2A protocol.',
+    blurb: 'Communicate with other AI agents via GopherHole A2A protocol.',
     systemImage: 'bubble.left.and.bubble.right',
-    aliases: ['agent2agent'],
+    aliases: ['agent2agent', 'gopherhole'],
     order: 200,
 };
 export const a2aPlugin = {
@@ -98,8 +97,8 @@ export const a2aPlugin = {
     messaging: {
         normalizeTarget: (target) => target?.trim() ?? '',
         targetResolver: {
-            looksLikeId: (id) => /^[a-z0-9_-]+$/i.test(id),
-            hint: '<agentId>',
+            looksLikeId: (id) => /^[a-z0-9_@-]+$/i.test(id),
+            hint: '<agentId> (e.g. @memory, @echo)',
         },
         formatTargetDisplay: ({ target }) => target ?? '',
     },
@@ -108,7 +107,7 @@ export const a2aPlugin = {
         applyAccountName: ({ cfg }) => cfg,
         validateInput: ({ input }) => {
             if (!input.httpUrl && !input.customArgs) {
-                return 'A2A requires --http-url (bridge URL) or agents configured in config.';
+                return 'A2A requires --http-url (bridge URL) or bridgeUrl + apiKey in config.';
             }
             return null;
         },
@@ -179,16 +178,18 @@ export const a2aPlugin = {
             lastError: snapshot.lastError ?? null,
         }),
         probeAccount: async () => ({ ok: connectionManager !== null }),
-        buildAccountSnapshot: ({ account, runtime }) => {
-            const agents = connectionManager?.listAgents() ?? [];
+        buildAccountSnapshot: async ({ account, runtime }) => {
+            const connectionStatus = connectionManager?.listAgents() ?? [];
+            const availableAgents = await connectionManager?.listAvailableAgents() ?? [];
             return {
                 accountId: account.accountId,
                 name: account.name,
                 enabled: account.enabled,
                 configured: account.configured,
                 running: runtime?.running ?? false,
-                connected: agents.some((a) => a.connected),
-                agents,
+                connected: connectionStatus.some((a) => a.connected),
+                hubStatus: connectionStatus,
+                availableAgents,
                 lastStartAt: runtime?.lastStartAt ?? null,
                 lastStopAt: runtime?.lastStopAt ?? null,
                 lastError: runtime?.lastError ?? null,
@@ -211,7 +212,7 @@ export const a2aPlugin = {
                         .join('\n') ?? '';
                     if (!text)
                         return;
-                    // Route to Clawdbot's reply pipeline via gateway JSON-RPC
+                    // Route to OpenClaw's reply pipeline via gateway JSON-RPC
                     try {
                         ctx.log?.info(`[a2a] Routing message from ${message.from}: "${text.slice(0, 100)}..."`);
                         // Use chat.send to route the message through the agent
@@ -219,26 +220,14 @@ export const a2aPlugin = {
                         const sessionKey = `agent:main:a2a:${message.from}`;
                         const response = await sendChatMessage(sessionKey, text);
                         ctx.log?.info(`[a2a] chat.send returned: ${response ? `text=${response.text?.slice(0, 50)}...` : 'null'}`);
-                        // Send response back to the agent
+                        // Send response back to the agent via GopherHole
                         if (response?.text) {
-                            // If message came via GopherHole, route response back through it
-                            if (agentId === 'gopherhole' && message.from) {
-                                connectionManager?.sendResponseViaGopherHole(message.from, message.taskId, response.text, message.contextId);
-                            }
-                            else {
-                                connectionManager?.sendResponse(agentId, message.taskId, response.text, message.contextId);
-                            }
+                            connectionManager?.sendResponseViaGopherHole(message.from, message.taskId, response.text, message.contextId);
                         }
                     }
                     catch (err) {
                         ctx.log?.error(`[a2a] Error handling message:`, err);
-                        // If message came via GopherHole, route error back through it
-                        if (agentId === 'gopherhole' && message.from) {
-                            connectionManager?.sendResponseViaGopherHole(message.from, message.taskId, `Error: ${err.message}`, message.contextId);
-                        }
-                        else {
-                            connectionManager?.sendResponse(agentId, message.taskId, `Error: ${err.message}`, message.contextId);
-                        }
+                        connectionManager?.sendResponseViaGopherHole(message.from, message.taskId, `Error: ${err.message}`, message.contextId);
                     }
                 }
             });

package/dist/src/connection.d.ts

@@ -49,7 +49,17 @@ export declare class A2AConnectionManager {
      */
     isGopherHoleConnected(): boolean;
     /**
-     * List connected agents (just GopherHole for now)
+     * List available agents from GopherHole
+     * Fetches same-tenant agents + agents with approved access + public agents
+     */
+    listAvailableAgents(): Promise<Array<{
+        id: string;
+        name: string;
+        description?: string;
+        accessType: 'same-tenant' | 'public' | 'granted';
+    }>>;
+    /**
+     * List connection status (for backward compatibility)
      */
     listAgents(): Array<{
         id: string;

package/dist/src/connection.js

@@ -11,30 +11,29 @@ export class A2AConnectionManager {
     connected = false;
     constructor(config) {
         this.config = config;
-        this.agentId = config.agentId ?? 'clawdbot';
+        this.agentId = config.agentId ?? 'openclaw';
     }
     setMessageHandler(handler) {
         this.messageHandler = handler;
     }
     async start() {
-        // Connect to GopherHole if configured
-        if (this.config.gopherhole?.enabled && this.config.gopherhole?.apiKey) {
+        // Connect to GopherHole if configured (flat config: enabled + apiKey)
+        if (this.config.enabled && this.config.apiKey) {
             await this.connectToGopherHole();
         }
     }
     async connectToGopherHole() {
-        const gphConfig = this.config.gopherhole;
-        const hubUrl = gphConfig.hubUrl || 'wss://gopherhole.ai/ws';
+        const hubUrl = this.config.bridgeUrl || 'wss://gopherhole.ai/ws';
         const timeoutMs = this.config.requestTimeoutMs ?? 180000;
         this.gopherhole = new GopherHole({
-            apiKey: gphConfig.apiKey,
+            apiKey: this.config.apiKey,
             hubUrl,
             autoReconnect: true,
             reconnectDelay: this.config.reconnectIntervalMs ?? 5000,
             maxReconnectAttempts: 20,
             requestTimeout: timeoutMs,
             messageTimeout: timeoutMs,
-            agentCard: gphConfig.agentCard ?? {
+            agentCard: this.config.agentCard ?? {
                 name: this.config.agentName ?? 'OpenClaw',
                 description: 'Personal AI assistant with tools, web search, browser control, and various skills',
                 version: '0.1.0',
@@ -213,7 +212,42 @@ export class A2AConnectionManager {
         return this.connected && this.gopherhole?.connected === true;
     }
     /**
-     * List connected agents (just GopherHole for now)
+     * List available agents from GopherHole
+     * Fetches same-tenant agents + agents with approved access + public agents
+     */
+    async listAvailableAgents() {
+        if (!this.config.apiKey) {
+            return [];
+        }
+        const hubUrl = this.config.bridgeUrl || 'wss://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`, {
+                headers: {
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                console.error(`[a2a] Failed to fetch agents: ${response.status}`);
+                return [];
+            }
+            const data = await response.json();
+            return data.agents.map(a => ({
+                id: a.id,
+                name: a.name,
+                description: a.description,
+                accessType: a.access_type,
+            }));
+        }
+        catch (err) {
+            console.error('[a2a] Error fetching available agents:', err.message);
+            return [];
+        }
+    }
+    /**
+     * List connection status (for backward compatibility)
      */
     listAgents() {
         const agents = [];

package/dist/src/types.d.ts

@@ -39,26 +39,27 @@ export interface A2AResponse {
     status: string;
     from?: string;
 }
+/**
+ * A2A Channel Config (flat structure)
+ *
+ * Example:
+ * {
+ *   "channels": {
+ *     "a2a": {
+ *       "enabled": true,
+ *       "bridgeUrl": "wss://gopherhole.ai/ws",
+ *       "apiKey": "gph_your_api_key"
+ *     }
+ *   }
+ * }
+ */
 export interface A2AChannelConfig {
     enabled?: boolean;
+    bridgeUrl?: string;
+    apiKey?: string;
     agentId?: string;
     agentName?: string;
-    bridgeUrl?: string;
-    agents?: Array<{
-        id: string;
-        url: string;
-        name?: string;
-    }>;
-    gopherhole?: {
-        enabled?: boolean;
-        apiKey: string;
-        hubUrl?: string;
-        requestTimeoutMs?: number;
-        agentCard?: A2AAgentCard;
-    };
-    auth?: {
-        token?: string;
-    };
+    agentCard?: A2AAgentCard;
     reconnectIntervalMs?: number;
     requestTimeoutMs?: number;
 }
@@ -69,10 +70,5 @@ export interface ResolvedA2AAccount {
     configured: boolean;
     agentId: string;
     bridgeUrl: string | null;
-    agents: Array<{
-        id: string;
-        url: string;
-        name?: string;
-    }>;
     config: A2AChannelConfig;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gopherhole_openclaw_a2a",
-  "version": "0.2.8",
+  "version": "0.3.1",
   "description": "GopherHole A2A plugin for OpenClaw - connect your AI agent to the GopherHole network",
   "type": "module",
   "main": "dist/index.js",

package/src/channel.ts

@@ -1,5 +1,5 @@
 /**
- * A2A Channel Plugin for Clawdbot
+ * A2A Channel Plugin for OpenClaw
  * Enables communication with other AI agents via A2A protocol
  */
 
@@ -18,7 +18,7 @@ import type {
 } from './types.js';
 
 // Minimal runtime interface - what we actually need
-interface ClawdbotRuntime {
+interface OpenClawRuntime {
   handleInbound(params: {
     channel: string;
     chatId: string;
@@ -32,14 +32,14 @@ interface ClawdbotRuntime {
 
 // Runtime state
 let connectionManager: A2AConnectionManager | null = null;
-let currentRuntime: ClawdbotRuntime | null = null;
+let currentRuntime: OpenClawRuntime | null = null;
 
 export function setA2ARuntime(runtime: unknown): void {
-  currentRuntime = runtime as ClawdbotRuntime;
+  currentRuntime = runtime as OpenClawRuntime;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-type ClawdbotConfig = any;
+type OpenClawConfig = any;
 
 // Minimal channel plugin interfaces (self-contained)
 interface ChannelAccountSnapshot {
@@ -85,12 +85,12 @@ type ChannelPlugin<T = any> = {
   };
 };
 
-function resolveA2AConfig(cfg: ClawdbotConfig): A2AChannelConfig {
+function resolveA2AConfig(cfg: OpenClawConfig): A2AChannelConfig {
   return cfg?.channels?.a2a ?? {};
 }
 
 function resolveA2AAccount(opts: {
-  cfg: ClawdbotConfig;
+  cfg: OpenClawConfig;
   accountId?: string;
 }): ResolvedA2AAccount {
   const config = resolveA2AConfig(opts.cfg);
@@ -100,10 +100,9 @@ function resolveA2AAccount(opts: {
     accountId,
     name: config.agentName ?? 'A2A',
     enabled: config.enabled ?? false,
-    configured: !!(config.bridgeUrl || (config.agents && config.agents.length > 0) || config.gopherhole?.enabled),
-    agentId: config.agentId ?? 'clawdbot',
+    configured: !!(config.bridgeUrl && config.apiKey),
+    agentId: config.agentId ?? 'openclaw',
     bridgeUrl: config.bridgeUrl ?? null,
-    agents: config.agents ?? [],
     config,
   };
 }
@@ -115,9 +114,9 @@ const meta = {
   detailLabel: 'A2A Protocol',
   docsPath: '/channels/a2a',
   docsLabel: 'a2a',
-  blurb: 'Communicate with other AI agents via A2A protocol.',
+  blurb: 'Communicate with other AI agents via GopherHole A2A protocol.',
   systemImage: 'bubble.left.and.bubble.right',
-  aliases: ['agent2agent'],
+  aliases: ['agent2agent', 'gopherhole'],
   order: 200,
 };
 
@@ -136,10 +135,10 @@ export const a2aPlugin: ChannelPlugin<ResolvedA2AAccount> = {
   config: {
     listAccountIds: () => [DEFAULT_ACCOUNT_ID],
     resolveAccount: (cfg, accountId) =>
-      resolveA2AAccount({ cfg: cfg as ClawdbotConfig, accountId }),
+      resolveA2AAccount({ cfg: cfg as OpenClawConfig, accountId }),
     defaultAccountId: () => DEFAULT_ACCOUNT_ID,
     setAccountEnabled: ({ cfg, enabled }) => {
-      const next = cfg as ClawdbotConfig;
+      const next = cfg as OpenClawConfig;
       return {
         ...next,
         channels: {
@@ -149,9 +148,9 @@ export const a2aPlugin: ChannelPlugin<ResolvedA2AAccount> = {
             enabled,
           },
         },
-      } as ClawdbotConfig;
+      } as OpenClawConfig;
     },
-    deleteAccount: ({ cfg }) => cfg as ClawdbotConfig,
+    deleteAccount: ({ cfg }) => cfg as OpenClawConfig,
     isConfigured: (account) => account.configured,
     describeAccount: (account): ChannelAccountSnapshot => ({
       accountId: account.accountId,
@@ -176,22 +175,22 @@ export const a2aPlugin: ChannelPlugin<ResolvedA2AAccount> = {
   messaging: {
     normalizeTarget: (target) => target?.trim() ?? '',
     targetResolver: {
-      looksLikeId: (id) => /^[a-z0-9_-]+$/i.test(id),
-      hint: '<agentId>',
+      looksLikeId: (id) => /^[a-z0-9_@-]+$/i.test(id),
+      hint: '<agentId> (e.g. @memory, @echo)',
     },
     formatTargetDisplay: ({ target }) => target ?? '',
   },
   setup: {
     resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
-    applyAccountName: ({ cfg }) => cfg as ClawdbotConfig,
+    applyAccountName: ({ cfg }) => cfg as OpenClawConfig,
     validateInput: ({ input }) => {
       if (!input.httpUrl && !input.customArgs) {
-        return 'A2A requires --http-url (bridge URL) or agents configured in config.';
+        return 'A2A requires --http-url (bridge URL) or bridgeUrl + apiKey in config.';
       }
       return null;
     },
     applyAccountConfig: ({ cfg, input }) => {
-      const next = cfg as ClawdbotConfig;
+      const next = cfg as OpenClawConfig;
       return {
         ...next,
         channels: {
@@ -202,7 +201,7 @@ export const a2aPlugin: ChannelPlugin<ResolvedA2AAccount> = {
             ...(input.httpUrl ? { bridgeUrl: input.httpUrl } : {}),
           },
         },
-      } as ClawdbotConfig;
+      } as OpenClawConfig;
     },
   },
   outbound: {
@@ -256,16 +255,18 @@ export const a2aPlugin: ChannelPlugin<ResolvedA2AAccount> = {
       lastError: snapshot.lastError ?? null,
     }),
     probeAccount: async () => ({ ok: connectionManager !== null }),
-    buildAccountSnapshot: ({ account, runtime }) => {
-      const agents = connectionManager?.listAgents() ?? [];
+    buildAccountSnapshot: async ({ account, runtime }) => {
+      const connectionStatus = connectionManager?.listAgents() ?? [];
+      const availableAgents = await connectionManager?.listAvailableAgents() ?? [];
       return {
         accountId: account.accountId,
         name: account.name,
         enabled: account.enabled,
         configured: account.configured,
         running: runtime?.running ?? false,
-        connected: agents.some((a) => a.connected),
-        agents,
+        connected: connectionStatus.some((a) => a.connected),
+        hubStatus: connectionStatus,
+        availableAgents,
         lastStartAt: runtime?.lastStartAt ?? null,
         lastStopAt: runtime?.lastStopAt ?? null,
         lastError: runtime?.lastError ?? null,
@@ -292,7 +293,7 @@ export const a2aPlugin: ChannelPlugin<ResolvedA2AAccount> = {
 
           if (!text) return;
 
-          // Route to Clawdbot's reply pipeline via gateway JSON-RPC
+          // Route to OpenClaw's reply pipeline via gateway JSON-RPC
           try {
             ctx.log?.info(`[a2a] Routing message from ${message.from}: "${text.slice(0, 100)}..."`);
             
@@ -303,43 +304,23 @@ export const a2aPlugin: ChannelPlugin<ResolvedA2AAccount> = {
 
             ctx.log?.info(`[a2a] chat.send returned: ${response ? `text=${response.text?.slice(0, 50)}...` : 'null'}`);
 
-            // Send response back to the agent
+            // Send response back to the agent via GopherHole
             if (response?.text) {
-              // If message came via GopherHole, route response back through it
-              if (agentId === 'gopherhole' && message.from) {
-                connectionManager?.sendResponseViaGopherHole(
-                  message.from,
-                  message.taskId,
-                  response.text,
-                  message.contextId
-                );
-              } else {
-                connectionManager?.sendResponse(
-                  agentId,
-                  message.taskId,
-                  response.text,
-                  message.contextId
-                );
-              }
-            }
-          } catch (err) {
-            ctx.log?.error(`[a2a] Error handling message:`, err);
-            // If message came via GopherHole, route error back through it
-            if (agentId === 'gopherhole' && message.from) {
               connectionManager?.sendResponseViaGopherHole(
                 message.from,
                 message.taskId,
-                `Error: ${(err as Error).message}`,
-                message.contextId
-              );
-            } else {
-              connectionManager?.sendResponse(
-                agentId,
-                message.taskId,
-                `Error: ${(err as Error).message}`,
+                response.text,
                 message.contextId
               );
             }
+          } catch (err) {
+            ctx.log?.error(`[a2a] Error handling message:`, err);
+            connectionManager?.sendResponseViaGopherHole(
+              message.from,
+              message.taskId,
+              `Error: ${(err as Error).message}`,
+              message.contextId
+            );
           }
         }
       });

package/src/connection.ts

@@ -22,7 +22,7 @@ export class A2AConnectionManager {
 
   constructor(config: A2AChannelConfig) {
     this.config = config;
-    this.agentId = config.agentId ?? 'clawdbot';
+    this.agentId = config.agentId ?? 'openclaw';
   }
 
   setMessageHandler(handler: MessageHandler): void {
@@ -30,26 +30,25 @@ export class A2AConnectionManager {
   }
 
   async start(): Promise<void> {
-    // Connect to GopherHole if configured
-    if (this.config.gopherhole?.enabled && this.config.gopherhole?.apiKey) {
+    // Connect to GopherHole if configured (flat config: enabled + apiKey)
+    if (this.config.enabled && this.config.apiKey) {
       await this.connectToGopherHole();
     }
   }
 
   private async connectToGopherHole(): Promise<void> {
-    const gphConfig = this.config.gopherhole!;
-    const hubUrl = gphConfig.hubUrl || 'wss://gopherhole.ai/ws';
+    const hubUrl = this.config.bridgeUrl || 'wss://gopherhole.ai/ws';
     const timeoutMs = this.config.requestTimeoutMs ?? 180000;
 
     this.gopherhole = new GopherHole({
-      apiKey: gphConfig.apiKey,
+      apiKey: this.config.apiKey!,
       hubUrl,
       autoReconnect: true,
       reconnectDelay: this.config.reconnectIntervalMs ?? 5000,
       maxReconnectAttempts: 20,
       requestTimeout: timeoutMs,
       messageTimeout: timeoutMs,
-      agentCard: gphConfig.agentCard ?? {
+      agentCard: this.config.agentCard ?? {
         name: this.config.agentName ?? 'OpenClaw',
         description: 'Personal AI assistant with tools, web search, browser control, and various skills',
         version: '0.1.0',
@@ -271,7 +270,57 @@ export class A2AConnectionManager {
   }
 
   /**
-   * List connected agents (just GopherHole for now)
+   * List available agents from GopherHole
+   * Fetches same-tenant agents + agents with approved access + public agents
+   */
+  async listAvailableAgents(): Promise<Array<{
+    id: string;
+    name: string;
+    description?: string;
+    accessType: 'same-tenant' | 'public' | 'granted';
+  }>> {
+    if (!this.config.apiKey) {
+      return [];
+    }
+
+    const hubUrl = this.config.bridgeUrl || 'wss://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`, {
+        headers: {
+          'Authorization': `Bearer ${this.config.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+      });
+
+      if (!response.ok) {
+        console.error(`[a2a] Failed to fetch agents: ${response.status}`);
+        return [];
+      }
+
+      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',
+      }));
+    } catch (err) {
+      console.error('[a2a] Error fetching available agents:', (err as Error).message);
+      return [];
+    }
+  }
+
+  /**
+   * List connection status (for backward compatibility)
    */
   listAgents(): Array<{ id: string; name: string; connected: boolean }> {
     const agents: Array<{ id: string; name: string; connected: boolean }> = [];

package/src/types.ts

@@ -39,28 +39,29 @@ export interface A2AResponse {
   from?: string;
 }
 
+/**
+ * A2A Channel Config (flat structure)
+ * 
+ * Example:
+ * {
+ *   "channels": {
+ *     "a2a": {
+ *       "enabled": true,
+ *       "bridgeUrl": "wss://gopherhole.ai/ws",
+ *       "apiKey": "gph_your_api_key"
+ *     }
+ *   }
+ * }
+ */
 export interface A2AChannelConfig {
   enabled?: boolean;
-  agentId?: string;        // Our agent ID (default: "clawdbot")
-  agentName?: string;      // Display name
-  bridgeUrl?: string;      // Legacy: direct bridge URL (ws://...)
-  agents?: Array<{         // Legacy: direct agent connections
-    id: string;
-    url: string;
-    name?: string;
-  }>;
-  gopherhole?: {           // GopherHole Agent Hub connection
-    enabled?: boolean;
-    apiKey: string;
-    hubUrl?: string;       // Default: wss://gopherhole.ai/ws
-    requestTimeoutMs?: number;
-    agentCard?: A2AAgentCard;  // Custom agent card (overrides defaults)
-  };
-  auth?: {
-    token?: string;
-  };
-  reconnectIntervalMs?: number;
-  requestTimeoutMs?: number;
+  bridgeUrl?: string;           // WebSocket URL (default: wss://gopherhole.ai/ws)
+  apiKey?: string;              // GopherHole API key (gph_...)
+  agentId?: string;             // Our agent ID (default: "openclaw")
+  agentName?: string;           // Display name for agent card
+  agentCard?: A2AAgentCard;     // Custom agent card (overrides defaults)
+  reconnectIntervalMs?: number; // Reconnect delay (default: 5000)
+  requestTimeoutMs?: number;    // Request timeout (default: 180000)
 }
 
 export interface ResolvedA2AAccount {
@@ -70,6 +71,5 @@ export interface ResolvedA2AAccount {
   configured: boolean;
   agentId: string;
   bridgeUrl: string | null;
-  agents: Array<{ id: string; url: string; name?: string }>;
   config: A2AChannelConfig;
 }