gopherhole_openclaw_a2a 0.3.14 → 0.4.0

package/src/channel.ts

@@ -1,385 +0,0 @@
-/**
- * A2A Channel Plugin for OpenClaw
- * Enables communication with other AI agents via A2A protocol
- */
-
-// Use minimal type imports - mostly self-contained
-const DEFAULT_ACCOUNT_ID = 'default';
-function normalizeAccountId(id?: string): string {
-  return id?.trim()?.toLowerCase() || DEFAULT_ACCOUNT_ID;
-}
-
-import { A2AConnectionManager } from './connection.js';
-import { sendChatMessage, connectToGateway, disconnectFromGateway } from './gateway-client.js';
-import { a2aLog } from './logger.js';
-import type {
-  A2AMessage,
-  A2AChannelConfig,
-  ResolvedA2AAccount,
-} from './types.js';
-
-// Minimal runtime interface - what we actually need
-interface OpenClawRuntime {
-  handleInbound(params: {
-    channel: string;
-    chatId: string;
-    userId: string;
-    username?: string;
-    text: string;
-    isGroup: boolean;
-    metadata?: Record<string, unknown>;
-  }): Promise<{ text?: string } | null>;
-}
-
-// Runtime state
-let connectionManager: A2AConnectionManager | null = null;
-let currentRuntime: OpenClawRuntime | null = null;
-
-export function setA2ARuntime(runtime: unknown): void {
-  currentRuntime = runtime as OpenClawRuntime;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type OpenClawConfig = any;
-
-// Minimal channel plugin interfaces (self-contained)
-interface ChannelAccountSnapshot {
-  accountId: string;
-  name: string;
-  enabled: boolean;
-  configured: boolean;
-  [key: string]: unknown;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type ChannelPlugin<T = any> = {
-  id: string;
-  meta: unknown;
-  capabilities: unknown;
-  reload?: unknown;
-  config: {
-    listAccountIds: (cfg: unknown) => string[];
-    resolveAccount: (cfg: unknown, accountId?: string) => T;
-    defaultAccountId: (cfg: unknown) => string;
-    setAccountEnabled: (opts: { cfg: unknown; accountId?: string; enabled: boolean }) => unknown;
-    deleteAccount: (opts: { cfg: unknown; accountId: string }) => unknown;
-    isConfigured: (account: T) => boolean;
-    describeAccount: (account: T) => ChannelAccountSnapshot;
-    resolveAllowFrom: (opts: { cfg: unknown; accountId?: string }) => string[];
-    formatAllowFrom: (opts: { allowFrom: string[] }) => string[];
-  };
-  security?: unknown;
-  messaging?: unknown;
-  setup?: unknown;
-  outbound?: unknown;
-  status?: unknown;
-  gateway?: {
-    startAccount: (ctx: {
-      account: T;
-      cfg: unknown;
-      accountId: string;
-      runtime: unknown;
-      abortSignal?: AbortSignal;
-      setStatus: (status: Record<string, unknown>) => void;
-      log?: { info: (...args: unknown[]) => void; error: (...args: unknown[]) => void };
-    }) => Promise<(() => Promise<void>) | void>;
-  };
-};
-
-function resolveA2AConfig(cfg: OpenClawConfig): A2AChannelConfig {
-  return cfg?.channels?.a2a ?? {};
-}
-
-function resolveA2AAccount(opts: {
-  cfg: OpenClawConfig;
-  accountId?: string;
-}): ResolvedA2AAccount {
-  const config = resolveA2AConfig(opts.cfg);
-  const accountId = opts.accountId ?? DEFAULT_ACCOUNT_ID;
-
-  return {
-    accountId,
-    name: config.agentName ?? 'A2A',
-    enabled: config.enabled ?? false,
-    configured: !!(config.bridgeUrl && config.apiKey),
-    agentId: config.agentId ?? 'openclaw',
-    bridgeUrl: config.bridgeUrl ?? null,
-    config,
-  };
-}
-
-const meta = {
-  id: 'a2a',
-  label: 'A2A',
-  selectionLabel: 'A2A (Agent-to-Agent)',
-  detailLabel: 'A2A Protocol',
-  docsPath: '/channels/a2a',
-  docsLabel: 'a2a',
-  blurb: 'Communicate with other AI agents via GopherHole A2A protocol.',
-  systemImage: 'bubble.left.and.bubble.right',
-  aliases: ['agent2agent', 'gopherhole'],
-  order: 200,
-};
-
-export const a2aPlugin: ChannelPlugin<ResolvedA2AAccount> = {
-  id: 'a2a',
-  meta,
-  capabilities: {
-    chatTypes: ['direct'],
-    media: false,      // Text-only for now
-    reactions: false,
-    edit: false,
-    unsend: false,
-    reply: false,
-  },
-  reload: { configPrefixes: ['channels.a2a'] },
-  config: {
-    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
-    resolveAccount: (cfg, accountId) =>
-      resolveA2AAccount({ cfg: cfg as OpenClawConfig, accountId }),
-    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-    setAccountEnabled: ({ cfg, enabled }) => {
-      const next = cfg as OpenClawConfig;
-      return {
-        ...next,
-        channels: {
-          ...next.channels,
-          a2a: {
-            ...(next.channels as Record<string, unknown>)?.a2a as object,
-            enabled,
-          },
-        },
-      } as OpenClawConfig;
-    },
-    deleteAccount: ({ cfg }) => cfg as OpenClawConfig,
-    isConfigured: (account) => account.configured,
-    describeAccount: (account): ChannelAccountSnapshot => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-    }),
-    resolveAllowFrom: () => [],
-    formatAllowFrom: ({ allowFrom }) => allowFrom,
-  },
-  security: {
-    resolveDmPolicy: ({ account }) => ({
-      policy: 'open',  // A2A connections are pre-configured, no pairing needed
-      allowFrom: [],
-      policyPath: 'channels.a2a.dmPolicy',
-      allowFromPath: 'channels.a2a.',
-      approveHint: '',
-      normalizeEntry: (raw) => raw,
-    }),
-    collectWarnings: () => [],
-  },
-  messaging: {
-    normalizeTarget: (target) => target?.trim() ?? '',
-    targetResolver: {
-      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 OpenClawConfig,
-    validateInput: ({ input }) => {
-      if (!input.httpUrl && !input.customArgs) {
-        return 'A2A requires --http-url (bridge URL) or bridgeUrl + apiKey in config.';
-      }
-      return null;
-    },
-    applyAccountConfig: ({ cfg, input }) => {
-      const next = cfg as OpenClawConfig;
-      return {
-        ...next,
-        channels: {
-          ...next.channels,
-          a2a: {
-            ...(next.channels as Record<string, unknown>)?.a2a as object,
-            enabled: true,
-            ...(input.httpUrl ? { bridgeUrl: input.httpUrl } : {}),
-          },
-        },
-      } as OpenClawConfig;
-    },
-  },
-  outbound: {
-    deliveryMode: 'direct',
-    textChunkLimit: 10000,
-    resolveTarget: ({ to }) => {
-      const trimmed = to?.trim();
-      if (!trimmed) {
-        return {
-          ok: false,
-          error: new Error('A2A requires --to <agentId>'),
-        };
-      }
-      return { ok: true, to: trimmed };
-    },
-    sendText: async ({ to, text }) => {
-      if (!connectionManager) {
-        return { channel: 'a2a', success: false, error: 'A2A not connected' };
-      }
-      try {
-        const response = await connectionManager.sendMessage(to, text);
-        return {
-          channel: 'a2a',
-          success: true,
-          messageId: response.status,
-          response: response.text,
-        };
-      } catch (err) {
-        return {
-          channel: 'a2a',
-          success: false,
-          error: (err as Error).message,
-        };
-      }
-    },
-  },
-  status: {
-    defaultRuntime: {
-      accountId: DEFAULT_ACCOUNT_ID,
-      running: false,
-      lastStartAt: null,
-      lastStopAt: null,
-      lastError: null,
-    },
-    collectStatusIssues: () => [],
-    buildChannelSummary: ({ snapshot }) => ({
-      configured: snapshot.configured ?? false,
-      running: snapshot.running ?? false,
-      lastStartAt: snapshot.lastStartAt ?? null,
-      lastStopAt: snapshot.lastStopAt ?? null,
-      lastError: snapshot.lastError ?? null,
-    }),
-    probeAccount: async () => ({ ok: connectionManager !== null }),
-    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: connectionStatus.some((a) => a.connected),
-        hubStatus: connectionStatus,
-        availableAgents,
-        lastStartAt: runtime?.lastStartAt ?? null,
-        lastStopAt: runtime?.lastStopAt ?? null,
-        lastError: runtime?.lastError ?? null,
-      };
-    },
-  },
-  gateway: {
-    startAccount: async (ctx) => {
-      const account = ctx.account;
-      const config = account.config;
-
-      ctx.log?.info(`[a2a] Starting A2A channel`);
-      ctx.setStatus({ accountId: account.accountId });
-
-      connectionManager = new A2AConnectionManager(config);
-
-      // Set up message handler for incoming messages
-      connectionManager.setMessageHandler(async (agentId: string, message: A2AMessage) => {
-        if (message.type === 'message' && message.from) {
-          const text = message.content?.parts
-            ?.filter((p) => p.kind === 'text')
-            .map((p) => p.text)
-            .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 {
-            // Use chat.send to route the message through the agent
-            // Session key format: agent:<agentId>:<channel>:<chatId>
-            const sessionKey = `agent:main:a2a:${message.from}`;
-            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) {
-              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) {
-            a2aLog.error('handler_error', (err as Error).message, { taskId: message.taskId, stack: (err as Error).stack });
-            connectionManager?.sendResponseViaGopherHole(
-              message.from,
-              message.taskId,
-              `Error: ${(err as Error).message}`,
-              message.contextId
-            );
-          }
-        }
-      });
-
-      await connectionManager.start();
-
-      ctx.setStatus({
-        accountId: account.accountId,
-        running: true,
-        lastStartAt: Date.now(),
-      });
-
-      ctx.log?.info(`[a2a] A2A channel started`);
-
-      // Return cleanup function
-      return async () => {
-        ctx.log?.info(`[a2a] Stopping A2A channel`);
-        await connectionManager?.stop();
-        connectionManager = null;
-        ctx.setStatus({
-          accountId: account.accountId,
-          running: false,
-          lastStopAt: Date.now(),
-        });
-      };
-    },
-  },
-};
-
-/**
- * Get the connection manager for direct access (e.g., from tools)
- */
-export function getA2AConnectionManager(): A2AConnectionManager | null {
-  return connectionManager;
-}

