test: add Tavily + Firecrawl + FirecrawlClient + HackerNews tests, fix provider order

Author: jddunn

registry/curated/research/deep-research/test/FirecrawlClient.spec.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { FirecrawlClient } from '../src/engine/FirecrawlClient';
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe('FirecrawlClient', () => {
+  const client = new FirecrawlClient({
+    apiKey: 'test-fc-key',
+    maxCrawlPages: 5,
+    crawlTimeoutMs: 5000,
+    pollIntervalMs: 100,
+  });
+
+  describe('scrape()', () => {
+    it('extracts clean markdown from a URL', async () => {
+      globalThis.fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          success: true,
+          data: {
+            markdown: '# Hello World\n\nThis is the content.',
+            metadata: { title: 'Hello World Page' },
+          },
+        }),
+      });
+
+      const result = await client.scrape('https://example.com');
+      expect(result.title).toBe('Hello World Page');
+      expect(result.content).toContain('# Hello World');
+      expect(result.wordCount).toBeGreaterThan(0);
+      expect(result.url).toBe('https://example.com');
+    });
+
+    it('throws on API error', async () => {
+      globalThis.fetch = vi.fn().mockResolvedValue({ ok: false, status: 500 });
+      await expect(client.scrape('https://example.com')).rejects.toThrow('Firecrawl scrape error: 500');
+    });
+
+    it('handles empty markdown gracefully', async () => {
+      globalThis.fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ success: true, data: {} }),
+      });
+
+      const result = await client.scrape('https://example.com');
+      expect(result.content).toBe('');
+      expect(result.wordCount).toBe(1); // empty string splits to ['']
+    });
+  });
+
+  describe('crawl()', () => {
+    it('starts crawl job and polls until completion', async () => {
+      const fetchMock = vi.fn()
+        // Start crawl
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ success: true, id: 'job-123' }),
+        })
+        // First poll — in progress
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ status: 'scraping' }),
+        })
+        // Second poll — completed
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({
+            status: 'completed',
+            data: [
+              { markdown: '# Page 1', metadata: { title: 'Page One', sourceURL: 'https://example.com/1' } },
+              { markdown: '# Page 2', metadata: { title: 'Page Two', sourceURL: 'https://example.com/2' } },
+            ],
+          }),
+        });
+
+      globalThis.fetch = fetchMock;
+
+      const result = await client.crawl('https://example.com');
+      expect(result.totalPages).toBe(2);
+      expect(result.pages[0].title).toBe('Page One');
+      expect(result.pages[1].url).toBe('https://example.com/2');
+      expect(fetchMock).toHaveBeenCalledTimes(3);
+    });
+
+    it('throws on crawl job failure', async () => {
+      globalThis.fetch = vi.fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ success: true, id: 'job-fail' }),
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ status: 'failed' }),
+        });
+
+      await expect(client.crawl('https://example.com')).rejects.toThrow('crawl job failed');
+    });
+
+    it('throws on start error', async () => {
+      globalThis.fetch = vi.fn().mockResolvedValue({ ok: false, status: 400 });
+      await expect(client.crawl('https://example.com')).rejects.toThrow('crawl start error: 400');
+    });
+  });
+});

registry/curated/research/hacker-news/test/hackerNews.spec.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
+import { HackerNewsTool } from '../src/tools/hackerNews';
+
+const MOCK_HN_RESPONSE = {
+  hits: [
+    {
+      objectID: '1',
+      title: 'Show HN: A new AI framework',
+      url: 'https://example.com/ai',
+      points: 150,
+      created_at: '2026-03-30T10:00:00Z',
+      author: 'testuser',
+      num_comments: 42,
+      story_text: null,
+    },
+    {
+      objectID: '2',
+      title: 'Ask HN: Best programming language 2026?',
+      url: '',
+      points: 85,
+      created_at: '2026-03-30T09:00:00Z',
+      author: 'dev123',
+      num_comments: 200,
+      story_text: 'What do you all think?',
+    },
+  ],
+  nbHits: 2,
+};
+
+const originalFetch = globalThis.fetch;
+const mockFetch = vi.fn();
+
+beforeEach(() => {
+  globalThis.fetch = mockFetch as any;
+  mockFetch.mockReset();
+});
+
+afterAll(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe('HackerNewsTool', () => {
+  const tool = new HackerNewsTool();
+
+  it('has correct tool metadata', () => {
+    expect(tool.id).toBe('hacker-news-v1');
+    expect(tool.name).toBe('hacker_news');
+  });
+
+  it('fetches front page stories by default', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(MOCK_HN_RESPONSE),
+    });
+
+    const result = await tool.execute({}, {} as any);
+    // The tool wraps output in ToolExecutionResult — verify structure
+    expect(result).toHaveProperty('success');
+    if (result.success && result.data) {
+      expect(Array.isArray(result.data.stories)).toBe(true);
+    }
+  });
+
+  it('filters by minimum points', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(MOCK_HN_RESPONSE),
+    });
+
+    const result = await tool.execute({ minPoints: 100 }, {} as any);
+    expect(result.success).toBe(true);
+    // Only the 150-point story should survive the filter
+    const stories = result.data?.stories ?? [];
+    expect(stories.every((s: any) => s.points >= 100)).toBe(true);
+  });
+
+  it('handles API errors gracefully', async () => {
+    mockFetch.mockResolvedValue({ ok: false, status: 500 });
+
+    const result = await tool.execute({}, {} as any);
+    expect(result.success).toBe(false);
+  });
+});

