gopherhole_openclaw_a2a 0.3.12 → 0.3.14

package/dist/index.js

@@ -141,6 +141,69 @@ const plugin = {
                 return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: `Unknown action: ${action}` }) }] };
             },
         });
+        // Register a tool for location-based agent discovery
+        api.registerTool?.({
+            name: 'a2a_discover_nearby',
+            description: 'Find A2A agents near a geographic location',
+            parameters: {
+                type: 'object',
+                properties: {
+                    lat: {
+                        type: 'number',
+                        description: 'Latitude of search center',
+                    },
+                    lng: {
+                        type: 'number',
+                        description: 'Longitude of search center',
+                    },
+                    radius: {
+                        type: 'number',
+                        description: 'Search radius in kilometers (default: 10, max: 500)',
+                    },
+                    tag: {
+                        type: 'string',
+                        description: 'Filter by tag (e.g., "retail", "food")',
+                    },
+                    category: {
+                        type: 'string',
+                        description: 'Filter by category',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of results (default: 20, max: 50)',
+                    },
+                },
+                required: ['lat', 'lng'],
+            },
+            execute: async (_id, params) => {
+                const lat = params.lat;
+                const lng = params.lng;
+                const radius = params.radius;
+                const tag = params.tag;
+                const category = params.category;
+                const limit = params.limit;
+                const manager = getA2AConnectionManager();
+                if (!manager) {
+                    return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'A2A channel not running' }) }] };
+                }
+                if (!manager.isGopherHoleConnected()) {
+                    return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'Not connected to GopherHole' }) }] };
+                }
+                try {
+                    const agents = await manager.discoverNearby({ lat, lng, radius, tag, category, limit });
+                    return { content: [{ type: 'text', text: JSON.stringify({
+                                    status: 'ok',
+                                    center: { lat, lng },
+                                    radius: radius || 10,
+                                    count: agents.length,
+                                    agents
+                                }) }] };
+                }
+                catch (err) {
+                    return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: err.message }) }] };
+                }
+            },
+        });
     },
 };
 export default plugin;

package/dist/src/connection.d.ts