package/src/connection.test.ts

@@ -1,298 +0,0 @@
-/**
- * Unit tests for OpenClaw plugin discovery methods
- * Tests the new discovery params: tag, skillTag, contentMode, sort, offset, scope
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { A2AConnectionManager } from './connection';
-
-// Mock fetch
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-
-// Mock @gopherhole/sdk
-vi.mock('@gopherhole/sdk', () => ({
-  GopherHole: vi.fn().mockImplementation(() => ({
-    connect: vi.fn(),
-    disconnect: vi.fn(),
-    on: vi.fn(),
-    connected: false,
-    id: null,
-  })),
-  getTaskResponseText: vi.fn(),
-}));
-
-describe('A2AConnectionManager Discovery', () => {
-  let manager: A2AConnectionManager;
-  const mockApiKey = 'gph_test_key';
-
-  beforeEach(() => {
-    manager = new A2AConnectionManager({
-      enabled: true,
-      apiKey: mockApiKey,
-      bridgeUrl: 'wss://test.gopherhole.ai/ws',
-    });
-    mockFetch.mockReset();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  const mockDiscoverResponse = {
-    agents: [
-      {
-        id: 'agent-1',
-        name: 'Test Agent',
-        description: 'A test agent',
-        verified: true,
-        tenantName: 'TestTenant',
-        avgRating: 4.5,
-      },
-    ],
-  };
-
-  const setupMockRpcResponse = (result: any) => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: () => Promise.resolve({ result }),
-    });
-  };
-
-  describe('discoverAgents() with new params', () => {
-    it('should call discover with tag param', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-
-      await manager.discoverAgents({ tag: 'ai' });
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          method: 'POST',
-          body: expect.stringContaining('"tag":"ai"'),
-        })
-      );
-    });
-
-    it('should call discover with skillTag param', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-
-      await manager.discoverAgents({ skillTag: 'nlp' });
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          body: expect.stringContaining('"skillTag":"nlp"'),
-        })
-      );
-    });
-
-    it('should call discover with contentMode param', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-
-      await manager.discoverAgents({ contentMode: 'text/markdown' });
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          body: expect.stringContaining('"contentMode":"text/markdown"'),
-        })
-      );
-    });
-
-    it('should call discover with sort param', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-
-      await manager.discoverAgents({ sort: 'rating' });
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          body: expect.stringContaining('"sort":"rating"'),
-        })
-      );
-    });
-
-    it('should call discover with offset param', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-
-      await manager.discoverAgents({ offset: 20 });
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          body: expect.stringContaining('"offset":20'),
-        })
-      );
-    });
-
-    it('should call discover with scope=tenant', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-
-      await manager.discoverAgents({ scope: 'tenant' });
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          body: expect.stringContaining('"scope":"tenant"'),
-        })
-      );
-    });
-  });
-
-  describe('discoverAgents() with combined params', () => {
-    it('should combine multiple new params', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-
-      await manager.discoverAgents({
-        tag: 'ai',
-        skillTag: 'nlp',
-        sort: 'popular',
-        offset: 10,
-      });
-
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.params.tag).toBe('ai');
-      expect(body.params.skillTag).toBe('nlp');
-      expect(body.params.sort).toBe('popular');
-      expect(body.params.offset).toBe(10);
-    });
-
-    it('should combine query with new params', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-
-      await manager.discoverAgents({
-        query: 'weather',
-        tag: 'api',
-        contentMode: 'application/json',
-        sort: 'recent',
-        limit: 25,
-      });
-
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.params.query).toBe('weather');
-      expect(body.params.tag).toBe('api');
-      expect(body.params.contentMode).toBe('application/json');
-      expect(body.params.sort).toBe('recent');
-      expect(body.params.limit).toBe(25);
-    });
-  });
-
-  describe('discoverAgents() edge cases', () => {
-    it('should handle empty results', async () => {
-      setupMockRpcResponse({ agents: [] });
-
-      const result = await manager.discoverAgents({ tag: 'nonexistent' });
-
-      expect(result).toHaveLength(0);
-    });
-
-    it('should handle RPC errors gracefully', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: () => Promise.resolve({ error: { message: 'Not found' } }),
-      });
-
-      const result = await manager.discoverAgents({ tag: 'test' });
-
-      expect(result).toEqual([]);
-    });
-
-    it('should handle network errors', async () => {
-      mockFetch.mockRejectedValueOnce(new Error('Network error'));
-
-      const result = await manager.discoverAgents({ tag: 'test' });
-
-      expect(result).toEqual([]);
-    });
-
-    it('should return empty array when apiKey not configured', async () => {
-      const managerNoKey = new A2AConnectionManager({
-        enabled: true,
-        // No apiKey
-      });
-
-      const result = await managerNoKey.discoverAgents({ tag: 'test' });
-
-      expect(result).toEqual([]);
-      expect(mockFetch).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('discoverAgents() sort values', () => {
-    it('should accept rating sort', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-      await manager.discoverAgents({ sort: 'rating' });
-      
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.params.sort).toBe('rating');
-    });
-
-    it('should accept popular sort', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-      await manager.discoverAgents({ sort: 'popular' });
-      
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.params.sort).toBe('popular');
-    });
-
-    it('should accept recent sort', async () => {
-      setupMockRpcResponse(mockDiscoverResponse);
-      await manager.discoverAgents({ sort: 'recent' });
-      
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.params.sort).toBe('recent');
-    });
-  });
-
-  describe('discoverAgents() response mapping', () => {
-    it('should map response correctly', async () => {
-      setupMockRpcResponse({
-        agents: [
-          {
-            id: 'agent-1',
-            name: 'Test Agent',
-            description: 'A test agent',
-            verified: true,
-            tenantName: 'TestTenant',
-            avgRating: 4.5,
-          },
-        ],
-      });
-
-      const result = await manager.discoverAgents({ query: 'test' });
-
-      expect(result).toEqual([
-        {
-          id: 'agent-1',
-          name: 'Test Agent',
-          description: 'A test agent',
-          verified: true,
-          tenantName: 'TestTenant',
-          avgRating: 4.5,
-        },
-      ]);
-    });
-  });
-
-  describe('listAvailableAgents()', () => {
-    it('should list available agents', async () => {
-      setupMockRpcResponse({
-        agents: [
-          {
-            id: 'agent-1',
-            name: 'Test Agent',
-            description: 'A test agent',
-            verified: true,
-            accessType: 'same-tenant',
-          },
-        ],
-      });
-
-      const result = await manager.listAvailableAgents();
-
-      expect(result).toHaveLength(1);
-      expect(result[0].accessType).toBe('same-tenant');
-    });
-  });
-});