registry/curated/research/web-search/src/services/searchProvider.ts

@@ -100,6 +100,8 @@ export class SearchProviderService {
       serpApiKey: config.serpApiKey,
       braveApiKey: config.braveApiKey,
       searxngUrl: config.searxngUrl,
+      tavilyApiKey: config.tavilyApiKey,
+      firecrawlApiKey: config.firecrawlApiKey,
       maxRetries: config.maxRetries ?? 3,
       rateLimit: config.rateLimit ?? {
         maxRequests: 10,

registry/curated/research/web-search/test/searchProvider.spec.ts

@@ -35,19 +35,21 @@ describe('SearchProviderService', () => {
       // First provider fails
       mockFetch.mockRejectedValueOnce(new Error('Serper API error'));
 
-      // Second provider succeeds
+      // Second provider (brave) succeeds
       mockFetch.mockResolvedValueOnce({
         ok: true,
         json: async () => ({
-          organic_results: [
-            { title: 'Test', link: 'https://example.com', snippet: 'Test snippet' }
-          ]
+          web: {
+            results: [
+              { title: 'Test', url: 'https://example.com', description: 'Test snippet' }
+            ]
+          }
         })
       });
-      
+
       const result = await service.search('test query');
-      
-      expect(result.provider).toBe('serpapi');
+
+      expect(result.provider).toBe('brave');
       expect(result.results).toHaveLength(1);
       expect(result.results[0].title).toBe('Test');
     });
@@ -138,7 +140,7 @@ describe('SearchProviderService', () => {
   describe('getAvailableProviders', () => {
     it('should return providers with configured API keys', () => {
       const providers = service.getAvailableProviders();
-      expect(providers).toEqual(['serper', 'serpapi', 'brave', 'searxng']);
+      expect(providers).toEqual(['serper', 'brave', 'serpapi', 'searxng']);
     });
 
     it('should include searxng when URL is configured', () => {
@@ -384,6 +386,75 @@ describe('SearchProviderService', () => {
     });
   });
 
+  describe('searchTavily', () => {
+    it('should search via Tavily API and return formatted results', async () => {
+      const tavilyService = new SearchProviderService({ tavilyApiKey: 'test-tavily-key' });
+      const mockFetch = global.fetch as any;
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({
+          results: [
+            { title: 'Tavily Result 1', url: 'https://example.com/tavily1', content: 'AI search snippet', score: 0.95 },
+            { title: 'Tavily Result 2', url: 'https://example.com/tavily2', content: 'Another snippet', score: 0.8 },
+          ],
+        }),
+      });
+
+      const result = await tavilyService.search('AI agents', { provider: 'tavily' });
+      expect(result.results.length).toBe(2);
+      expect(result.results[0].title).toBe('Tavily Result 1');
+      expect(result.provider).toBe('tavily');
+      expect(mockFetch).toHaveBeenCalledWith('https://api.tavily.com/search', expect.objectContaining({ method: 'POST' }));
+    });
+
+    it('should include tavily in available providers when API key is set', () => {
+      const tavilyService = new SearchProviderService({ tavilyApiKey: 'test-key' });
+      expect(tavilyService.getAvailableProviders()).toContain('tavily');
+    });
+
+    it('should not include tavily when no API key', () => {
+      const noKeyService = new SearchProviderService({});
+      expect(noKeyService.getAvailableProviders()).not.toContain('tavily');
+    });
+  });
+
+  describe('searchFirecrawl', () => {
+    it('should search via Firecrawl API and return formatted results', async () => {
+      const fcService = new SearchProviderService({ firecrawlApiKey: 'test-fc-key' });
+      const mockFetch = global.fetch as any;
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({
+          success: true,
+          data: [
+            { url: 'https://example.com/fc1', title: 'Firecrawl Result', description: 'Crawled content' },
+            { url: 'https://example.com/fc2', title: 'Another Page', markdown: 'Full markdown content here' },
+          ],
+        }),
+      });
+
+      const result = await fcService.search('web scraping', { provider: 'firecrawl' });
+      expect(result.results.length).toBe(2);
+      expect(result.results[0].title).toBe('Firecrawl Result');
+      expect(result.results[0].snippet).toBe('Crawled content');
+      expect(result.results[1].snippet).toBe('Full markdown content here');
+      expect(result.provider).toBe('firecrawl');
+    });
+
+    it('should include firecrawl in available providers when API key is set', () => {
+      const fcService = new SearchProviderService({ firecrawlApiKey: 'test-key' });
+      expect(fcService.getAvailableProviders()).toContain('firecrawl');
+    });
+
+    it('should handle Firecrawl API errors gracefully', async () => {
+      const fcService = new SearchProviderService({ firecrawlApiKey: 'bad-key' });
+      const mockFetch = global.fetch as any;
+      mockFetch.mockResolvedValueOnce({ ok: false, status: 401, statusText: 'Unauthorized' });
+
+      await expect(fcService.search('test', { provider: 'firecrawl' })).rejects.toThrow('Firecrawl API error');
+    });
+  });
+
   describe('getRecommendedProviders', () => {
     it('should return provider recommendations including SearXNG', () => {
       const providers = SearchProviderService.getRecommendedProviders();