@@ -80,6 +80,7 @@ export declare class A2AConnectionManager {
         skillTag?: string;
         contentMode?: string;
         sort?: string;
+        owner?: string;
         verified?: boolean;
         limit?: number;
         offset?: number;
@@ -92,6 +93,32 @@ export declare class A2AConnectionManager {
         tenantName?: string;
         avgRating?: number;
     }>>;
+    /**
+     * Discover agents near a geographic location
+     */
+    discoverNearby(options: {
+        lat: number;
+        lng: number;
+        radius?: number;
+        tag?: string;
+        category?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Array<{
+        id: string;
+        name: string;
+        description?: string;
+        verified?: boolean;
+        tenantName?: string;
+        avgRating?: number;
+        location?: {
+            name: string;
+            lat: number;
+            lng: number;
+            country: string;
+        };
+        distance?: number;
+    }>>;
     /**
      * List connection status (for backward compatibility)
      */

package/dist/src/connection.js

@@ -333,6 +333,13 @@ export class A2AConnectionManager {
         const result = await this.a2aRpc('x-gopherhole/agents.discover', options);
         return result?.agents || [];
     }
+    /**
+     * Discover agents near a geographic location
+     */
+    async discoverNearby(options) {
+        const result = await this.a2aRpc('x-gopherhole/agents.discover.nearby', options);
+        return result?.agents || [];
+    }
     /**
      * List connection status (for backward compatibility)
      */

package/dist/src/connection.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for OpenClaw plugin discovery methods
+ * Tests the new discovery params: tag, skillTag, contentMode, sort, offset, scope
+ */
+export {};

package/dist/src/connection.test.js

@@ -0,0 +1,224 @@
+/**
+ * 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;
+    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) => {
+        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');
+        });
+    });
+});

package/index.ts

@@ -159,6 +159,72 @@ const plugin = {
         return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: `Unknown action: ${action}` }) }] };
       },
     });
+
+    // Register a tool for location-based agent discovery
+    api.registerTool?.({
+      name: 'a2a_discover_nearby',
+      description: 'Find A2A agents near a geographic location',
+      parameters: {
+        type: 'object',
+        properties: {
+          lat: {
+            type: 'number',
+            description: 'Latitude of search center',
+          },
+          lng: {
+            type: 'number',
+            description: 'Longitude of search center',
+          },
+          radius: {
+            type: 'number',
+            description: 'Search radius in kilometers (default: 10, max: 500)',
+          },
+          tag: {
+            type: 'string',
+            description: 'Filter by tag (e.g., "retail", "food")',
+          },
+          category: {
+            type: 'string',
+            description: 'Filter by category',
+          },
+          limit: {
+            type: 'number',
+            description: 'Maximum number of results (default: 20, max: 50)',
+          },
+        },
+        required: ['lat', 'lng'],
+      },
+      execute: async (_id, params) => {
+        const lat = params.lat as number;
+        const lng = params.lng as number;
+        const radius = params.radius as number | undefined;
+        const tag = params.tag as string | undefined;
+        const category = params.category as string | undefined;
+        const limit = params.limit as number | undefined;
+        
+        const manager = getA2AConnectionManager();
+        if (!manager) {
+          return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'A2A channel not running' }) }] };
+        }
+
+        if (!manager.isGopherHoleConnected()) {
+          return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: 'Not connected to GopherHole' }) }] };
+        }
+
+        try {
+          const agents = await manager.discoverNearby({ lat, lng, radius, tag, category, limit });
+          return { content: [{ type: 'text', text: JSON.stringify({ 
+            status: 'ok', 
+            center: { lat, lng },
+            radius: radius || 10,
+            count: agents.length,
+            agents 
+          }) }] };
+        } catch (err) {
+          return { content: [{ type: 'text', text: JSON.stringify({ status: 'error', error: (err as Error).message }) }] };
+        }
+      },
+    });
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gopherhole_openclaw_a2a",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "GopherHole A2A plugin for OpenClaw - connect your AI agent to the GopherHole network",
   "type": "module",
   "main": "dist/index.js",
@@ -8,6 +8,8 @@
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepublishOnly": "npm run build"
   },
   "clawdbot": {
@@ -35,8 +37,10 @@
     "uuid": "^10.0.0"
   },
   "devDependencies": {
+    "@types/node": "^25.5.0",
     "@types/uuid": "^10.0.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^1.6.0"
   },
   "peerDependencies": {
     "openclaw": "*"

package/src/connection.test.ts

@@ -0,0 +1,298 @@
+/**
+ * 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');
+    });
+  });
+});

package/src/connection.ts

@@ -427,7 +427,8 @@ export class A2AConnectionManager {
     skillTag?: string;
     contentMode?: string;
     sort?: string;
-    verified?: boolean;
+    owner?: string;      // Filter by organization/tenant name
+    verified?: boolean;  // Only show agents from verified organizations
     limit?: number;
     offset?: number;
     scope?: string;
@@ -451,6 +452,51 @@ export class A2AConnectionManager {
     return result?.agents || [];
   }
 
+  /**
+   * Discover agents near a geographic location
+   */
+  async discoverNearby(options: { 
+    lat: number;
+    lng: number;
+    radius?: number;
+    tag?: string;
+    category?: string;
+    limit?: number;
+    offset?: number;
+  }): Promise<Array<{
+    id: string;
+    name: string;
+    description?: string;
+    verified?: boolean;
+    tenantName?: string;
+    avgRating?: number;
+    location?: {
+      name: string;
+      lat: number;
+      lng: number;
+      country: string;
+    };
+    distance?: number;
+  }>> {
+    const result = await this.a2aRpc<{ agents: Array<{
+      id: string;
+      name: string;
+      description?: string;
+      verified?: boolean;
+      tenantName?: string;
+      avgRating?: number;
+      location?: {
+        name: string;
+        lat: number;
+        lng: number;
+        country: string;
+      };
+      distance?: number;
+    }> }>('x-gopherhole/agents.discover.nearby', options);
+
+    return result?.agents || [];
+  }
+
   /**
    * List connection status (for backward compatibility)
    */

package/tsconfig.json

@@ -13,5 +13,5 @@
     "forceConsistentCasingInFileNames": true
   },
   "include": ["index.ts", "src/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
 }

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.test.ts'],
+  },
+});