gopherhole_openclaw_a2a 0.3.1 → 0.3.3

package/A2A-FIX-GUIDE.md

@@ -0,0 +1,122 @@
+# 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/dist/index.js

@@ -55,8 +55,13 @@ const plugin = {
                     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 }) }] };
+                    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)) {

package/dist/src/channel.js

@@ -9,6 +9,7 @@ function normalizeAccountId(id) {
 }
 import { A2AConnectionManager } from './connection.js';
 import { sendChatMessage } from './gateway-client.js';
+import { a2aLog } from './logger.js';
 // Runtime state
 let connectionManager = null;
 let currentRuntime = null;
@@ -212,21 +213,41 @@ export const a2aPlugin = {
                         .join('\n') ?? '';
                     if (!text)
                         return;
+                    // Log incoming message
+                    a2aLog.messageReceived(message.from, message.taskId, text);
+                    // Validate taskId early
+                    if (!message.taskId || message.taskId.startsWith('gph-')) {
+                        a2aLog.error('taskid_invalid', `Invalid taskId "${message.taskId}" - response relay will fail!`, { from: message.from });
+                    }
                     // 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
                         // Session key format: agent:<agentId>:<channel>:<chatId>
                         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 via GopherHole
+                        a2aLog.messageProcessing(message.taskId, sessionKey);
+                        // Add A2A context so the agent knows to relay its full response
+                        const a2aContext = `[A2A Request from agent "${message.from}"]\n\n${text}\n\n[Note: Your complete response will be sent back to the requesting agent. Include all relevant information in your reply.]`;
+                        const response = await sendChatMessage(sessionKey, a2aContext);
+                        // Log captured response
                         if (response?.text) {
-                            connectionManager?.sendResponseViaGopherHole(message.from, message.taskId, response.text, message.contextId);
+                            a2aLog.responseCaptured(message.taskId, response.text);
+                        }
+                        else {
+                            a2aLog.error('response_empty', 'No response text captured from agent', { taskId: message.taskId });
+                        }
+                        // Send response back to the agent via GopherHole
+                        if (response?.text && response.text.trim()) {
+                            const sent = connectionManager?.sendResponseViaGopherHole(message.from, message.taskId, response.text, message.contextId);
+                            a2aLog.responseSent(message.taskId || 'unknown', message.from, true);
+                        }
+                        else {
+                            a2aLog.error('response_relay_failed', 'No response text to relay', { taskId: message.taskId });
+                            connectionManager?.sendResponseViaGopherHole(message.from, message.taskId, `[No response generated]`, message.contextId);
+                            a2aLog.responseSent(message.taskId || 'unknown', message.from, false);
                         }
                     }
                     catch (err) {
-                        ctx.log?.error(`[a2a] Error handling message:`, err);
+                        a2aLog.error('handler_error', err.message, { taskId: message.taskId, stack: err.stack });
                         connectionManager?.sendResponseViaGopherHole(message.from, message.taskId, `Error: ${err.message}`, message.contextId);
                     }
                 }

package/dist/src/connection.js

@@ -102,6 +102,12 @@ export class A2AConnectionManager {
         if (!this.messageHandler)
             return;
         console.log(`[a2a] Received message from ${message.from}, taskId=${message.taskId}`);
+        console.log(`[a2a] Raw message payload:`, JSON.stringify(message.payload, null, 2).slice(0, 500));
+        // Validate taskId - critical for response routing
+        if (!message.taskId) {
+            console.error(`[a2a] WARNING: No taskId in incoming message! Response relay will fail.`);
+            console.error(`[a2a] Full message object:`, JSON.stringify(message, null, 2));
+        }
         // Convert SDK message to our A2AMessage format
         const a2aMsg = {
             type: 'message',
@@ -116,6 +122,7 @@ export class A2AConnectionManager {
                 })),
             },
         };
+        console.log(`[a2a] Dispatching to messageHandler with taskId=${a2aMsg.taskId}`);
         this.messageHandler('gopherhole', a2aMsg).catch((err) => {
             console.error('[a2a] Error handling incoming message:', err);
         });
@@ -181,16 +188,27 @@ export class A2AConnectionManager {
      */
     sendResponseViaGopherHole(_targetAgentId, taskId, text, _contextId) {
         if (!this.gopherhole || !this.connected) {
-            console.warn('[a2a] Cannot send response - GopherHole not connected');
+            console.error('[a2a] Cannot send response - GopherHole not connected');
+            return;
+        }
+        // Validate taskId
+        if (!taskId) {
+            console.error('[a2a] Cannot respond - taskId is null/undefined!');
+            return;
+        }
+        if (taskId.startsWith('gph-')) {
+            console.error(`[a2a] Cannot respond - taskId "${taskId}" is a fallback ID (not a real task). Response will be lost!`);
             return;
         }
-        console.log(`[a2a] Responding to taskId=${taskId}: ${text.slice(0, 100)}...`);
+        console.log(`[a2a] Responding to taskId=${taskId}: "${text.slice(0, 200)}..." (total ${text.length} chars)`);
         try {
             // Use SDK's respond method to complete the task
             this.gopherhole.respond(taskId, text);
+            console.log(`[a2a] respond() called successfully for taskId=${taskId}`);
         }
         catch (err) {
             console.error('[a2a] Failed to send response:', err.message);
+            console.error('[a2a] Error details:', err);
         }
     }
     /**

package/dist/src/gateway-client.js

@@ -160,15 +160,23 @@ function handleChatEvent(payload) {
         // 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)}`);
+    // Detailed logging for debugging relay issues
+    console.log(`[a2a] Chat event: runId=${payload.runId}, state=${payload.state}, seq=${payload.seq}, role=${payload.message?.role}`);
+    if (payload.state === 'delta' || payload.state === 'final') {
+        console.log(`[a2a] Chat content (${payload.state}): ${JSON.stringify(payload.message?.content)?.slice(0, 300)}`);
+    }
     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;
+                console.log(`[a2a] Updated latestText (delta): "${text.slice(0, 100)}..." (len=${text.length})`);
             }
         }
+        else {
+            console.log(`[a2a] Skipping delta - role=${payload.message?.role}, hasContent=${!!payload.message?.content}`);
+        }
     }
     else if (payload.state === 'final') {
         // Final message - resolve with latest text
@@ -179,14 +187,16 @@ function handleChatEvent(payload) {
             const text = extractTextContent(payload.message.content);
             if (text) {
                 pending.latestText = text;
+                console.log(`[a2a] Updated latestText (final): "${text.slice(0, 100)}..." (len=${text.length})`);
             }
         }
-        console.log(`[a2a] Chat complete: ${pending.latestText.slice(0, 100)}...`);
+        console.log(`[a2a] Chat complete - resolving with: "${pending.latestText.slice(0, 150)}..." (total ${pending.latestText.length} chars)`);
         pending.resolve({ text: pending.latestText });
     }
     else if (payload.state === 'error' || payload.state === 'aborted') {
         clearTimeout(pending.timeout);
         pendingChats.delete(payload.runId);
+        console.error(`[a2a] Chat ${payload.state}: ${payload.errorMessage}`);
         pending.reject(new Error(payload.errorMessage || `Chat ${payload.state}`));
     }
 }

package/dist/src/logger.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A2A Plugin Logger
+ * Writes to both console and a dedicated log file for dashboard viewing
+ */
+export interface A2ALogEntry {
+    timestamp: string;
+    level: 'info' | 'warn' | 'error' | 'debug';
+    event: string;
+    taskId?: string;
+    from?: string;
+    to?: string;
+    message?: string;
+    data?: Record<string, unknown>;
+}
+export declare const a2aLog: {
+    info(event: string, message: string, data?: Record<string, unknown>): void;
+    warn(event: string, message: string, data?: Record<string, unknown>): void;
+    error(event: string, message: string, data?: Record<string, unknown>): void;
+    messageReceived(from: string, taskId: string | undefined, text: string): void;
+    messageProcessing(taskId: string | undefined, sessionKey: string): void;
+    responseCaptured(taskId: string | undefined, text: string): void;
+    responseSent(taskId: string, to: string, success: boolean): void;
+};
+export declare const A2A_LOG_FILE_PATH: string;

package/dist/src/logger.js

@@ -0,0 +1,94 @@
+/**
+ * A2A Plugin Logger
+ * Writes to both console and a dedicated log file for dashboard viewing
+ */
+import { appendFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const LOG_DIR = join(homedir(), '.clawdbot', 'logs');
+const A2A_LOG_FILE = join(LOG_DIR, 'a2a.log');
+// Ensure log directory exists
+try {
+    if (!existsSync(LOG_DIR)) {
+        mkdirSync(LOG_DIR, { recursive: true });
+    }
+}
+catch {
+    // Ignore if we can't create the directory
+}
+function writeLog(entry) {
+    const line = JSON.stringify(entry) + '\n';
+    // Console output (colored)
+    const prefix = `[a2a:${entry.event}]`;
+    const msg = entry.message || '';
+    switch (entry.level) {
+        case 'error':
+            console.error(prefix, msg, entry.data || '');
+            break;
+        case 'warn':
+            console.warn(prefix, msg, entry.data || '');
+            break;
+        default:
+            console.log(prefix, msg, entry.data || '');
+    }
+    // File output (JSON lines)
+    try {
+        appendFileSync(A2A_LOG_FILE, line);
+    }
+    catch {
+        // Ignore file write errors
+    }
+}
+export const a2aLog = {
+    info(event, message, data) {
+        writeLog({ timestamp: new Date().toISOString(), level: 'info', event, message, data });
+    },
+    warn(event, message, data) {
+        writeLog({ timestamp: new Date().toISOString(), level: 'warn', event, message, data });
+    },
+    error(event, message, data) {
+        writeLog({ timestamp: new Date().toISOString(), level: 'error', event, message, data });
+    },
+    // Structured event logging for dashboard
+    messageReceived(from, taskId, text) {
+        writeLog({
+            timestamp: new Date().toISOString(),
+            level: 'info',
+            event: 'message_received',
+            from,
+            taskId,
+            message: text.slice(0, 200),
+            data: { textLength: text.length },
+        });
+    },
+    messageProcessing(taskId, sessionKey) {
+        writeLog({
+            timestamp: new Date().toISOString(),
+            level: 'info',
+            event: 'message_processing',
+            taskId,
+            data: { sessionKey },
+        });
+    },
+    responseCaptured(taskId, text) {
+        writeLog({
+            timestamp: new Date().toISOString(),
+            level: 'info',
+            event: 'response_captured',
+            taskId,
+            message: text.slice(0, 200),
+            data: { textLength: text.length },
+        });
+    },
+    responseSent(taskId, to, success) {
+        writeLog({
+            timestamp: new Date().toISOString(),
+            level: success ? 'info' : 'error',
+            event: 'response_sent',
+            taskId,
+            to,
+            data: { success },
+        });
+    },
+};
+export const A2A_LOG_FILE_PATH = A2A_LOG_FILE;

package/index.ts

@@ -72,8 +72,13 @@ const plugin = {
         }
 
         if (action === 'list') {
-          const agents = manager.listAgents();
-          return { content: [{ type: 'text', text: JSON.stringify({ status: 'ok', agents }) }] };
+          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') {

package/package.json

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

package/src/channel.ts

@@ -11,6 +11,7 @@ function normalizeAccountId(id?: string): string {
 
 import { A2AConnectionManager } from './connection.js';
 import { sendChatMessage, connectToGateway, disconnectFromGateway } from './gateway-client.js';
+import { a2aLog } from './logger.js';
 import type {
   A2AMessage,
   A2AChannelConfig,
@@ -293,28 +294,54 @@ export const a2aPlugin: ChannelPlugin<ResolvedA2AAccount> = {
 
           if (!text) return;
 
+          // Log incoming message
+          a2aLog.messageReceived(message.from, message.taskId, text);
+
+          // Validate taskId early
+          if (!message.taskId || message.taskId.startsWith('gph-')) {
+            a2aLog.error('taskid_invalid', `Invalid taskId "${message.taskId}" - response relay will fail!`, { from: message.from });
+          }
+
           // 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
             // Session key format: agent:<agentId>:<channel>:<chatId>
             const sessionKey = `agent:main:a2a:${message.from}`;
-            const response = await sendChatMessage(sessionKey, text);
+            a2aLog.messageProcessing(message.taskId, sessionKey);
+            
+            // Add A2A context so the agent knows to relay its full response
+            const a2aContext = `[A2A Request from agent "${message.from}"]\n\n${text}\n\n[Note: Your complete response will be sent back to the requesting agent. Include all relevant information in your reply.]`;
+            
+            const response = await sendChatMessage(sessionKey, a2aContext);
 
-            ctx.log?.info(`[a2a] chat.send returned: ${response ? `text=${response.text?.slice(0, 50)}...` : 'null'}`);
+            // Log captured response
+            if (response?.text) {
+              a2aLog.responseCaptured(message.taskId, response.text);
+            } else {
+              a2aLog.error('response_empty', 'No response text captured from agent', { taskId: message.taskId });
+            }
 
             // Send response back to the agent via GopherHole
-            if (response?.text) {
-              connectionManager?.sendResponseViaGopherHole(
+            if (response?.text && response.text.trim()) {
+              const sent = connectionManager?.sendResponseViaGopherHole(
                 message.from,
                 message.taskId,
                 response.text,
                 message.contextId
               );
+              a2aLog.responseSent(message.taskId || 'unknown', message.from, true);
+            } else {
+              a2aLog.error('response_relay_failed', 'No response text to relay', { taskId: message.taskId });
+              connectionManager?.sendResponseViaGopherHole(
+                message.from,
+                message.taskId,
+                `[No response generated]`,
+                message.contextId
+              );
+              a2aLog.responseSent(message.taskId || 'unknown', message.from, false);
             }
           } catch (err) {
-            ctx.log?.error(`[a2a] Error handling message:`, err);
+            a2aLog.error('handler_error', (err as Error).message, { taskId: message.taskId, stack: (err as Error).stack });
             connectionManager?.sendResponseViaGopherHole(
               message.from,
               message.taskId,

package/src/connection.ts

@@ -122,6 +122,13 @@ export class A2AConnectionManager {
     if (!this.messageHandler) return;
 
     console.log(`[a2a] Received message from ${message.from}, taskId=${message.taskId}`);
+    console.log(`[a2a] Raw message payload:`, JSON.stringify(message.payload, null, 2).slice(0, 500));
+
+    // Validate taskId - critical for response routing
+    if (!message.taskId) {
+      console.error(`[a2a] WARNING: No taskId in incoming message! Response relay will fail.`);
+      console.error(`[a2a] Full message object:`, JSON.stringify(message, null, 2));
+    }
 
     // Convert SDK message to our A2AMessage format
     const a2aMsg: A2AMessage = {
@@ -138,6 +145,8 @@ export class A2AConnectionManager {
       },
     };
 
+    console.log(`[a2a] Dispatching to messageHandler with taskId=${a2aMsg.taskId}`);
+
     this.messageHandler('gopherhole', a2aMsg).catch((err) => {
       console.error('[a2a] Error handling incoming message:', err);
     });
@@ -230,17 +239,30 @@ export class A2AConnectionManager {
     _contextId?: string
   ): void {
     if (!this.gopherhole || !this.connected) {
-      console.warn('[a2a] Cannot send response - GopherHole not connected');
+      console.error('[a2a] Cannot send response - GopherHole not connected');
+      return;
+    }
+
+    // Validate taskId
+    if (!taskId) {
+      console.error('[a2a] Cannot respond - taskId is null/undefined!');
+      return;
+    }
+    
+    if (taskId.startsWith('gph-')) {
+      console.error(`[a2a] Cannot respond - taskId "${taskId}" is a fallback ID (not a real task). Response will be lost!`);
       return;
     }
 
-    console.log(`[a2a] Responding to taskId=${taskId}: ${text.slice(0, 100)}...`);
+    console.log(`[a2a] Responding to taskId=${taskId}: "${text.slice(0, 200)}..." (total ${text.length} chars)`);
 
     try {
       // Use SDK's respond method to complete the task
       this.gopherhole.respond(taskId, text);
+      console.log(`[a2a] respond() called successfully for taskId=${taskId}`);
     } catch (err) {
       console.error('[a2a] Failed to send response:', (err as Error).message);
+      console.error('[a2a] Error details:', err);
     }
   }
 

package/src/gateway-client.ts

@@ -201,7 +201,12 @@ function handleChatEvent(payload: {
     return;
   }
 
-  console.log(`[a2a] Chat event: runId=${payload.runId}, state=${payload.state}, seq=${payload.seq}, content=${JSON.stringify(payload.message?.content)?.slice(0, 200)}`);
+  // Detailed logging for debugging relay issues
+  console.log(`[a2a] Chat event: runId=${payload.runId}, state=${payload.state}, seq=${payload.seq}, role=${payload.message?.role}`);
+  
+  if (payload.state === 'delta' || payload.state === 'final') {
+    console.log(`[a2a] Chat content (${payload.state}): ${JSON.stringify(payload.message?.content)?.slice(0, 300)}`);
+  }
 
   if (payload.state === 'delta') {
     // Each delta contains the full message so far, not incremental
@@ -209,7 +214,10 @@ function handleChatEvent(payload: {
       const text = extractTextContent(payload.message.content);
       if (text) {
         pending.latestText = text;
+        console.log(`[a2a] Updated latestText (delta): "${text.slice(0, 100)}..." (len=${text.length})`);
       }
+    } else {
+      console.log(`[a2a] Skipping delta - role=${payload.message?.role}, hasContent=${!!payload.message?.content}`);
     }
   } else if (payload.state === 'final') {
     // Final message - resolve with latest text
@@ -221,14 +229,16 @@ function handleChatEvent(payload: {
       const text = extractTextContent(payload.message.content);
       if (text) {
         pending.latestText = text;
+        console.log(`[a2a] Updated latestText (final): "${text.slice(0, 100)}..." (len=${text.length})`);
       }
     }
     
-    console.log(`[a2a] Chat complete: ${pending.latestText.slice(0, 100)}...`);
+    console.log(`[a2a] Chat complete - resolving with: "${pending.latestText.slice(0, 150)}..." (total ${pending.latestText.length} chars)`);
     pending.resolve({ text: pending.latestText });
   } else if (payload.state === 'error' || payload.state === 'aborted') {
     clearTimeout(pending.timeout);
     pendingChats.delete(payload.runId);
+    console.error(`[a2a] Chat ${payload.state}: ${payload.errorMessage}`);
     pending.reject(new Error(payload.errorMessage || `Chat ${payload.state}`));
   }
 }

package/src/logger.ts

@@ -0,0 +1,118 @@
+/**
+ * A2A Plugin Logger
+ * Writes to both console and a dedicated log file for dashboard viewing
+ */
+
+import { appendFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const LOG_DIR = join(homedir(), '.clawdbot', 'logs');
+const A2A_LOG_FILE = join(LOG_DIR, 'a2a.log');
+
+// Ensure log directory exists
+try {
+  if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true });
+  }
+} catch {
+  // Ignore if we can't create the directory
+}
+
+export interface A2ALogEntry {
+  timestamp: string;
+  level: 'info' | 'warn' | 'error' | 'debug';
+  event: string;
+  taskId?: string;
+  from?: string;
+  to?: string;
+  message?: string;
+  data?: Record<string, unknown>;
+}
+
+function writeLog(entry: A2ALogEntry): void {
+  const line = JSON.stringify(entry) + '\n';
+  
+  // Console output (colored)
+  const prefix = `[a2a:${entry.event}]`;
+  const msg = entry.message || '';
+  
+  switch (entry.level) {
+    case 'error':
+      console.error(prefix, msg, entry.data || '');
+      break;
+    case 'warn':
+      console.warn(prefix, msg, entry.data || '');
+      break;
+    default:
+      console.log(prefix, msg, entry.data || '');
+  }
+  
+  // File output (JSON lines)
+  try {
+    appendFileSync(A2A_LOG_FILE, line);
+  } catch {
+    // Ignore file write errors
+  }
+}
+
+export const a2aLog = {
+  info(event: string, message: string, data?: Record<string, unknown>): void {
+    writeLog({ timestamp: new Date().toISOString(), level: 'info', event, message, data });
+  },
+  
+  warn(event: string, message: string, data?: Record<string, unknown>): void {
+    writeLog({ timestamp: new Date().toISOString(), level: 'warn', event, message, data });
+  },
+  
+  error(event: string, message: string, data?: Record<string, unknown>): void {
+    writeLog({ timestamp: new Date().toISOString(), level: 'error', event, message, data });
+  },
+  
+  // Structured event logging for dashboard
+  messageReceived(from: string, taskId: string | undefined, text: string): void {
+    writeLog({
+      timestamp: new Date().toISOString(),
+      level: 'info',
+      event: 'message_received',
+      from,
+      taskId,
+      message: text.slice(0, 200),
+      data: { textLength: text.length },
+    });
+  },
+  
+  messageProcessing(taskId: string | undefined, sessionKey: string): void {
+    writeLog({
+      timestamp: new Date().toISOString(),
+      level: 'info',
+      event: 'message_processing',
+      taskId,
+      data: { sessionKey },
+    });
+  },
+  
+  responseCaptured(taskId: string | undefined, text: string): void {
+    writeLog({
+      timestamp: new Date().toISOString(),
+      level: 'info',
+      event: 'response_captured',
+      taskId,
+      message: text.slice(0, 200),
+      data: { textLength: text.length },
+    });
+  },
+  
+  responseSent(taskId: string, to: string, success: boolean): void {
+    writeLog({
+      timestamp: new Date().toISOString(),
+      level: success ? 'info' : 'error',
+      event: 'response_sent',
+      taskId,
+      to,
+      data: { success },
+    });
+  },
+};
+
+export const A2A_LOG_FILE_PATH = A2A_LOG_FILE;